关于c ++：为什么我们使用’this-＆gt;’


Why do we use 'this->' and not 'this.' to access members?

我正在看一个人在C++中为脸谱网制作的图书馆。头文件如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
#ifndef __FACEBOOK_H__
#define __FACEBOOK_H__

/**
 * Facebook Class
 * Joel Seligstein
 * Last mod: Aug 22, 2006
 *
 * This is the beginnings of a facebook class set and REST client.  Its not documented
 * yet nor nearly complete.  But this is a release to demonstrate its usefulness.  
 * Please email [email protected] with suggestions or additions.
 *
 * TODO: Create classes/parsers for each request type
 * TODO: Linux URL launcher
 */

//uncomment to have verbose output turned on
//#define fb_debug 1

//define which platform you're compiling for
#define fb_windows 1
//#define fb_linux 1

#include <string>
#include <sstream>
#include <list>
using namespace std;

#ifdef fb_windows
#include <windows.h>
#endif

#include"curl/curl.h"
#include"xmlParser/xmlParser.h"
#include"md5.h"

class facebook
{
    public:
        //app/session vars
        string api_key;
        string secret;
        string token;
        string server;
        string session_key;
        string session_secret;
        string uid;
        bool has_session;

        facebook( string my_key, string my_secret, string my_server );
        bool authenticate( );
        bool request( string method, list<string> params, string *res );
        bool load_token( );
        void launch_login( string url );
        bool get_session( );
        void clean_up( );

    private:
        //curl info
        CURL *curl;
        CURLcode res;
        int call_id;

        //internal functions
        string get_signature( list<string> params );
        static string md5( string str );
        static string get_param_string( list<string> params, bool separate );
        static size_t write_callback( void *ptr, size_t size, size_t nmemb, void *userp );
};

#endif //__FACEBOOK_H__

然后在cpp文件中，我的问题是关于这个，下面是构造函数：

1
2
3
4
5
6
7
8
facebook::facebook( string my_key, string my_secret, string my_server )
{
    this->api_key = my_key;
    this->secret = my_secret;
    this->server = my_server;
    this->has_session = false;
    this->call_id = 0;
}

他们为什么使用->运算符而不是.？

我对->直接访问内存中该类型的属性和方法的理解有限，但我感到困惑，因为无知，我希望看到：

1
2
3
4
5
6
7
8
facebook::facebook( string my_key, string my_secret, string my_server )
{
    this.api_key = my_key;
    this.secret = my_secret;
    this.server = my_server;
    this.has_session = false;
    this.call_id = 0;
}

我想知道的是为什么在点符号上使用->的理论。

更新：对于和我一样的人和学习C++的人。我已经扩展了一个成员在这个问题上发布的示例。我还包装了一个成员字段的初始化列表。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include"stdafx.h"
#include <iostream>
using namespace std;

class A {
private:
    int x;
public:
    A() : x(0){}
    int getX() const {return x;}
    void setX(int xx) {x += xx;}
};

int main()
{
    A a;

    a.setX(13);

    A *pa = &a;

    pa->setX(2);

    A b = a;

    b.setX(5);

    cout <<"a" << a.getX() << endl;

    cout <<"a*" << pa->getX() << endl;

    cout <<"b" << b.getX() << endl;

    return 0;
}

"this"是指向当前对象的指针，即在类A的方法(或构造函数)内部，它的类型为"a*"。注意，如果方法被标记为const，那么它的类型为"a const*"。因此，使用"->"(设计用于指针)而不是"."(设计用于类对象"A"或对类对象"A&；"的引用)

相关讨论

您可以考虑下面的例子。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class A {
    int x;
public:
    int getX() const {return x;}
    void setx(int xx) {x = xx;}
};

int main()
{
    A a;

    a.setX(13);
    cout << a.getX() << endl;

    A *pa = &a;

    cout << pa->getX() << endl;

    return 0;
}

请注意，当使用对象A直接调用的成员函数时，使用点运算符(.)。当通过类型A(a*pa=&a)的指针间接调用的成员函数时，使用箭头运算符(->)。

在C++中，这是指向调用对象的指针。因此，我们还可以定义一个：：getx()函数，如下所示：

1
int getX() const {return this->x;}

或：

1
int getX() const {return (*this).x;}

这是对象A的指针，因此*这将取消对它的引用。所以我们可以使用上面的两个函数。

相关讨论

因为在类或结构成员内部，"this"是指向当前实例的特殊指针。

每当您通过指针访问类或结构的成员时，都会使用->运算符。

如果您通过任何非指针(通常是引用)访问它们，则使用点运算符。

值得注意的是，除了模板声明的某些形式之外，这个->语法是不必要的。然而，很多人选择使用它是出于风格上的原因。在S.O.上已经有几个与此背后的理论基础相关的问题。

在C++中，EDCOX1×0是指向自对象的指针。它是C++早期版本的遗留物，在它有引用之前。如果现在将this添加到语言中，它可能是一个引用，您可以使用.表示法。

相关讨论

如前所述，这是一个指针而不是引用。因此，您需要一个大致相同的->操作符：(*this)。

它们的不同之处在于，可以在类中重载->operator或*operator，并且可以有不同的语义。事实上，如果类重写了operator->并且返回的值不是原始指针，编译器将继续对返回的对象应用operator->直到它到达本机指针。操作员。不能超载。

在您指出的构造函数中，使用它完全是可选的，因为没有名称冲突，代码可能只是命名了属性，而没有进一步的限定。

1
2
3
4
5
6
7
8
facebook::facebook( string my_key, string my_secret, string my_server )
{
    api_key = my_key;
    secret = my_secret;
    server = my_server;
    has_session = false;
    call_id = 0;
}

更好的解决方案是使用初始化列表。如果你有兴趣学习C++谷歌的话。

相关讨论

因为"this"是引用当前对象的特殊指针，我们使用"->"通过指针访问对象的成员，而"."用于直接调用对象的成员。