C++中this指针的使用

Every object in C++ has access to its own address through an important pointer called this pointer. The this pointer is an implicit parameter to all member functions. Therefore, inside a member function, this may be used to refer to the invoking object.

Friend functions do not have a this pointer,because friends are not members of a class. Only member functions have a this pointer.

The this pointer is a pointer accessible only within the nonstatic member functions of a class, struct, or union type. It points to the object for which the member function is called. Static member functions do not have a this pointer.

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

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

this指针使用场景：(1)、在类的非静态成员函数中返回类对象本身的时候，直接使用 return *this；(2)、当参数与成员变量名相同时，如this->n = n(不能写成n = n)。

The this pointer's type can be modified in the function declaration by the const and volatile keywords. To declare a function as having the attributes of one or more of these keywords, add the keyword(s) after the function argument list.

以下是测试代码：

this_pointer.hpp：

#ifndef FBC_MESSY_TEST_THIS_POINTER_HPP
#define FBC_MESSY_TEST_THIS_POINTER_HPP

#include <iostream>

// reference: http://www.tutorialspoint.com/cplusplus/cpp_this_pointer.htm class Box
{
public:
// Constructor definition
Box(double l = 2.0, double b = 2.0, double h = 2.0)
{
std::cout << "Constructor called." << std::endl;
length = l;
breadth = b;
height = h;
}
double Volume()
{
return length * breadth * height;
}
int compare(Box box)
{
return this->Volume() > box.Volume();
}
private:
double length;     // Length of a box
double breadth;    // Breadth of a box
double height;     // Height of a box
};

/*void Date::setMonth(int mn)
{
month = mn; // These three statements are equivalent
this->month = mn;
(*this).month = mn;
}*/

// reference: https://msdn.microsoft.com/en-us/library/y0dddwwd.aspx class Buf
{
public:
Buf(char* szBuffer, size_t sizeOfBuffer);
Buf& operator=(const Buf &);
void Display();

private:
char* buffer;
size_t sizeOfBuffer;
};

// reference: http://en.cppreference.com/w/cpp/language/this class T
{
int x;

void foo()
{
x = 6;       // same as this->x = 6;
this->x = 5; // explicit use of this->
}

void foo() const
{
//        x = 7; // Error: *this is constant
}

void foo(int x) // parameter x shadows the member with the same name
{
this->x = x; // unqualified x refers to the parameter
// 'this->' required for disambiguation
}

int y;
T(int x) : x(x), // uses parameter x to initialize member x
y(this->x) // uses member x to initialize member y
{}

T& operator= (const T& b)
{
x = b.x;
return *this; // many overloaded operators return *this
}
};

class Outer {
//int a[sizeof(*this)]; // error: not inside a member function
unsigned int sz = sizeof(*this); // OK: in default member initializer
void f() {
int b[sizeof(*this)]; // OK
struct Inner {
//int c[sizeof(*this)]; // error: not inside a member function of Inner
};
}
}

void test_this_pointer1();
void test_this_pointer2();

#endif // FBC_MESSY_TEST_THIS_POINTER_HPP

this_pointer.cpp：

#include "this_pointer.hpp"

Buf::Buf(char* szBuffer, size_t sizeOfBuffer)
{
sizeOfBuffer++; // account for a NULL terminator

buffer = new char[sizeOfBuffer];
if (buffer)
{
strcpy_s(buffer, sizeOfBuffer, szBuffer);
sizeOfBuffer = sizeOfBuffer;
}
}

Buf& Buf::operator=(const Buf &otherbuf)
{
if (&otherbuf != this) {
if (buffer)
delete[] buffer;

sizeOfBuffer = strlen(otherbuf.buffer) + 1;
buffer = new char[sizeOfBuffer];
strcpy_s(buffer, sizeOfBuffer, otherbuf.buffer);
}
return *this;
}

void Buf::Display()
{
std::cout << buffer << std::endl;
}

void test_this_pointer1()
{
Box Box1(3.3, 1.2, 1.5);    // Declare box1
Box Box2(8.5, 6.0, 2.0);    // Declare box2

if (Box1.compare(Box2)) {
std::cout << "Box2 is smaller than Box1" << std::endl;
} else {
std::cout << "Box2 is equal to or larger than Box1" << std::endl;
}
}

void test_this_pointer2()
{
Buf myBuf("my buffer", 10);
Buf yourBuf("your buffer", 12);

// Display 'my buffer'
myBuf.Display();

// assignment opperator
myBuf = yourBuf;

// Display 'your buffer'
myBuf.Display();
}

函数test_this_pointer1的测试结果如下图：



函数test_this_pointer2的测试结果如下图：



主要参考文献：

1. http://www.tutorialspoint.com/cplusplus/cpp_this_pointer.htm
2. https://msdn.microsoft.com/en-us/library/y0dddwwd.aspx
3. http://en.cppreference.com/w/cpp/language/this
GitHub：https://github.com/fengbingchun/Messy_Test