这是模棱两可的还是完全没问题？

发布于 2024-08-19 05:51:56 字数 328 浏览 3 评论 0原文

这段代码是否含糊不清或者是否完全正确（通过标准批准/对现有的任何编译器具有一致的行为）？

struct SCustomData {
    int nCode;
    int nSum;
    int nIndex;
    SCustomData(int nCode, int nSum, int nIndex)
        : nCode(nCode)
        , nSum(nSum)
        , nIndex(nIndex)
    {}
};

编辑：
是的，我指的是成员变量与构造函数的形参同名。

原文

Is this code ambiguous or is it perfectly fine (approved by standards/has consistent behavior for any compilers in existence)?

struct SCustomData {
    int nCode;
    int nSum;
    int nIndex;
    SCustomData(int nCode, int nSum, int nIndex)
        : nCode(nCode)
        , nSum(nSum)
        , nIndex(nIndex)
    {}
};

edit:
yes, I am referring to the fact that the member variables have the same name with formal parameters of the constructor.

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

月牙弯弯 2024-08-26 05:51:56

不，在这种情况下没有歧义，但请考虑以下内容：

struct SCustomData {
//...
    void SetCode(int nCode)
    {
            //OOPS!!! Here we do nothing!
            //nCode = nCode;

            //This works but still error prone
            this->nCode = nCode;
    }
};

您应该注意现有的编码风格之一。例如，Google C++ 编码样式中的一般命名规则或阅读优秀文章Herb 所著的《C++ 编码标准：101 条规则、指南和最佳实践》一书萨特和安德烈·亚历山德雷斯库。

No, in this case there are no ambiguity, but consider following:

struct SCustomData {
//...
    void SetCode(int nCode)
    {
            //OOPS!!! Here we do nothing!
            //nCode = nCode;

            //This works but still error prone
            this->nCode = nCode;
    }
};

You should draw attention to one of existing coding styles. For instance General Naming Rule in Google C++ Coding Styles or read excellent book "C++ Coding Standards: 101 Rules, Guidelines, and Best Practices" by Herb Sutter and Andrei Alexandrescu.

回复收藏 0 原文

浮世清欢 2024-08-26 05:51:56

你的例子（对我来说）是明确的，但这不是一个好的做法，因为它很快就会变得非常模糊。

我已经很长一段时间没有在愤怒中写过任何 C++ 了，所以我猜下面会做什么。
你知道它会做什么吗？你确定吗？

class Noddy
{
    int* i;
    Noddy(int *i)
    : i(i)
    {
        if(i == NULL)
            i = new int;
    }
};

Your example is unambiguous (to me), but it's not good practise, because it can quickly become as ambiguous as hell.

It's a long while since I've written any C++ in anger, so I'm guessing what the following will do.
Do you KNOW what it will do? Are you sure?

class Noddy
{
    int* i;
    Noddy(int *i)
    : i(i)
    {
        if(i == NULL)
            i = new int;
    }
};

回复收藏 0 原文

话少情深 2024-08-26 05:51:56

如果您指的是对成员和构造函数参数使用相同的名称，那么这绝对没问题。然而，您可能会发现有些人出于某种原因坚持认为这是不好的做法。

如果您需要访问构造函数主体中的成员，那么您需要小心 - 要么为参数提供不同的名称，要么使用 this-> 来访问成员。

如果您指的是使用伪匈牙利疣来提醒人们整数就是整数，那么这在技术上是允许的，但绝对没有任何好处，并且会使代码更难以阅读。请不要这样做。

回复收藏 0 原文

清醇 2024-08-26 05:51:56

一般来说，我在构造函数中使用下划线为实例变量添加前缀，并在没有任何前缀的情况下为命名参数添加前缀。至少，这将消除参数与实例变量的歧义。如果在构造函数体内进行初始化，它也会让生活变得不那么忙碌。

struct SCustomData {
    int _nCode;
    int _nSum;
    int _nIndex;
    SCustomData(int nCode, int nSum, int nIndex)
        : _nCode(nCode), _nSum(nSum), _nIndex(nIndex)
    {}
};

// Alternatively
struct SCustomData {
    int _nCode;
    SCustomData(int nCode)
    {
        this->_nCode = nCode;
    }
};

我不喜欢按照问题中编写的方式堆叠变量。我喜欢节省垂直空间，而且从左到右阅读也更容易。（这是我个人的喜好，不是强制性规则或类似的东西。）

In general, I've prefixed instance variables with underscores and named parameters in the constructor without any prefixes. At the very least, this will disambiguate your parameters from your instance variables. It also makes life less hectic if initializing within the body of the constructor.

struct SCustomData {
    int _nCode;
    int _nSum;
    int _nIndex;
    SCustomData(int nCode, int nSum, int nIndex)
        : _nCode(nCode), _nSum(nSum), _nIndex(nIndex)
    {}
};

// Alternatively
struct SCustomData {
    int _nCode;
    SCustomData(int nCode)
    {
        this->_nCode = nCode;
    }
};

I don't like stacking the variables the way it was written in the question. I like to save vertical space, and it's also easier for me to read left-to-right. (This is a personal preference of mine, not a mandatory rule or anything like that.)

回复收藏 0 原文