C++的指向成员的指针和this指针 C++编程指向成员的指针以及this指针的基本使用指南

[storage-class-specifiers] [cv-qualifiers] type-specifiers [ms-modifier]
qualified-name ::* [cv-qualifiers] identifier
[= & qualified-name :: member-name];

// pointers_to_members1.cpp
class Window
{
public:
 Window();        // Default constructor.
 Window( int x1, int y1,     // Constructor specifying
 int x2, int y2 );      // window size.
bool SetCaption( const char *szTitle ); // Set window caption.
 const char *GetCaption();    // Get window caption.
 char *szWinCaption;      // Window caption.
};

// Declare a pointer to the data member szWinCaption.
char * Window::* pwCaption = &Window::szWinCaption;
int main()
{
}

const char * (Window::*pfnwGC)() = &Window::GetCaption;
bool (Window::*pfnwSC)( const char * ) = &Window::SetCaption;

Window wMainWindow;
Window *pwChildWindow = new Window;
char *szUntitled = "Untitled - ";
int cUntitledLen = strlen( szUntitled );

strcpy_s( wMainWindow.*pwCaption, cUntitledLen, szUntitled );
(wMainWindow.*pwCaption)[cUntitledLen - 1] = '1';  //same as
//wMainWindow.SzWinCaption [cUntitledLen - 1] = '1';
strcpy_s( pwChildWindow->*pwCaption, cUntitledLen, szUntitled ); 
(pwChildWindow->*pwCaption)[cUntitledLen - 1] = '2'; //same as //pwChildWindow->szWinCaption[cUntitledLen - 1] = '2';

// Allocate a buffer.
enum {
 sizeOfBuffer = 100
};
char szCaptionBase[sizeOfBuffer];

// Copy the main window caption into the buffer
// and append " [View 1]".
strcpy_s( szCaptionBase, sizeOfBuffer, (wMainWindow.*pfnwGC)() );
strcat_s( szCaptionBase, sizeOfBuffer, " [View 1]" );
// Set the child window's caption.
(pwChildWindow->*pfnwSC)( szCaptionBase );

// virtual_functions.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

class Base
{
public:
virtual void Print();
};
void (Base ::* bfnPrint)() = &Base :: Print;
void Base :: Print()
{
cout << "Print function for class Base\n";
}

class Derived : public Base
{
public:
void Print(); // Print is still a virtual function.
};

void Derived :: Print()
{
cout << "Print function for class Derived\n";
}

int main()
{
 Base *bPtr;
 Base bObject;
Derived dObject;
bPtr = &bObject; // Set pointer to address of bObject.
(bPtr->*bfnPrint)();
bPtr = &dObject; // Set pointer to address of dObject.
(bPtr->*bfnPrint)();
}

//Output: Print function for class Base
Print function for class Derived

  this 
this->member-identifier

myDate.setMonth( 3 );

setMonth( &myDate, 3 );

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

return *this;

if (&Object != this) {
// do not execute in cases of self-reference

// this_pointer.cpp
// compile with: /EHsc

#include <iostream>
#include <string.h>

using namespace std;

class Buf 
{
public:
 Buf( char* szBuffer, size_t sizeOfBuffer );
 Buf& operator=( const Buf & );
 void Display() { cout << buffer << endl; }

private:
 char* buffer;
 size_t sizeOfBuffer;
};

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;
}

int main()
{
 Buf myBuf( "my buffer", 10 );
 Buf yourBuf( "your buffer", 12 );

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

 // assignment opperator
 myBuf = yourBuf;

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

my buffer
your buffer

// type_of_this_pointer1.cpp
class Point
{
 unsigned X() const;
};
int main()
{
}

// type_of_this_pointer2.cpp
class Point
{
 unsigned X() const;
};
int main()
{
}

[cv-qualifier-list] class-type * const this