可能重复：
我什么时候用点，箭头或双冒号指在C ++类的成员？
我创建了一个叫做Kwadrat类的，我有内部的三个int字段。 代码块给我意见，我可以进入对象的字段:: ， . 和-> 。 箭头是一个只有工作，但为什么呢？ 什么是这三个之间的区别？
#include <iostream>
using namespace std;
class Kwadrat{
public:
int val1, val2, val3;
Kwadrat(int val1, int val2, int val3)
{
this->val1 = val1;
//this.val2 = val2;
//this::val3 = val3;
}
};
int main()
{
Kwadrat* kwadrat = new Kwadrat(1,2,3);
cout<<kwadrat->val1<<endl;
cout<<kwadrat->val2<<endl;
cout<<kwadrat->val3<<endl;
return 0;
}
Answer 1:
1. ->用于通过访问对象的成员变量和方法pointer到对象
Foo *foo = new Foo();
foo->member_var = 10;
foo->member_func();
2 . 用于经由对象访问对象的成员变量和方法instance
Foo foo;
foo.member_var = 10;
foo.member_func();
3. ::访问静态变量和方法的class/struct或namespace 。 它也可以被用于从另一个范围（实际上类，结构，命名空间是在这种情况下，范围）访问的变量和函数
int some_val = Foo::static_var;
Foo::static_method();
int max_int = std::numeric_limits<int>::max();
Answer 2:
在C ++中，你可以访问字段或方法，使用不同的运营商，这取决于它的类型：
- 类名::字段名 ：类公共静态字段和方法
- ClassInstance.FieldName：通过类引用访问一个公共字段（或方法）
- ClassPointer->字段名 ：访问公共字段（或方法）解引用类指针
需要注意的是::应该与类名，而不是一个类的实例中使用，因为静态字段或方法是常见的一类的所有实例。
class AClass{
public:
static int static_field;
int instance_field;
static void static_method();
void method();
};
那么你访问是这样的：
AClass instance;
AClass *pointer = new AClass();
instance.instance_field; //access instance_field through a reference to AClass
instance.method();
pointer->instance_field; //access instance_field through a pointer to AClass
pointer->method();
AClass::static_field;
AClass::static_method();
Answer 3:
把很简单::是作用域运算符， . 是接入运营商（我忘了实际名称是什么？），和->是解引用箭头。
:: -作用域的功能。 也就是说，它可以让编译器知道函数住在什么类，因此，如何调用它。 如果您正在使用该运营商调用一个函数，该函数是一个static函数。
. - 这将允许访问一个成员函数已经创建的对象上。 例如， Foo x; x.bar() Foo x; x.bar()调用方法bar()上实例化的对象x ，其具有类型Foo 。 您也可以用它来访问公共类变量。
-> -从本质上同样的事情. 除了这个工程上指针类型。 在本质上它取消引用指针，比电话. 。 使用这相当于(*ptr).method()
Answer 4:
你有一个指向对象。 因此，你需要访问点音符所指向的对象的字段。 取消引用您使用指针* ，并访问一个字段，您可以使用. ，所以你可以使用：
cout << (*kwadrat).val1;
请注意，括号是必需的。 这种操作是很常见的是很久以前（当C是年轻的），他们决定建立这样做的“速记”的方法：
cout << kwadrat->val1;
这些被定义为是相同的。 正如你所看到的， ->基本上只是结合了*和. 成单个操作。 如果你是直接与对象或对象的引用处理，你可以使用. 不首先解引用指针：
Kwadrat kwadrat2(2,3,4);
cout << kwadrat2.val1;
该::是作用域运算符。 它是用来当你只需要限定名称 ，但你不能与一个单独的对象打交道的。 这将是主要访问静态数据成员：
struct something {
static int x; // this only declares `something::x`. Often found in a header
};
int something::x; // this defines `something::x`. Usually in .cpp/.cc/.C file.
在这种情况下，由于x是static ，它不与任何特定的实例相关联something 。 事实上，它会存在，即使没有该类型对象的实例已创建。 在这种情况下，我们可以用范围解析运算符访问：
something::x = 10;
std::cout << something::x;
请注意，但是，它也可以访问静态成员，如果它是一个特定对象的成员：
something s;
s.x = 1;
至少如果没有记错，在C的早期历史++这是不允许的，但意义是明确的，所以他们决定允许它。
Answer 5:
，三大运营商都相关，但含义不同，尽管从IDE误导音符。
该::操作被称为范围解析操作符 ，它是用来从一个命名空间或类成员一个拿到。
的. 和->操作符是用于访问对象实例的成员，只有创建一个对象实例后进场。 您可以使用. 如果有一个实际的对象（或该对象的引用，声明了&在声明的类型），并使用->如果你有一个指针的对象（具有声明*在声明的类型）。
在this对象始终是一个指向当前实例，因此，为什么->运算符是唯一可行的。
例子：
// In a header file
namespace Namespace {
class Class {
private:
int x;
public:
Class() : x(4) {}
void incrementX();
};
}
// In an implementation file
namespace Namespace {
void Class::incrementX() { // Using scope resolution to get to the class member when we aren't using an instance
++(this->x); // this is a pointer, so using ->. Equivalent to ++((*this).x)
}
}
// In a separate file lies your main method
int main() {
Namespace::Class myInstance; // instantiates an instance. Note the scope resolution
Namespace::Class *myPointer = new Namespace::Class;
myInstance.incrementX(); // Calling a function on an object instance.
myPointer->incrementX(); // Calling a function on an object pointer.
(*myPointer).incrementX(); // Calling a function on an object pointer by dereferencing first
return 0;
}
Answer 6:
Answer 7:
- >是指向一个类的实例
。 是类实例
::是类名 - 例如使用静态构件时
Answer 8:
其他人已经回答了不同的语法，但是请注意，当你做你的couts ，你只使用-> ：
int main()
{
Kwadrat* kwadrat = new Kwadrat(1,2,3);
cout<<kwadrat->val1<<endl;
cout<<kwadrat->val2<<endl;
cout<<kwadrat->val3<<endl;
return 0;
}
文章来源: What is the difference between “::” “.” and “->” in c++ [duplicate]
