精华内容
下载资源
问答
  • C++this指针 千次阅读
    2019-07-20 23:05:56

     

    1) 以下说法不正确的是:

    (括号内为个人理解)

    • A.this指针就是指向成员函数所作用的对象的指针   

    • B. 每个对象的空间中都存放着一个this指针

    • C.类的非静态成员函数,真实的参数比所写的参数多1 (多一个this指针)

    • D. 静态成员函数中不能使用this指针 (因为static函数不属于某个对象)

       

    this指针是类的一个自动生成、自动隐藏的私有成员,它存在于类的非静态成员函数中,指向被调用函数所在的对象。全局仅有一个this指针,当一个对象被创建时,this指针就存放指向对象数据的首地址。

     

    所以该题选B

    更多相关内容
  • 1.this指针 this指针就是类的实例起始地址——实例的变量存储区的起始地址,和代码区是分开的。有了this指针我就可以访问我的实例的变量,并传递给代码区区执行。值得注意的是,this指针本身并不是实例的一部份,...

    1.this指针

    this指针就是类的实例起始地址——实例的变量存储区的起始地址,和代码区是分开的。有了this指针我就可以访问我的实例的变量,并传递给代码区区执行。值得注意的是,this指针本身并不是实例的一部份,所以不会影响sizeof(实例)的大小。

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

    this是指向实例化对象本身时候的一个指针,里面存储的是对象本身的地址,通过该地址可以访问内部的成员函数和成员变量。
          为什么需要this?因为this作用域是在类的内部,自己声明一个类的时候,还不知道实例化对象的名字,所以用this来使用对象变量的自身。在非静态成员函数中,编译器在编译的时候加上this作为隐含形参,通过this来访问各个成员(即使你没有写上this指针)
    return *this返回的是当前对象的克隆或者本身(若返回类型为A, 则是克隆, 若返回类型为A&, 则是本身 )。
    return  this返回当前对象的地址(指向当前对象的指针)

    this的使用:
    (1)在类的非静态成员函数中返回对象的本身时候,直接用return *this(常用于操作符重载和赋值、拷贝等函数)。
    (2)传入函数的形参与成员变量名相同时,例如:this->a = a

    2.类的公共变量——静态成员变量

    静态就是在程序编译时就分配存储空间,而不是等到运行时才知道,也就是程序加载之后,它的存储空间就已经分配了。这是因为我们有时候希望即便类的实例销毁了,但我却希望保存它的某些数据,那么这个时候,静态成员变量就是一个很好的选择。对于被所有类共享的数据可声明成静态变量,它在程序运行前就已经存在了(所以一定要初始化),它被放到静态存储区,按照出现次序被初始化。 它被所有该类的对象共享,静态变量可以被改变。

    构造函数是为了构造对象而定义的,而静态变量是 一个类的变量,而不是类的实例的变量,所以自然不能在用于构造对象的构造函数中初始化静态变量。

    静态变量调用的时候可以通过对象调用,也可以通过类直接调用。

    3.不依赖于类实例的函数——静态函数

    静态函数没有this指针。  静态函数只能访问类中的静态成员变量
    静态函数不需要类的实例就可以调用
    静态成员函数不属于任何对象,而是属于类的。

    显然调用静态函数效率要高,因为不需要找类实例的数据就可以执行(所以自然不需要标记类实例地址的this指针了),由于没有隐含的this指针,自然无法访问类的其他变量,而只能访问静态变量了。

    一般: A a=new A; a.fun();      静态函数:A::fun();

    类的成员函数想作为回调函数来使用,一般情况下只能将它定义为静态成员才行。比方说,光靠类中”其他“函数,不能将类中的某个“其他”函数当作线程的入口地址。如果要作线程函数的入口地址,一定要声明为静态的函数,静态函数的地址是加载即确认,OS可以直接找到,建立新线程。而非静态函数却是动态加载,如果作为回调函数和线程函数,就只能是静态函数.
    static成员函数不能为virtual        virtual static void fun() { }//错误
    原因:①static成员不属于任何类对象或类实例,故即使给此函数加上virutal也是没意义的。 ②静态成员函数没有this指针。 

    static成员函数不能为const函数   static void fun() const { } //编译错误    const static void fun() {}  //可以的 
    原因:当声明一个非静态成员函数为const时,对this指针会有影响。对于一个Test类中的const修饰的成员函数,this指针相当于Test const , 而对于非const成员函数,this指针相当于Test . 而static成员函数没有this指针,所以使用const来修饰static成员函数没有意义。 volatile的道理也是如此。

     

    展开全文
  • this指针的介绍和用法

    千次阅读 多人点赞 2017-01-20 13:45:55
    this指针是面向对象程序设计的一项概念,在C++中,它表示当前运行的对象。在实现对象的方法时,this指针来获得该对象自身的引用。 正如class Family类,创建了Family类的两个对象,即Chen1和Chen2。 (1)假如...

    参考书籍,孙鑫视频教学,百度等。

    ---下文举的例子是错误的,楼主若有空会对此进行修改。记录时间:2019-3-4

    this指针的介绍

    this指针是面向对象程序设计的一项概念,在C++中,它表示当前运行的对象。在实现对象的方法时,this指针来获得该对象自身的引用。

    正如class Family类,创建了Family类的两个对象,即Chen1和Chen2。

    (1)假如Family类是”家庭“这个抽象。

    (2)Chen1是你家,Chen2是邻居家。

    (3)你的家庭成员中有个人名叫“陈皮”(”陈皮“是个 类里的成员,即可以假设是非静态成员函数、非静态成员变量、析构函数等,这里假设”陈皮“是个非静态成员变量,是个小孩),你隔壁家的家庭成员也有个人叫“陈皮”,也是个小孩。

    (4)你是Chen1家的非静态成员函数void you(),是"陈皮“的家长。

    (5)菜园是Chen1和Chen2这两个家庭共享的静态成员函数或者是静态成员变量。这里假设菜园是静态成员函数static void cai(),而菜是静态成员变量。即菜园和菜都是属于家庭类的,任何一个家庭都可以访问和改变它,但不能占为己有。

    (6)this1假设是你家的家庭保姆,假设当前this1的联系里只有你家的地址,只服务于你这个家Chen1对象,原则上只能一对一服务你这个家庭,不能对其他家庭进行服务。

    this用处比喻:

            如果你自己家的this1保姆今天过来工作于你的整个家庭,由于this1只能一对一服务,所以邻居家只好找到的是另外的this2作为他家的保姆。this2今天来不来都不关你家和你家的this1的事情。因此,你家的this1只能联系你家,而不能联系邻居家。相反,他家的this2的联系只有他家的地址,而没有你家的地址。

    this1保姆找你家”陈皮“出去玩:

            如果this1想要找你家“陈皮”带出去玩,就必须来到你家里,进而通过你这个家长允许并获取”陈皮“喜欢玩什么等信息,并再与”陈皮“沟通交流,使”陈皮“心情大好并让他穿上衣服准备走人(改变情绪,改变装扮,即改变非静态成员变量的值,当然”陈皮“可以什么都不用改变)。由于this1不会联系有邻居家,跟this1无关,自然不会去访问邻居家。this1的沟通主要作用在家庭类对象Chen1家庭中这个家长,即你这个非静态成员函数void you()。

    this1保姆也可能对菜园感兴趣:

            如果this1对你家和邻居家共享的菜园感兴趣,就通过你的指引下,来参观你和邻居家共享的菜园,并获取菜园的信息。(this1在菜园中,既可以替你家来看看有什么好吃的菜,哪些菜长得如何,也可以替你家为菜园施肥料、除虫,但不会把这些行为或者菜园信息记录在this1的联系中),this1的联系始终只有你家的地址,不含其他家的地址,没有改变指向的说法。

    this1保姆不认识邻居家:

           哪怕邻居家的this2今天不来,后天也不来,你家的this1因为不认识邻居家,也不会自作多情地对他家进行一番服务。只能通过你家的关系,把菜园里的菜都挖走了一大半,给你家做菜,也会导致邻居家天天因为吃饭时菜量不够而挨饿。邻居家只能喊他们的this2重新种菜,或者也全部挖走剩下的菜,来给他家做菜。即每个家庭都可以改变菜的份量。

     this1和this2都尽心服务于各自的家庭,但两者没有任何关系,从来都没有碰过面,也就没有过交际。

    图解:

    1.this指针是一个隐含的指针,它是指向对象本身,代表了对象的地址。

    隐含的指针的说法,可以形象化成这样:
      当你进入一个房子后,你可以看见桌子、椅子、地板等,但是房子你是看不到全貌了。(即我们口头说的“房子”抽象概念是一个类,而我们亲眼看到的实际存在的"房子"类似一个对象。“桌子、椅子、地板等”类似成员函数、成员变量)

    对于一个类的实例来说,你可以看到它的成员函数、成员变量,但是实例本身呢? this是一个指针,它时时刻刻指向你这个实例本身。

    2.一个类所有的对象调用的成员函数都是统一代码段。

    那么成员函数又是怎么识别属于同一对象的数据成员呢?
    原来,在对象调用pt.output(10,10)时,成员函数除了接受2个实参外,还接受到了一个对象pt的地址。这个地址被一个隐含的形参this指针所获取,它等同于执行this=&pt。所有对数据成员的访问都隐含地被加上前缀this->。
    例如x是数据成员:
    x=0;等价于this->x=0。

    3.一个对象的this指针并不是对象本身的一部分,不会影响sizeof(对象)的结果。

    this是一个指针,指向对象,保存的是对象的地址,所以在32位平台上,sizeof(this)始终是4个字节。sizeof(对象)或者sizeof(类名)是创建一个实例子后,包括了成员变量等占有内存的结果。

    复制代码

    class A
    {
    public:
        int i;
        A(){ cout << endl; }
        void fun(){  cout << this << endl; }
        ~A(){};
    };
    int main()
    {
        A a;
        a.fun();
        cout << &a << endl;
        return 0;
    }

    复制代码

    结果是:this指向对象a的地址与对象a的地址是一样的。

    this作用域是在类内部,而且是在类的非静态成员函数中使用,实际引用并操作对象a的成员。

    当在类的非静态成员函数中访问类的非静态成员的时候,编译器会自动将对象本身的地址作为一个隐含参数传递给函数。也就是说,即使你没有写上this指针,编译器在编译的时候也是加上this的,它作为非静态成员函数的隐含形参,对各成员的访问均通过this进行。

    4.this到底是什么?(摘自c语言中文网)

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

    2.在一个非静态的成员里面,this关键字就是一个指针,指向该函数的这次调用所针对的那个对象。在类a的非const成员函数里,this类型就是*a。但是this不是一个常规变量,所以不可以获取this的地址或者给它赋值。在类a的const成员函数里,this的类型是const a*,不可以对这个对象本身进行修改。

    this的作用

    1.使用this区分成员变量和局部变量。

    当类中有两个同名变量,一个属于类(类的成员变量),而另一个属于某个特定的方法(方法中的局部变量)。

    2.使用this简化构造函数的调用。

    3.静态成员函数存在类中,只有一份拷贝。而非静态成员函数属于对象的,各自的对象都有各自的一份拷贝。

    一个类所有的实例(对象)调用的非静态成员函数在内存中只有一份拷贝,尽管在内存中可能有多个对象,而非静态数据成员在类的每个对象所在内存中都存在着一份拷贝。this变量允许相同的实例方法为不同的对象工作。
    每当调用一个实例的非静态成员函数时,this变量将被设置成引用该实例函数的特定的类对象。方法的代码接着会与this所代表的对象的特定数据建立关联。

    4.为了分清同变量名,引用指针。

    假设:void output(int x,int y)函数里面的两个形参和类的公有的两个变量名一致时,分析如下实例:

    复制代码

    class Point
    {public:
    int x;
    int y;
    Point(int a,int b){x=a;y=b;}
    void output()//output函数{cout<<x<<endl<<y<<endl;}
    void output(int x,int y)//output函数重载{x=x;y=y;}
    };
    void main()
    {
    Point pt(3,3);
    pt.output(5,5);
    }

    复制代码

    输出结果为:
    3
    3
    原因:在output(int x,int y)中,x,y都属于output重载函数里面的形参,并没有调用类里面的x,y;

    把output(int x,int y)函数改成:

    void output(int x,int y)//output函数重载
    {
    this->x=x;
    this->y=y;
    }

    输出结果:
    5
    5

    this指针程序示例

      this指针存在于类的成员函数中,指向被调用函数所在的类实例的地址。
      根据以下程序来说明this指针

    复制代码

       #include<iostream.h>
       class Point
       {
       int x, y;
       public:
       Point(int a, int b) {x=a; y=b;}
       void MovePoint( int a, int b){ x+=a; y+=b;}
       void print(){ cout<<"x="<<x<<"y="<<y<<endl;}
       };
       void main( )
       {
       Point point1( 10,10);
       point1.MovePoint(2,2);
       point1.print( );
       }

    复制代码

    当对象point1调用MovePoint(2,2)函数时,即将point1对象的地址传递给了this指针。
       MovePoint函数的原型应该是 void MovePoint( Point *this, int a, int b);第一个参数是指向该类对象的一个指针,我们在定义成员函数时没看见是因为这个参数在类中是隐含的。这样point1的地址传递给了this,所以在MovePoint函数中便显式的写成:
       void MovePoint(int a, int b) { this->x +=a; this-> y+= b;}
       即可以知道,point1调用该函数后,也就是point1的数据成员被调用并更新了值。
       即该函数过程可写成 point1.x+= a; point1. y + = b;

    摘自百度百科:

    详细解析编辑
            在前面曾经提到过: 每个对象中的数据成员都分别占有存储空间,如果对同一个类定义了n个对象,则有n组同样大小的空间以存放n个对象中的数据成员。但是,不同对象都调用同一个函数代码段。
            那么,当不同对象的成员函数引用数据成员时,怎么能保证引用的是所指定的对象的数据成员呢?假如,对于例程序中定义的Box类,定义了3个同类对象a,b,c。
                1.如果有a.volume( ) ,应该是引用对象a中的height,width和length,计算出长方体a的体积。
                2.如果有b.volume( ) ,应该是引用对象b中的height,width和length,计算出长方体b的体积。
            而现今都用同一个函数段(volume()),系统怎样使它分别引用a或b中的数据成员呢?在每一个成员函数中都包含一个特殊的指针,这个指针的名字是固定的,称为this指针。它是指向本类对象的指针,它的值是当前被调用的成员函数所在的对象的起始地址。
             例如,当调用成员函数a.volume时,编译系统就把对象a的起始地址赋给this指针,于是在成员函数引用数据成员时,就按照this的指向找到对象a的数据成员。例如volume函数要计算height*width*length的值,实际上是执行:
    (this->height)*(this->width)*(this->length)
    由于当前this指向a,因此相当于执行:
    (a.height)*(a.width)*( a.length)
    这就计算出长方体a的体积。
              同样如果有b.volume( ) ,编译系统就把对象b的起始地址赋给成员函数volume的this指针,显然计算出来的是长方体b的体积。this指针是隐式使用的,它是作为参数被传递给成员函数的。
    本来,成员函数volume的定义如下:
    int Box::volume( )
    {
    return (height*width*length);
    }
    C++把它处理为
    int Box::volume(Box *this)
    {
    return (this->height * this->width * this->length);
    }
    即在成员函数的形参表列中增加一个this指针。
    在调用该成员函数时,实际上是用以下方式调用的:
    a.volume(&a);
    将对象a的地址传给形参this指针。然后按this的指向去引用其他成员。
    需要说明: 这些都是编译系统自动实现的,编程序者不必人为地在形参中增加this指针,也不必将对象a的地址传给this指针。在需要时也可以显式地使用this指针。


    例如在Box类的volume函数中,下面两种表示方法都是合法的、相互等价的。
    return (height * width * length); //隐含使用this指针
    return (this->height * this->width * this->length); //显式使用this指针
    可以用*this表示被调用的成员函数所在的对象,*this就是this所指向的对象,即当前的对象。


    例如在成员函数a.volume( )的函数体中,如果出现*this,它就是本对象a。上面的return语句也可写成
    return((*this).height * (*this).width * (*this).length);
    注意*this两侧的括号不能省略,不能写成*this.height。
    所谓“调用对象a的成员函数f”,实际上是在调用成员函数f时使this指针指向对象a,从而访问对象a的成员。在使用“调用对象a的成员函数f”时,应当对它的含义有正确的理解。

    应用参考编辑

    this指针只能在一个类的成员函数中调用,它表示当前对象的地址。下面是一个例子(选自《C/C++程序员宝典》面试题91):

    复制代码

    voidDate::setMonth(intmn)
    {
      month=mn;
      this->month=mn;
      (*this).month=mn;
      //这三句是等价的
    }

    复制代码

    1.this只能在成员函数中使用。

    全局函数,静态函数都不能使用this。
    实际上,成员函数默认第一个参数为T*const register this。
    如:
    class A{public: int func( int p){}};
    其中,func的原型在编译器看来应该是: int func(A*const register this, int p);

    2. 由此可见,this在成员函数的开始前构造的,在成员的结束后清除。

    这个生命周期同任一个函数的参数是一样的,没有任何区别。
    当调用一个类的成员函数时,编译器将类的指针作为函数的this参数传递进去。如:
    A a;
    a.func(10);
    此处,编译器将会编译成: A::func(&a, 10);
    嗯,看起来和静态函数没差别,对吗?不过,区别还是有的。编译器通常会对this指针做一些优化的,因此,this指针的传递效率比较高--如vc通常是通过ecx寄存器来传递this参数。

    3. 回答

    #1:this指针是什么时候创建的?
    this在非静态成员中有意义,作为右值可以直接在编译时确定其存在,运行时无所谓创建。

    #2:this指针存放在何处?

    堆,栈,全局变量,还是其他?

    由上一问可知,this指针无需显式储存内存中。只要存储对象的内存位置确定,对应的this指针就被确定了。

    #3:this指针如何传递给类中函数的?绑定?还是在函数参数的首参数就是this指针.那么this指针又是如何找到类实例后函数的?
    this是通过函数参数的首参数来传递的。this指针是在调用之前生成的。类实例后的函数,没有这个说法。类在实例化时,只分配类中的变量空间,并没有为函数分配空间。自从类的函数定义完成后,它就在那儿,不会跑的。
    #4:this指针如何访问类中变量的?
    如果不是类,而是结构的话,那么,如何通过结构指针来访问结构中的变量呢?如果你明白这一点的话,那就很好理解这个问题了。
    在C++中,struct是一种类类型,struct和class只有一个区别的:class的成员和继承默认的访问控制权限是private,而struct是public。
    this是class或public的对象的指针。
    #5:我们只有获得一个对象后,才能通过对象使用this指针,如果我们知道一个对象this指针的位置可以直接使用吗?
    this指针只有在非静态成员中才有意义。获得一个对象后,不需要在类外部使用this对其操作。应当注意this是一个右值(方法的一个隐式参数) ,不存在所谓的this的“位置”,只是this表示了对象的存储位置而已。&this违反语义规则,是错误的用法,不会编译通过。
    #6:每个类编译后,是否创建一个类中函数表保存函数指针,以便用来调用函数?
    一般来说,对于类成员函数(不论是静态还是非静态的成员函数)都不需要创建一个在运行时的函数表来保存。只有虚函数才会被放到函数表中。
    但是,即使是虚函数,如果编译器能明确知道调用的是哪个函数,编译器就不会通过函数表中的指针来间接调用,而是可以直接调用该函数。

    本文小结

    1.this是一个指针,指向对象的地址,不是对象本身。

    复制代码

    class A
    {
    private:
        int i;
    public:
        void fun()
    {
          this->i;
    };
        A();
       ~A();
    }
    int main()
    {
        A a1,a2;
        a1.fun();//一个this指向a1的地址,作用a1的fun
        a2.fun();//另一个this指向a2的地址,作用a2的fun
    }

    复制代码

     

    2.this只能作用于在类内的非静成员函数里,并不在静态成员函数起作用。

    复制代码

    class A
    {
    private:
        int i;
        static int j;
    public:
        void fun();
        static void s_fun()
    {
    //由于静态成员函数属于类的,是每个对象共享的,所以this不能在这里起作用。
         this->i;//错误,this引用任何成员都是错误。
    };
        A();
       ~A();
    }

    复制代码

    3.通过this引用出来的是对象的成员函数(包括静态成员函数)和成员变量(包括静态成员变量),析构函数等。但不能是构造函数

    复制代码

    class A
    {
    private:
       int i;
       static int j;
    public:
        void fun()
    {
         this->i;//正确
         this->j;//正确
         this->s_fun();//正确
         this->fun();//正确
         this->A();//错误
         this->~A();//正确
    };
        static void s_fun();
        A();
       ~A();
    }

    复制代码

     

    this面试题

    (1)选自《C/C++程序员宝典》面试题91。

    复制代码

    #include<iostream>
    using namespace std;
    class A
    {
    public:
        A()
        {
            a = b = 0;
        }
        A(int a, int b)
        {
            this->a = a;
            this->b = b;
        }
        void copy(A &aa);//对象引用作函数参数
        void print()
        {
            cout << a << "," <<b<< endl;
        }
    private:
        int a, b;
    };
    void A::copy(A &aa)
    {
        if (this == &aa)
            return;//这个this是操作对象a1的地址
        *this = aa;//*this操作该成员函数的对象,在这里是对象a1
        //对象aa赋给a1,aa具有的数据成员的值赋给a1的数据成员
    }
    
    int main()
    {
        A a1, a2(3, 4);
        a1.copy(a2);
        a1.print();
        return 0;
    }

    复制代码

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

    展开全文
  • C++中this指针的用法详解

    千次阅读 2019-08-31 10:28:02
    1. this指针的用处:  一个对象的this指针并不是对象本身的一部分,不会影响sizeof(对象)的结果。this作用域是在类内部,当在类的非静态成员函数中访问类的非静态成员的时候,编译器会自动将对象本身的地址作为一个...

    1. this指针的用处:

      一个对象的this指针并不是对象本身的一部分,不会影响sizeof(对象)的结果。this作用域是在类内部,当在类的非静态成员函数中访问类的非静态成员的时候,编译器会自动将对象本身的地址作为一个隐含参数传递给函数。也就是说,即使你没有写上this指针,编译器在编译的时候也是加上this的,它作为非静态成员函数的隐含形参,对各成员的访问均通过this进行。  例如,调用date.SetMonth(9) <===> SetMonth(&date, 9),this帮助完成了这一转换 .

    2. this指针的使用:

    一种情况就是,在类的非静态成员函数中返回类对象本身的时候,直接使用 return *this;另外一种情况是当参数与成员变量名相同时,如this->n = n (不能写成n = n)。

    3. this指针程序示例:

    this指针存在于类的成员函数中,指向被调用函数所在的类实例的地址。  根据以下程序来说明this指针  

    #include   
    
    class Point   {   int x, y;   
    
    public:   
    
    Point(int a, int b) { x=a; y=b;}   
    
    void MovePoint( int a, int b){ x+=a; y+=b;}   
    
    void print(){ cout<<"x="<<x<<"y="<<y<<endl;} <="" font="">  
    
    };   
    
    void main( )   {   
    
    Point point1( 10,10);   
    
    point1.MovePoint(2,2);   
    
    point1.print( );   
    
    }   

    当对象point1调用MovePoint(2,2)函数时,即将point1对象的地址传递给了this指针。  

    MovePoint函数的原型应该是 void MovePoint( Point *this, int a, int b);第一个参数是指向该类对象的一个指针,我们在定义成员函数时没看见是因为这个参数在类中是隐含的。这样point1的地址传递给了this,所以在MovePoint函数中便显式的写成:  

    void MovePoint(int a, int b) { this->x +=a; this-> y+= b;}   即可以知道,point1调用该函数后,也就是point1的数据成员被调用并更新了值。  即该函数过程可写成point1.x+= a; point1. y + = b;

    4. 关于this指针的一个经典回答:

    当你进入一个房子后,  

    你可以看见桌子、椅子、地板等,  

    但是房子你是看不到全貌了。  

    对于一个类的实例来说,  

    你可以看到它的成员函数、成员变量,  

    但是实例本身呢?  

    this是一个指针,它时时刻刻指向你这个实例本身

     

    5. 类的this指针有以下特点:

    1this只能在成员函数中使用。

    全局函数、静态函数都不能使用this.

    实际上,成员函数默认第一个参数为T * const this。

    如:

     class A
    
     {
    
      public:
    
         int func(int p)
    
         {
    
         }
    
     };

    其中,func的原型在编译器看来应该是:

      int func(A * const this,int p);

    2)由此可见,this在成员函数的开始前构造,在成员函数的结束后清除。

    这个生命周期同任何一个函数的参数是一样的,没有任何区别。

    当调用一个类的成员函数时,编译器将类的指针作为函数的this参数传递进去。如:

    A a;

    a.func(10);

    此处,编译器将会编译成:

    A::func(&a,10);

    看起来和静态函数没差别,对吗?不过,区别还是有的。编译器通常会对this指针做一些优化,因此,this指针的传递效率比较高--如VC通常是通过ecx寄存器传递this参数的。

    3)几个this指针的易混问题。

    A. this指针是什么时候创建的?

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

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

    B. this指针存放在何处?堆、栈、全局变量,还是其他?

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

    C. this指针是如何传递类中的函数的?

    绑定?还是在函数参数的首参数就是this指针?那么,this指针又是如何找到“类实例后函数的”?

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

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

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

    如果不是类,而是结构体的话,那么,如何通过结构指针来访问结构中的变量呢?如果你明白这一点的话,就很容易理解这个问题了。

    C++ ,类和结构是只有一个区别的:类的成员默认是private,而结构是public

    this是类的指针,如果换成结构,那this就是结构的指针了。

     

    E. 我们只有获得一个对象后,才能通过对象使用this指针。

    如果我们知道一个对象this指针的位置,可以直接使用吗?

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

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

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

    展开全文
  • c++ this指针与const对象

    千次阅读 2017-11-16 18:38:38
    在 c++的const对象一文中已经介绍了const对象的属性,本文尝试从this指针的角度,再来分析const对象。 1. 问题引入   同样的示例,定义一个类,并将其实例化为const对象: //1_const_obj.cpp class Obj { ...
  • 因为普通函数不是类成员函数,如果想要访问类成员,在执行回调函数的时候,要把对象指针传给回调函数,如下代码: namespace yy0 { //普通全局函数 void call_back(void* pointer); class A { public:
  • this指针常识性问题

    2018-07-08 00:20:35
    下面关于this指针的说法正确的是: A.调用类的成员函数时,对象的地址会隐式地作为第一个参数传递给this指针; B.通过取地址符&amp;可以获得this指针的地址; C.对象进行sizeof运算时会加上this指针所占用的...
  • A) 静态成员函数中不能使用this指针 B) this指针就是指向成员函数所作用的对象 的指针 C) 每个对象的空间中都存放着一个this指针 D) 类的非静态成员函数,真实的参数比所 写的参数多1 this指针 在建立对象时...
  • 不要再构造函数中使用this指针

    千次阅读 2019-02-12 22:13:25
    只有当构造函数完成后,这个对象才是真正有效的,即this才是正确的。而再构造中使用this时,这个对象并没有完全的初始化好,所以存在问题。 https://blog.csdn.net/zenghui08/article/details/11853685 ...
  • 【C++】隐含的this指针

    千次阅读 2017-03-12 11:13:28
    当我们在进入一个房子之后,你可以看见房子里面的桌子、椅子、地板... 在类的成员函数内部,暗含着一个名字是this指针,这个指针指向了调用该函数的类对象。 下面我们来看一个简单的例子:class Employee { pubilc:
  • this指针和 *this

    千次阅读 2014-12-21 19:01:09
    我们都知道,类的成员函数有一个附加的隐形形参,即指向该类对象的this指针,它与调用成员函数的对象绑定在一起。那么,这个this指针究竟是什么样的指针呢?其解引用*this返回的又是怎样的一个对象呢? 首先,我们以...
  • this指针到底存放到哪里

    千次阅读 2018-06-13 15:09:55
    当一个对象调用某成员函数时会隐式传入一个参数, 这个参数就是this指针this指针中存放的就是这个对象的首地址。 这和C中通过向函数传递结构体变量的地址是不是很像?只是传参形式不一样罢了! 在C中我们是手工把...
  • C++类中this指针的含义

    千次阅读 2018-04-04 11:44:29
     而对于成员函数Test4()要访问类的成员变量,因此要使用this指针,这个时候发现this指针的值为NULL,就会造成程序的崩溃。       this是指向实例化对象本身时候的一个指针,里面存储的是对象本身的地址,通过该...
  • C++this指针详解

    千次阅读 多人点赞 2017-04-06 01:36:06
    我们知道在如下例子中。 ...Fun(int a)是Test的非静态成员函数,所以编译器在编译期间改写该函数时,会自动将一个名为this指针当作为第一个参数传入。 类似于:Fun(Test* const this,int a);
  • this指针的用法和含义

    千次阅读 2014-03-13 17:58:31
    2. 当对一个对象调用成员函数时,编译程序先将对象的地址赋给this指针,然后调用成员函数,每次成员函数存取数据成员时,由隐含使用this指针。 3. 当一个成员函数被调用时,自动向它传递一个隐含的参数,该参数是一...
  • C++ this指针与const成员函数

    千次阅读 2017-10-29 15:09:54
    C++ this指针与const成员函数this指针 ...this指针只能在成员函数中使用,全局函数、静态函数都不能使用this指针 **在普通成员函数中,this是一个指向非const对象的const指针(如类类型为Student,那么thi
  • C++ 面试题(一) this指针

    千次阅读 2014-03-30 10:26:30
    而对于成员函数Test4()要访问类的成员变量,因此要使用this指针,这个时候发现this指针的值为NULL,就会造成程序的崩溃。   其实,我们可以想象编译器把Test4()转换成如下的形式: void  ...
  • 什么时候使用this 指针

    千次阅读 2012-10-30 15:18:17
    一直没理解this应该什么时候用,今天自己添加一个Edit 的派生类,在里里面用到了this; 在这里用:GetDlgItem(IDC_EDIT1)-> GetWindowText(str); 一直有错误; 改成:this->GetWindowText(str); 则运行正确; ...
  • this指针 operator* 解析

    千次阅读 2014-11-19 11:32:21
    当我在侯捷先生的《STL源码剖析》中看到类似的代码时,我内心产生个疑惑:迭代器的->操作 会不会重复调用了解引用操作即operator*。...return *this; }   testFunc* operator->() { return &
  • C++中this指针存放在哪里

    千次阅读 2016-01-25 10:33:15
    类的静态成员函数因为没有this指针这个参数,所以类的静态成员函数也就无法调用类的非静态成员变量。 让我们调试,并对EXC进行手动修改会发现一点有趣的现象。 #include #include using ...
  • 而对于成员函数Test4()要访问类的成员变量,因此要使用this指针,这个时候发现this指针的值为NULL,就会造成程序的崩溃。   其实,我们可以想象编译器把Test4()转换成如下的形式: void  CNullPointCall::...
  • 谈谈基类与子类的this指针(C++)

    千次阅读 2015-08-06 22:52:41
    这里在基类中使用this的意思有点像,由于子类对象没构造好,但是指向对象的指针已近指向那个对象了,早晚对象都会构造好的,那不如先拿this指针代替子类对象用! 补充: 构造函数为什么不能是虚函数  1. 从...
  • 深入探讨this指针:从汇编的角度考虑 总结:至此我们对this指针和成员函数调用有了更进一步的认识, (1) this 指针只存在于成员函数内部, (2) 成员函数的调用时,this指针并没有那么神秘,那完全可以认为对象在调用...
  • error C2663 重载没有“this指针的合法转换error C2663: “XXX”: 1 个重载没有“this指针的合法转换error C2663: “XXX”: 2 个重载没有“this指针的合法转换error C2663: “XXX”: 3 个重载没有“this指针...
  • void Date::setMonth( int mn ) {   month = mn; // 这三句是等价的   this->month = mn;... Please choose the right statement of "this" pointer:(下面关于this指针哪个描述是正确的) A.
  • C++智能指针的enable_shared_from_this和shared_from_this机制

    千次阅读 多人点赞 2019-04-02 18:40:43
    知识的学习在于点滴记录,坚持不懈;知识的学习要有深度和广度,不...如果不熟悉C++带引用计数的智能指针shared_ptr和weak_ptr,请参考我的另一篇介绍智能指针的博客:https://blog.csdn.net/QIANGWEIYUAN/article/d...
  • 如何给一个字符指针char *p 赋值?很多人会迅速的写出:我看到很多博客上面写的是这样操作: char *p; p="hello"; 在C语言中这种方式确实是被允许的,但是到c++11中会给出警告(报错): 错误提示的...
  • 指针的详细使用介绍

    千次阅读 多人点赞 2018-07-13 11:38:09
    指针简介 指针是C语言中广泛使用的一种数据... 学习指针是学习C语言中最重要的一环, 能否正确理解和使用指针是我们是否掌握C语言的一个标志。同时, 指针也是C语言中最为困难的一部分,在学习中除了要正确理...
  • this指针的那些事儿

    千次阅读 2016-10-08 22:11:51
    this指针也叫自引用指针,专门用来存放当前正在被调用对象的地址。
  • 指针使用之一:初始化

    千次阅读 2020-02-23 17:03:21
    使用指针时如果出现了错误,第一步我们首先检查指针是否正确的进行了初始化。指针总是指向一个地址的,因此在检查初始化是否正确的时候, 可以关注一下,“=”号的右边是不是一个地址。 指针的初始化主要有两大类...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 156,106
精华内容 62,442
关键字:

关于this指针使用正确的是