精华内容
下载资源
问答
  • C++ this指针

    万次阅读 多人点赞 2019-06-07 21:13:37
    类内的一切对于成员函数来说都是透明的),那么成员函数如何知道哪个对象的数据成员要被操作呢,原因在于每个对象都拥有一个指针:this指针,通过this指针来访问自己的地址。 注意: this指针并不是对象的一部分,...

    this 指针

    引言:
    首先,我们都知道类的成员函数可以访问类的数据(限定符只是限定于类外的一些操作,类内的一切对于成员函数来说都是透明的),那么成员函数如何知道哪个对象的数据成员要被操作呢,原因在于每个对象都拥有一个指针:this指针,通过this指针来访问自己的地址。
    注意:
    this指针并不是对象的一部分,this指针所占的内存大小是不会反应在sizeof操作符上的。this指针的类型取决于使用this指针的成员函数类型以及对象类型,

    一、this指针的概念

    1. 定义
      在 C++ 中,每一个对象都能通过 this 指针来访问自己的地址。this 指针是所有成员函数的隐含参数。因此,在成员函数内部,它可以用来指向调用对象。

    2. this只能在成员函数中使用
      成员函数默认第一个参数为T* const register this。
      (友元函数,全局函数不是成员函数)

    3. this指针不能再静态函数中使用
      静态函数如同静态变量一样,他不属于具体的哪一个对象,静态函数表示了整个类范围意义上的信息,而this指针却实实在在的对应一个对象,所以this指针不能被静态函数使用。

    4. this指针的创建
      this指针在成员函数的开始执行前构造的,在成员的执行结束后清除。

    5. this指针只有在成员函数中才有定义。
      创建一个对象后,不能通过对象使用this指针。也无法知道一个对象的this指针的位置(只有在成员函数里才有this指针的位置)。当然,在成员函数里,你是可以知道this指针的位置的(可以&this获得),也可以直接使用的。

    二、this指针的操作

    1. 在类的非静态成员函数中返回类对象本身的时候,我们可以使用圆点运算符*,箭头运算符->。
      #include<iostream>
      using namespace std;
      class A{
       private:
        int x;
       public:
        A(){
         x=0;
        }
        void display(){
         cout<<this<<endl;
         cout<<this->x<<endl;
         cout<<x<<endl;
         cout<<(*this).x<<endl;
        }
      };
      int main(void){
          A a;
          a.display();
      }
      
      输出:
      0x70fe40
      0
      0
      0
      
      
    2. 实现级联

    关于this指针的一个精典回答:

    当你进入一个房子后,
    你可以看见桌子、椅子、地板等,
    但是房子你是看不到全貌了。
    对于一个类的实例来说,
    你可以看到它的成员函数、成员变量,
    但是实例本身呢?
    this是一个指针,
    它时时刻刻指向你这个实例本身。

    展开全文
  • c++this指针

    2018-11-15 14:54:44
    c++this指针

    分享一下我老师大神的人工智能教程!零基础,通俗易懂!http://blog.csdn.net/jiangjunshow

    也欢迎大家转载本篇文章。分享知识,造福人民,实现我们中华民族伟大复兴!

                   

    今天 查了些资料,现在总结下c++中this指针

    关于this指针的描述我们一般从语言层次上讲;

    this指针作为一个隐含参数传递给非静态成员函数,用以指向该成员函数所属类所定义的对象。当不同的对象调用同一个类的成员函数代码时,编译器会依据该成员函数的this指针所指向的不同对象来确定应该引用哪个对象的数据成员。

    this指针是一个隐含于每一个成员函数中的特殊指针。它是一个指向正在被该成员函数操作的对象,也就是要操作该成员函数的对象。

    当对一个对象调用成员函数时,编译程序先将对象的地址赋给this指针,然后调用成员函数,每次成员函数存取数据成员时,由隐含作用this指针。而通常不去显式地使用this指针来引用数据成员。同样也可以使用*this来标识调用该成员函数的对象。

    再来说下类的成员函数。非静态函数成员,不占用对象的内存,它经C++编译器处理后,它是一个全局函数,它的第一个参数为this指针,其余参数类型和名字,与用户定义的一致。

    1)基本用法

    class Base{publicvoid test(int x) {  this->x= x; }publicint x;};


    2)const成员函数 

    class Base {publicvirtual void f()const { cout << "Base::f" << endl; }};
    lass Derive : public Base{publicvirtual void f()  { cout << "Derive::f" << endl; }};


    执行:

    Base* pBase = new Derive;
     pBase->f();

    之后运行结果是啥?

    Base::f

    为什么呢?

    这个const将隐含的this指针声明成const类型,所以相当于父类和子类的f()函数具有不同的参数,也就是说子类遮蔽了f()函数,此处不具有多态性


    发个连接,补充this指针的介绍

    深入探讨this指针

    http://blog.csdn.net/ugg/article/details/606396

    2 this指针探秘

    http://bbs.csdn.net/topics/100069525

    this指针探秘

     

               

    给我老师的人工智能教程打call!http://blog.csdn.net/jiangjunshow

    这里写图片描述
    展开全文
  • C++ this 指针

    2021-03-06 12:01:12
    C++ this 指针C++ 中,每一个对象都能通过 this 指针来访问自己的地址。this 指针是所有成员函数的隐含参数。在成员函数内部,它可以用来指向调用对象。 友元函数没有 this 指针,因为友元不是类的成员。只有...

    C++ this 指针

    在 C++ 中,每一个对象都能通过 this 指针来访问自己的地址。this 指针是所有成员函数的隐含参数。在成员函数内部,它可以用来指向调用对象。

    友元函数没有 this 指针,因为友元不是类的成员。只有成员函数才有 this 指针。this 关键字只能用于成员函数,不能用于被 static 修饰的静态函数。this 指代的是当前上下文。

    this 指针是隐含在对象成员函数内的一种指针,成员函数通过 this 指针可以知道操作的是哪个对象的数据。静态成员函数内部没有 this 指针,静态成员函数不能操作非静态成员变量,静态成员函数是属于类,函数内部没有 this 指针。当形参和成员变量同名时,可用 this 指针来区分。

    this 是 C++ 的一个关键字,也是一个 const 指针,它指向当前对象,通过它可以访问当前对象的所有成员,它的值是不能被修改的。当前对象,是指正在使用的对象。info.set_count(10);info 是当前对象,this 指向 info。this 是一个指针,要用 -> 来访问成员变量或成员函数。在对象被创建以后会给 this 赋值,赋值的过程是编译器自动完成的,不需要用户干预,用户也不能显式地给 this 赋值。this 指向当前对象,而且对于不同的对象,this 的值是不一样。

    this 只能在成员函数内部使用,用在其他地方没有意义,也是非法的。当对象被创建后 this 才有意义,因此不能在 static 成员函数中使用。

    this 实际上是成员函数的一个形参,在调用成员函数时将对象的地址作为实参传递给 this。不过 this 这个形参是隐式的,它并不出现在代码中,而是在编译阶段由编译器默默地将它添加到参数列表中。

    this 作为隐式形参,本质上是成员函数的局部变量,所以只能用在成员函数的内部,并且只有在通过对象调用成员函数时才给 this 赋值。

    成员函数最终被编译成与对象无关的普通函数,除了成员变量,会丢失所有信息,所以编译时要在成员函数中添加一个额外的参数,把当前对象的首地址传入,以此来关联成员函数和成员变量。这个额外的参数,实际上就是 this,它是成员函数和成员变量关联的桥梁。

    this 指代的是当前上下文,this 表示的对象是这个方法活动的上下文。当我们调用成员函数时,实际上是替某个对象调用它。成员函数通过一个名为 this 的额外隐式参数来访问调用它的那个对象,当我们调用一个成员函数时,用请求该函数的对象地址初始化 this。

    成员函数通过一个名为 this 的额外隐式参数来访问调用它的那个对象,当我们调用一个成员函数时,用请求该函数的对象地址初始化 this。

    1. Example

    //============================================================================
    // Name        : Yongqiang Cheng
    // Author      : Yongqiang Cheng
    // Version     : Version 1.0.0
    // Copyright   : Copyright (c) 2020 Yongqiang Cheng
    // Description : Hello World in C++, Ansi-style
    //============================================================================
    
    #ifndef _CRT_SECURE_NO_WARNINGS
    #define _CRT_SECURE_NO_WARNINGS
    #endif
    
    #include <iostream>
    
    class Qiang {
    public:
        static int cnt;
        int count;
    
        void set_count(const int num) {
            // count = num;
            this->count = num;
        }
    };
    
    // static
    int Qiang::cnt = 9;
    
    int main() {
        Qiang info;
        Qiang data;
        std::cout << Qiang::cnt << std::endl;
        std::cout << info.cnt << std::endl;
        std::cout << data.cnt << std::endl;
    
        info.cnt = 16;
    
        std::cout << Qiang::cnt << std::endl;
        std::cout << info.cnt << std::endl;
        std::cout << data.cnt << std::endl;
    
        info.set_count(10);
        std::cout << "info.count = " << info.count << std::endl;
    
        data.set_count(20);
        std::cout << "data.count = " << data.count << std::endl;
    
        std::cout << "Hello, World!\n" << std::endl;
        return 0;
    }
    
    
    /home/yongqiang/CLionProjects/hash_table/cmake-build-debug/hash_table
    9
    9
    9
    16
    16
    16
    info.count = 10
    data.count = 20
    Hello, World!
    
    
    Process finished with exit code 0
    

    2. Example

    //============================================================================
    // Name        : Yongqiang Cheng
    // Author      : Yongqiang Cheng
    // Version     : Version 1.0.0
    // Copyright   : Copyright (c) 2020 Yongqiang Cheng
    // Description : Hello World in C++, Ansi-style
    //============================================================================
    
    #ifndef _CRT_SECURE_NO_WARNINGS
    #define _CRT_SECURE_NO_WARNINGS
    #endif
    
    #include <iostream>
    
    class Qiang {
    public:
        void set_name(const char *name);
    
        void set_age(const int age);
    
        void set_score(const float score);
    
        void display();
    
    private:
        const char *name;
        int age;
        float score;
    };
    
    void Qiang::set_name(const char *name) {
        this->name = name;
    }
    
    void Qiang::set_age(const int age) {
        this->age = age;
    }
    
    void Qiang::set_score(const float score) {
        this->score = score;
    }
    
    void Qiang::display() {
        std::cout << this->name << " " << this->age << " " << this->score << std::endl;
    }
    
    int main() {
        Qiang info;
    
        std::string name = "yongqiang";
        info.set_name(name.c_str());
        info.set_age(16);
        info.set_score(96.5);
        info.display();
    
        std::cout << "Hello, World!\n" << std::endl;
        return 0;
    }
    
    
    /home/yongqiang/CLionProjects/hash_table/cmake-build-debug/hash_table
    yongqiang 16 96.5
    Hello, World!
    
    
    Process finished with exit code 0
    

    References

    展开全文
  • C++this指针

    2019-09-26 10:02:46
    C++this指针 一、什么是this指针 一个对象的this指针并不是对象本身的一部分,不会影响sizeof(对象)的结果。this指针作用域是类内部,当类在非静态成员函数中访问类的非静态成员的时候,编译器会自动将对象本身的...

    C++this指针

    一、什么是this指针

    一个对象的this指针并不是对象本身的一部分,不会影响sizeof(对象)的结果。this指针作用域是类内部,当类在非静态成员函数中访问类的非静态成员的时候,编译器会自动将对象本身的地址作为一个隐含参数传递给函数。即使程序员没有编写上this指针,编译器在编译的时候也是加上this的,它作为非静态成员函数隐含形参,对各个成员的访问均通过this指针进行。

    例:data.SetStudent(1)<===>SetStudent(&data,1),this指针帮助转换。

    建立对象时,系统会为每一个对象分配独立的存储空间,也就是给每个对象中的数据成员都分配有自己独立的存储空间。如果对同一个类定义n个对象,则有n组同样大小的空间以存放对象中的数据成员。但对于成员函数来说,对象中的数据成员。一个函数的代码段在内存中只有一份。也就是说,函数的代码段在内存中只有一份。也就是说,同一个类中的不同对象在调用自己的成员函数时,一个类中的不同对象在调用自己的成员函数时,其实它们调用的是同一段函数代码。

    二、this指针的作用

    this作用域是在类的内部,自己声明一个类的时候,还不知道实例化对象的名字,所以用this来使用对象变量的自身。在非静态成员函数中,编译器在编译的时候加上this作为隐含形参,通过this来访问各个成员(即使你没有写上this指针)。 
    一种情况就是,在类的非静态成员函数中返回类对象本身的时候,直接使用 return *this;另外一种情况是当参数与成员变量名相同时,如this->n = n (不能写成n = n)。 

    #include <iostream>
    #include <string.h>
    using namespace std;
    class Student{
        public:
            void InfoStudent(char *name,char *gender,int age){
                //void InfoStudent(Student *const this,char *name,char *gender,int age);
                strcpy(_name,name);
                strcpy(_gender,gendet);
                _age=age;
                }
            void PrintStudent(){
                cout<<_name<<" "<<_gender<<" "<<age<endl;
            }
        private:
            char _name[20];
            char _gender[4];
            int _age;
    };
    int main(){
        Student Stu;
        Stu.InfoStudent("LIU","female",20);
        Stu.PrintStudent();
        return 0;
    }

    其中类成员函数:

    void InfoStudent(char *name,char *gender,int age);
    //真正传参方式
    void InfoStudent(Student *const this,char *name,char *gender,int age);

    那么,当一个对象调用自己的成员函数是,如何保证成员函数中数据成员的处理是针对自己的数据而不是其他对象的数据成员呢?this指针假设用一个类定义10个对象:编译系统并不是分别为10个对象的数据成员函数分配存储空间,而是仅为每个对象的数据成员分配存储单元,10个对象的成员函数对应的是同一个函数代码段。不论成员函数在类内定义还是在类外定义,成员函数都用以上方式存储。

    在每一个成员函数中都包含一个特殊的指针,这个指针的名字是固定的,称为this。

    当前被调用的成员函数所在的对象的起始地址。在调用成员函数时,系统隐式地将对象的起始地址传递给成员函数,使this指针得到当前对象的地址。于是在成员函数中对数据成员的引用,就按照this的指向找到对象的数据成员,实现对数据成员的操作。也就是说, 成员函数中数据成员名的前面隐含有“this->” 的指向。 

    int Box::Volum(){return (l*w*h);}

    int Box::Volum(){return(this->l*this->w*this->h);}

    假设a是Box类对象,当执行到a.Volum时候,this=&a当执行时int Box::Volum() return (a.l*a.w*a.h);}

    三、this指针的两种传参方式:

    1.参数压栈:当成员函数的参数为可变时(_cdecl调用约定)

    2.ecx寄存器:当成员函数的参数固定时(_thiscall调用约定)

    叫this指针而不叫引用:this 指针和引用的底层实现一样但是类的概念在引用之前提出来所以没有用引用代替this指针 

    this指针也有可能为空:

    int main(){
        Student s1;
        s1.InfoStudent("Liu","female",18);
        Student *ps=&s1;
        s1.InfoStudent("Hua","male",20);
        ps=NULL;
        ps->InfoStudent("Tony","female",25);
        s1.PrintStudent();
        system("pause");
        return 0;
    }
    

    NULL对象指针可以调用成员函数 通过对象调用成员函数,对象的指针会被传入函数中,指针名为this

    NULL对象指针调用成员函数时,只要不访问此对象的成员变量,则程序能够正常运行。

    NULL对象指针调用成员函数时,一旦访问此对象的成员变量,则程序会崩溃。

    this指针创建时间

    this在成员函数开始执行前构造,在成员的执行结束后清除。

    this在成员函数的开始执行前构造,在成员的执行结束后清除。 
    但是如果class或者struct里面没有方法的话,它们是没有构造函数的,只能当做C的struct使用。采用 TYPE xx的方式定义的话,在栈里分配内存,这时候this指针的值就是这块内存的地址。采用new的方式创建对象的话,在堆里分配内存,new操作符通过eax返回分配的地址,然后设置给指针变量。之后去调用构造函数(如果有构造函数的话),这时将这个内存块的地址传给ecx

    this指针存放位置?堆、栈、全局变量还是其他地方

    this指针会因编译器不同而有不同的放置位置。可能是栈,也可能是寄存器,甚至全局变量。在汇编级别里面,一个值只会以3种形式出现:立即数、寄存器值和内存变量值。不是存放在寄存器就是存放在内存中,它们并不是和高级语言变量对应的。

    this指针是如何传递类中的函数?绑定?在函数参数的首参数就是this指针?那么,this指针又如何找打“类实力后的函数的”?

    大多数编译器通过ecx寄存器传递this指针。事实上,这也是一个潜规则。一般来说,不同编译器都会遵从一致的传参规则,否则不同编译器产生的obj就无法匹配了。

    在call之前,编译器会把对应的对象地址放到eax中。this是通过函数参数的首参来传递的。this指针在调用之前生成,至于“类实例后函数”,没有这个说法。类在实例化时,只分配类中的变量空间,并没有为函数分配空间。自从类的函数定义完成后,它就在那儿,不会跑的。

    this指针是如何访问类中的变量?

    如果不是类,而是结构体的话,那么,如何通过结构指针来访问结构中的变量呢?如果你明白这一点的话,就很容易理解这个问题了。 
    在C++中 ,类和结构是只有一个区别的:类的成员默认是private,而结构是public。 
    this是类的指针,如果换成结构,那this就是结构的指针了。 

    我们只有获取一个对象后,才能通过对象使用this指针。如果我们知道一个对象this指针的位置,可以直接使用吗?

    this指针只有在成员函数中才有定义。因此,你获得一个对象后,也不能通过对象使用this指针。所以,我们无法知道一个对象的this指针的位置(只有在成员函数里才有this指针的位置)。当然,在成员函数里,你是可以知道this指针的位置的(可以通过&this获得),也可以直接使用它。

    每个类编译后,是否创建一个类中函数表保存函数指针,以便用来调用函数?

    普通的类函数(不论是成员函数,还是静态函数)都不会创建一个函数表来保存函数指针。只有虚函数才会被放到函数表中。但是,即使是虚函数,如果编译器能明确知道调用的是哪个函数,编译器就不会通过函数表中的指针来间接调用,而是会直接调用该函数。

     

    展开全文
  • C++ This指针

    2017-07-10 10:59:17
    C++ this指针。1、概念、原理2、构造函数不能是虚函数的原因3、static函数无法处理类中non-static成员变量的原因 转载于:https://blog.51cto.com/weiyuqingcheng/1945837...
  • c++ this指针

    2020-09-14 08:39:13
    this指针,通过this指针来访问自己的地址。 注:this指针并不是对象的一部分,this指针所占的内存大小是不会反应在sizeof操作符上的。this指针的类型取决于使用this指针的成员函数类型以及对象类型。 1.this只能在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,542
精华内容 2,616
关键字:

c++this指针

c++ 订阅