"::"之间有什么区别." 和c ++中的" - >"

Question

可能重复:
我何时使用点,箭头或双冒号来引用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++中,您可以使用不同的运算符访问字段或方法,具体取决于它的类型:

• ClassName :: FieldName:类public static字段和方法
• 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();

Answer 3

非常简单的::是作用域操作符,.是访问操作符(我忘记实际名称是什么？),并且->是解引用箭头.

:: - 范围功能.也就是说,它让编译器知道函数所在的类,以及如何调用它.如果您使用此运算符来调用函数,则该函数是一个static函数.

. - 这允许访问已创建对象上的成员函数.例如,在具有类型的实例化对象上Foo x; x.bar()调用该方法.您还可以使用它来访问公共类变量.bar()xFoo

->- 基本上是相同的东西,.除了这适用于指针类型.本质上,它取消引用指针,而不是调用..使用它相当于(*ptr).method()

Answer 4

尽管来自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 5

你有一个指向对象的指针.因此,您需要访问指针指向的对象的字段.要取消引用您使用的指针*,并访问一个字段,您可以使用.,因此您可以使用:

cout << (*kwadrat).val1;

请注意,括号是必要的.这个操作很常见,很久以前(当C年轻时)他们决定创建一个"速记"方法:

cout << kwadrat->val1;

这些被定义为相同.如您所见,->基本上只是将a *和a组合.成一个操作.如果直接处理对象或对象的引用,则可以先使用.而不取消引用指针:

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++历史的早期这是不允许的,但意思是明确的,所以他们决定允许它.