标签: this-pointer

C++ 标准的第 9.3.2.1 节指出：

在非静态 (9.3) 成员函数的主体中，关键字 this 是一个纯右值表达式，其值是调用该函数的对象的地址。类 X 的成员函数中 this 的类型是 X*。如果成员函数声明为const，则this的类型为const X*，如果成员函数声明为volatile，则this的类型为volatile X*，如果成员函数声明为const volatile，则this的类型为const挥发性 X*。

那么如果this是一个纯右值，它的值类别是*this什么？以下表明即使对象是右值，*this也始终是左值。这样对吗？如果可能，请参考标准。

struct F;
struct test
{
    void operator()(F &&) { std::cout << "rvalue operator()" << std::endl; }
    void operator()(F const &&) { std::cout << "const rvalue operator()" << std::endl; }
    void operator()(F &) { std::cout << "lvalue operator()" << std::endl; }
    void operator()(F const &) { std::cout << "const lvalue operator()" << std::endl; }
};

struct …

我不确定

return *this

是唯一可以返回调用成员函数的类实例的方法吗？我问的原因是因为我们的教练告诉我们如果有必要避免使用指针,我想知道这是否是唯一必要的方法是返回this指针.

我正在使用一个包含私有数据成员分子和分母的分数类.我正在谈论的成员函数用于添加两个分数,例如:

Fraction C = A.plus(B);

加上成员函数定义如下:

Fraction& plus( const Fraction frac )

教练要我们做C = A + = B,所以我猜这就是原因.

我想知道在c ++中使用'this'引用类成员而不是不使用它有什么优势？

例如...

class Test
{
    public:
        Test();
        void print_test()
            {
                std::cout << this -> m_x   // Using 'this'
                          << endl;

                std::cout << m_x          // Rather than referencing 'm_x' this way
                          << endl;
            }
    private:
        int m_x;
        int m_y;
};

这里我举一个重载增量运算符的例子:

 class Digit
 {
     int m_digit;

  public:
      Digit (int value)   //constructor
          {
            m_digit = value;
          }

      Digit& operator++();

      int ret_dig (){return m_digit;}
};

Digit& Digit::operator++()
{
   if (m_digit == 9)
        m_digit = 0;

   else  ++m_digit;
    return *this;
 }

int main ()
{
   Digit my_dig (5);
   ++my_dig;
 return 0;
 }

我被告知无法返回局部变量."这个"不是局部变量吗？这是我的想法:

Digit类型的指针附加到成员函数(重载操作符函数).当编译器看到行++ my_dig(即Digit类的实例)时,它会调用成员函数.实例my_dig的地址作为参数传递给函数,并且有一个名为"this"的隐藏"const Digit*"来捕获参数."this"被解除引用(隐式)访问m_digit,这是类Digit的成员变量.所有增量或包装都在函数内部完成,然后对解除引用的"this"的引用返回给调用者.是的,这是我的困惑.如果"this"是const数字*类型的局部变量,返回时它不应该包含垃圾,因为"this"超出了块结束haaa的范围吗？

代码是:

class base{
    base(){}
    virtual base* copy()const=0;
    virtual ~base(){}
};
class derived:public base{
    derived(){}
    base* copy()const;
    ~derived(){}
};
base* derived::copy()const{
   return new derived(*this);
}

是否有必要new在函数中使用运算符copy()或代码使用new运算符的原因？

我应该直接返回this指针,如下所示:

const base* derived::copy()const{
   return this;// note: this pointer is const.
}

因此,以下是Class Sales_data的成员函数,它在类外定义,

Sales_data& Sales_data::combine(const Sales_data &rhs) {
    units_sold += rhs.units_sold;
    revenue += rhs.revenue; //adding the members of rhs into the members of "this" object
    return *this;
} //units_sold and revenue are both data members of class

当调用该函数时,它被称为

total.combine(trans); //total and trans are the objects of class

我不理解的是函数返回*this,我理解它返回一个对象的实例,但是它没有将这个实例返回给我们在函数调用期间可以看到的任何东西,如果我不写return语句,它会工作吗任何不同.

有人请详细解释,因为我只是没有得到它.

假设我有两个这样的ES6类:

class Base {
    static something() {
        console.log(this);
    }
}

class Derived extends Base {
}

然后我打个电话:

Derived.something();

请注意,我正在通过子类调用超类上定义的静态方法.

这并没有给我的错误.它打印

[Function: Derived]

因此,this在静态方法中访问似乎在这里工作.

我需要一个超级类的所有子类的公共静态方法,我需要能够知道什么子类正在调用此方法.

现在我的问题是this在静态方法中使用是否合法.我知道这些静态方法成为类方法,因此this自然会指向它们被调用的类对象.(类对象是构造函数.)

但我似乎无法找到任何明确的资源,表明ES规范允许这样做.

这看起来像一个很好的介绍ES6类,但没有谈及this与static.

我是c ++的新手,面临着常量对象的问题.我已经声明了一个名为function的常量成员函数(并且我已经知道常量函数只能由常量对象调用)但是这里常规对象调用一个常量对象.请解释为什么会这样.代码就在这里

myClass.h

#ifndef MYCLASS_H
#define MYCLASS_H

class myClass
{
    public:
        void function() const;  
};

#endif

myClass.cpp

#include "myClass.h"
#include<iostream>
using namespace std;

void myClass::function() const{
    cout<<"this is a constant object";
}

main.cpp中

#include <iostream>
using namespace std;
#include "myClass.h"

int main() {
    myClass obj;
    obj.function();

    return 0;
}

请帮帮我.谢谢

这是我想做的事情(可能不是最好的事情)能够调用一些类构造函数,它接收一个指向正在调用的类的指针(ufff !!!).代码看起来更好,就像我在C#中所做的那样.

public class SomeClass
{
   SomeOtherClass someOtherClass;

   //Constructor
   public SomeClass(SomeOtherClass someOtherClass)
   {
      this->someOtherClass = someOtherClass;
   }
}

public class SomeOtherClass
{

   public SomeOtherMethod()
   {
      SomeClass c = new SomeClass(this);
   }
}

那么,如何在c ++中实现相同的结果呢？Thanx提前.

举个例子：

SomeClass.h

class Foo {
public:
    static int bar;
    int x;
    void someFunc() {
        this->x = 5;
        this->bar = 9;
    }
};

SomeClass.cpp

int Foo::bar = 0;

mainc.pp

#include <iostream>
#include "SomeClass.h"

int main() {
    Foo f;
    f.someFunc();

    std::cout << "f.x = " << f.x << '\n';
    std::cout << "f.bar = " << f.bar << '\n';
    return 0;
}

使用Visual Studio 2017CE编译和构建。

输出量

f.x = 5
f.bar = 9

但是根据cppreference：static

类的静态成员不与该类的对象关联：它们是具有静态或线程（自C ++ 11起）存储持续时间或常规函数的自变量。

现在，对于静态成员函数，它们声明：

静态成员函数不与任何对象关联。调用时，它们没有此指针。

我只想对此有所澄清：我以为静态成员和静态函数成员都没有this与之关联的指针...