在C++；？ 这个C++方法中，我认为这个方法不返回任何东西，所以前缀是“代码>空格”，：：/Cuth>告诉< WeeLyDATA < /COD>和 ReVySeq（String和Seq）< /代码>之间的关系？谢谢

weight\u data

是一个或类名称。

void

是返回类型

：

是范围解析运算符，因此它意味着

rev_seq

在

weight_data

的范围内<代码> WeyTyDATA < /C>可以是命名空间或类（基于您所给出的，不可能说出哪个）.C++中的

< P>

• A：：B

  表示

  B

  是

  命名空间

  或

  类

  类型

  A

  中的标识符

• A.B

  表示

  B

  是

  结构

  ，

  类

  ，或

  联合

  类型的成员，其实例由对象或引用

  A

  引用，以及

• A->B

  表示

  B

  是

  结构

  ，

  类

  ，或

  联合

  类型的成员，其实例由指针

  A

  引用。（它相当于

  （*A.B

  ）

在其他一些语言中，这三种情况都只包含在

中

---

注意，C++中，成员函数不必在类定义中实现（定义）。（如果是，它们是隐式的

内联的

），它们可以而且通常在单独的实现（

.cpp

）文件中实现。这样做的好处是，当您更改类的一个成员函数的实现时，并非所有的类用户都需要重新编译。因此，除非

weight_data

是

名称空间

名称，否则

void weight_data:：rev_seq（string&seq）{…}

是类之外的类成员的定义

行

void weight\u data:：rev_seq（string&seq）

告诉编译器这是

rev_seq（string&seq）

成员函数在

weight\u data

中的定义。如果这只是说

void revu seq（string&seq）{…}

，编译器会认为定义了一个非成员函数，而不是

weight\u data

类的

revu seq（string&seq）

成员函数

void weight_data::rev_seq(string &seq){ 
//TODO
std::reverse(seq.begin(), seq.end());
}

它还可能意味着

rev_str

引用的函数是命名空间

weight_data

的一部分

class weight_data
{
    void rev_str(string &seq);
}

---

我只想再添加两个关于以下内容的有趣内容：

a） 运算符：：是一元运算符和二元运算符

namespace weight_data
{
    void rev_str(string &seq);
}

b） $10.3/12-“使用范围运算符（5.1）的显式限定会抑制虚拟调用机制。”

结构A{

---

virtual void f（）{cout“weight_data”被定义为a.hpp文件中的一个结构，使用一个名为“rev_seq”的方法（未实现），然后在a.cpp文件中，这个方法被称为我在问题中所问的方法part@ladyfafa：

void weight_data:：rev_seq（string&seq）{…}<代码>是该成员函数的实现。@ SBI：好的，我明白了，它可以不止一次地实现吗？即在不同的CPP文件中，对不同的函数“ReVySeq”进行不同的实现，即“WebIyDATA”@ LADYFAFA：NO-C++具有“一个定义规则”（ODR），它表示任何一个函数只能被实现。（已定义）一次。有一些类型的异常（例如，对于内联函数），但它们只是一种类型的异常，并且无论如何都不适合任何异常。@ladyfafafa：通常，定义只能出现一次。（请参阅）但是，不同的成员函数可以在不同的实现文件中实现。此外，根据某些前提条件（例如，编译程序的平台），条件编译可用于包含同一实体的多个定义之一。这非常全面，非常感谢！注意：
*
和
->
运算符可以重载。通常它们只能重载迭代器和智能指针之类的对象。设计糟糕的代码可能会重载这些运算符。@Brian:这是一个非常好的观点！请注意，
weight\u data
可能是一个错误另外，我想你是想写“如果这只是说
void rev_seq（string&seq）{…}
..”。感谢sbi提醒我这一点。：：在PHP中被称为Paamayim Nekudotayim。
struct A{
   int m;
};

int x;
int main(){
   ::x;                     // Unary
   int (A::*p) = &A::m;     // Binary
}

struct A{
   virtual void f(){cout << 1;}
};

struct B : A{
   void f(){cout << 2;}
};

int x;
int main(){
   B b;
   A &ra = b;
   ra.f();     // dynamic binding, prints 2
   ra.A::f();  // suppress VF mechanism, prints 1.
}