C++ 在类定义中，类成员是否需要以`class:::`作为前缀？

在定义类

cls

时，在

cls

自己的定义中使用类名时，是否有必要（或良好做法）为成员添加类名

cls:：

，还是隐式添加？例如

class cls {
    int x;
    void foo();
    void bar();
}
void cls::foo() {
    x++;    // or use cls::x?
    bar();  // or cls::bar()?
}

如果是这样，那么创建一个类

cls

是否自动意味着它也是一个名称空间（因为我认为

：

操作符只用于名称空间）

编辑（跟进）：

---

如果我们不使用

cls:：

或

this->

，那么如果我的源代码在类外也有一个变量

x

，该怎么办？

cls:：foo（）

如何知道x++指的是哪一个？

Nop。至少不是这样

您可以使用

this->

让读者更清楚地了解它。然而，

：

是另一回事。它用于访问静态成员变量或函数

int x;                  // Global x
namespace ot { int x; } // another x
class cls {
    int x;              // Normal member
    static int y;       // Static member
    void foo();
    static void bar();  // Static member function
}
void cls::foo() {
    this->x++;    // Modify own x. 
    x++           // Modify own x. This has implicit this->
    ::x++;        // Modify the global x.
    ot::x++;      // Modify the x in namespace ot.
    cls::y++;     // modify the static member
    cls::bar();   // static member function. same as bar()
}

---

没有。至少不是这样

您可以使用

this->

让读者更清楚地了解它。然而，

：

是另一回事。它用于访问静态成员变量或函数

int x;                  // Global x
namespace ot { int x; } // another x
class cls {
    int x;              // Normal member
    static int y;       // Static member
    void foo();
    static void bar();  // Static member function
}
void cls::foo() {
    this->x++;    // Modify own x. 
    x++           // Modify own x. This has implicit this->
    ::x++;        // Modify the global x.
    ot::x++;      // Modify the x in namespace ot.
    cls::y++;     // modify the static member
    cls::bar();   // static member function. same as bar()
}

上面显示的代码定义了一个类，但最初只声明了成员函数（然后才定义它们）。我之所以提到这一点，是因为术语对于有效沟通非常重要

如果内联定义类成员，则不使用范围解析运算符

：

，例如：

class cls {
    void hello() { cout << "Hello world"; }
};

只要有多个成员具有相同的名称，并且编译器将非限定名称解析为您想要的成员以外的名称，就需要限定名称。示例：

void cls::foo(int x) {
    x++;       // increments the argument
    cls::x++;  // increments the member
    this->x++; // also increments the member
}

还要考虑到

cls

可能来自

base

，而

base

也可能定义

x

。在这种情况下，其工作原理如下：

void cls::foo() {
    x++;       // increments foo::x
    cls::x++;  // increments foo::x
    base::x++; // increments base::x
}

上面显示的代码定义了一个类，但最初只声明了成员函数（然后才定义它们）。我之所以提到这一点，是因为术语对于有效沟通非常重要

如果内联定义类成员，则不使用范围解析运算符

：

，例如：

class cls {
    void hello() { cout << "Hello world"; }
};

只要有多个成员具有相同的名称，并且编译器将非限定名称解析为您想要的成员以外的名称，就需要限定名称。示例：

void cls::foo(int x) {
    x++;       // increments the argument
    cls::x++;  // increments the member
    this->x++; // also increments the member
}

还要考虑到

cls

可能来自

base

，而

base

也可能定义

x

。在这种情况下，其工作原理如下：

void cls::foo() {
    x++;       // increments foo::x
    cls::x++;  // increments foo::x
    base::x++; // increments base::x
}

---

用类名显式限定成员变量的使用是个坏主意。充其量，它是不必要的（或者在必要的地方，这个->成员更好），并且禁止重构（如果重命名类，会有更多的地方需要更改），最坏的情况下，它会引入错误，因为对虚拟函数的限定调用不会分派到重写版本。

用类名显式限定成员变量的使用是个坏主意。充其量，它是不必要的（或者在必要的地方，这个->成员更好），并且禁止重构（如果重命名类，会有更多的地方需要更改），最坏的情况下，它会引入错误，因为对虚拟函数的限定调用不会分派到重写版本。

那么，如果我的源代码在类之外也有一个变量

x

？cls:：foo（）将如何使用如果我们不使用

这个
？
：：
可以与非静态数据和函数成员一起使用，并且可以用于禁用虚拟分派。对于嵌套类也是这样吗？@MiloChen如果您想访问嵌套类
嵌套
的静态成员，那么您可以这样做
Nest:：x++
。如果要访问嵌套类的非静态成员，则需要该类的对象，例如
nestednt；nt.x++
最后，从一个嵌套类到另一个嵌套类如何？i、 e.如果
cls
在同一级别上有两个子类。那么如果我的源代码在类外也有一个变量
x
，该怎么办？cls:：foo（）将如何使用如果我们不使用
这个
？
：：
可以与非静态数据和函数成员一起使用，并且可以用于禁用虚拟分派。对于嵌套类也是这样吗？@MiloChen如果您想访问嵌套类
嵌套
的静态成员，那么您可以这样做
Nest:：x++
。如果要访问嵌套类的非静态成员，则需要该类的对象，例如
nestednt；nt.x++
最后，从一个嵌套类到另一个嵌套类如何？i、 e.如果
cls
在同一级别上有两个子类。通常在成员变量的名称前加前缀，如“x”，通常加上“m_x”（即“m_x”）。这有助于将局部变量与类成员区分开来，从而消除了您可能希望用类名定义成员范围的一个原因。在成员变量的名称（如“x”）前面加上前缀通常是“m_x”（即“m_x”）。这有助于区分局部变量和类成员，从而消除了您可能希望用类名来限定成员范围的一个原因