C++ “之间的区别是什么？”&引用&引用&引用；及-&燃气轮机&引用；在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;
}

#包括
使用名称空间std；
夸德拉特级{
公众：
int val1，val2，val3；
Kwadrat（内瓦1、内瓦2、内瓦3）
{
这->val1=val1；
//this.val2=val2；
//这：：val3=val3；
}
};
int main（）
{
Kwadrat*Kwadrat=新Kwadrat（1,2,3）；
cout1.
->
用于通过指向对象的
指针访问对象成员变量和方法

Foo *foo = new Foo();
foo->member_var = 10;
foo->member_func();

2.
用于通过对象
实例访问对象成员变量和方法

Foo foo;
foo.member_var = 10;
foo.member_func();

3.
：
用于访问
类/结构
或
命名空间
的静态变量和方法。它还可用于从另一个作用域访问变量和函数（实际上，在这种情况下，类、结构、命名空间都是作用域）

intsome\u val=Foo:：static\u var；
Foo:：static_method（）；
int max_int=std:：numeric_limits:：max（）；
“：：”用于静态成员。
->用于指向类实例的指针

.用于类实例

<>：是用于类名的，例如，在C++中使用静态成员
时，可以使用不同的运算符访问字段或方法，这取决于它的类型：


ClassName:：FieldName：类公共静态字段和方法
ClassInstance.FieldName：通过类引用访问公共字段（或方法）
ClassPointer->FieldName：访问公共字段（或方法）取消引用类指针

注意：：应该与类名而不是类实例一起使用，因为静态字段或方法对于类的所有实例都是通用的

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();

其他人回答了不同的语法，但请注意，当你在做
演讲时，你只使用
->
：

int main()
{
    Kwadrat* kwadrat = new Kwadrat(1,2,3);
    cout<<kwadrat->val1<<endl;
    cout<<kwadrat->val2<<endl;
    cout<<kwadrat->val3<<endl;
    return 0;
}

intmain（）
{
Kwadrat*Kwadrat=新Kwadrat（1,2,3）；
coutPut very simple
：
是作用域运算符，
是访问运算符（我忘了实际名称了？），而
->
是取消引用箭头

：：
-定义函数的作用域。也就是说，它让编译器知道函数所在的类，从而知道如何调用它。如果使用此运算符调用函数，则函数是一个
静态
函数

-这允许访问已创建对象上的成员函数。例如，
Foo x；x.bar（）
调用实例化对象
x
上的方法
bar（）
，该对象的类型为
Foo
。您还可以使用它访问公共类变量

->
-本质上与
相同，只是它适用于指针类型。本质上，它取消指针引用，而不是调用
。使用它相当于
（*ptr）.method（）
这三个操作符具有相关但不同的含义，尽管IDE中有误导性的注释

：
运算符称为范围解析运算符，用于从命名空间或类获取其成员之一

和
->
运算符用于访问对象实例的成员，仅在创建对象实例后才起作用。如果您有实际对象（或对对象的引用，在声明的类型中用
&
声明），则使用
，如果有指向对象的指针（在声明的类型中用
*
声明），则使用
->

此
对象始终是指向当前实例的指针，因此
->
运算符是唯一有效的运算符

示例：

// 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;
}

您有一个指向对象的指针。因此，您需要访问指针指向的对象的字段。若要取消引用指针，请使用
*
，若要访问字段，请使用
，因此您可以使用：

cout << (*kwadrat).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
是
静态的
，因此它与
某物的任何特定实例都不关联。事实上，即使没有创建该类型对象的实例，它也会存在。在这种情况下，我们可以使用范围解析操作符访问它：

something::x = 10;

std::cout << something::x;

<>至少如果记忆服务，C++历史上的早期是不允许的，但是意思是明确的，所以他们决定允许它。
也见：重新开放选民：通常我惩罚那些无意识的亲密选民，但是现在，这个问题真的是一个重复。任何新的见解都可以添加到它重复的问题。e的访问方式与普通变量类似。您可以对对象实例执行
ref=2；
或
ref.x=5；
操作。我知道，我只是暗示您可能希望将其添加到2中。您可以对其中任何一个进行引用。引用始终保持相同的类型。它实际上是不同的主题。列表不全面，也不100%正确。作用域运算符可以在更多情况下用于限定实体，即使它们不是静态的：
void-derived:：f（）{base:：f（）；}
甚至可以与其他两种运算符组合使用：
obj.base:：f（）
，访问运算符可以用于访问静态：
struct test{static const int i=1；}；test t；int j=t.i；
…@Andrew：我们的特定偏好与
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.

something::x = 10;

std::cout << something::x;

something s;

s.x = 1;