91

我创建了一个名为Kwadrat. 该类具有三个int字段。我的开发环境建议我通过&运算符从Kwadrat创建的对象访问字段。我尝试了这两个运算符，发现运算符能够成功访问对象字段中的数据，但是对于运算符来说却不能这样说。我还发现操作员也将访问类成员。我很困惑，不明白为什么有三个成员用于访问对象成员和/或方法。有人可以向我解释这三个运营商之间有什么区别吗？::->->->.

          1.->

          2.::

          3..



    #include <iostream>

    using namespace std;

    class Kwadrat{

    public: 
        int val1,
            val2,
            val3;

        Kwadrat(int val1, int val2, int val3)
        {
            this->val1 = val1; // Working
            this.val2 = val2;  // Doesn't Work!
            this::val3 = val3; // Doesn't Work!
        }
    };


    int main()
    {
        Kwadrat* kwadrat = new Kwadrat(1,2,3);

        cout<<kwadrat->val1<<endl;
        cout<<kwadrat->val2<<endl;
        cout<<kwadrat->val3<<endl;

        return 0;
    }
4

8 回答 8

170

1.通过to对象->访问对象成员变量和方法pointer

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

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

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

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

int some_val = Foo::static_var;
Foo::static_method();
int max_int = std::numeric_limits<int>::max();
于 2012-08-10T13:35:59.737 回答
29

在 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();
于 2012-08-10T13:36:44.150 回答
18

说得非常简单::，就是作用域操作符，.就是访问操作符（我忘了实际的名字是什么？），还有->解引用箭头。

::- 范围函数。也就是说，它让编译器知道函数所在的类以及如何调用它。如果你使用这个操作符来调用一个函数，这个函数就是一个static函数。

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

->- 基本上与指针类型相同，.但它适用于指针类型。本质上，它取消引用指针，而不是调用.。使用它相当于(*ptr).method()

于 2012-08-10T13:37:44.307 回答
8

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

cout << (*kwadrat).val1;

请注意，括号是必需的。这种操作很常见，以至于很久以前（当 C 还年轻的时候）他们决定创建一个“速记”方法来做这件事：

cout << kwadrat->val1;

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

Kwadrat kwadrat2(2,3,4);

cout << kwadrat2.val1;

是::范围解析运算符。当您只需要限定name时使用它，但您根本不处理单个对象。这主要是访问静态数据成员：

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.

在这种情况下，因为xis static，它不与 的任何特定实例相关联something。事实上，即使没有创建该类型对象的实例，它也会存在。在这种情况下，我们可以使用范围解析运算符访问它：

something::x = 10;

std::cout << something::x;

但是请注意，也允许访问静态成员，就好像它是特定对象的成员一样：

something s;

s.x = 1;

至少如果有记忆的话，在 C++ 的早期历史中这是不允许的，但含义是明确的，所以他们决定允许它。

于 2012-08-10T13:43:12.150 回答
7

尽管来自 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;
}
于 2012-08-10T13:41:57.160 回答
3

'::' 用于静态成员。

于 2012-08-10T13:36:29.720 回答
3

-> 用于指向类实例的指针

. 用于类实例

:: 用于类名 - 例如在使用静态成员时

于 2012-08-10T13:36:37.577 回答
1

其他人已经回答了不同的语法，但请注意，当你做你的时候couts，你只使用->：

int main()
{
    Kwadrat* kwadrat = new Kwadrat(1,2,3);
    cout<<kwadrat->val1<<endl;
    cout<<kwadrat->val2<<endl;
    cout<<kwadrat->val3<<endl;
    return 0;
}
于 2012-08-10T13:37:35.213 回答