this 指针的作用

this变量代表对象本身

当类中有两个同名变量，一个属于类（类的成员变量），而另一个属于某个特定的方法（方法中的局部变量），使用this区分成员变量和局部变量。

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

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

看了你的大概意思，理解上是可以的。

函数里的theAppm_pCurrentWinApp返回的是什么？ 是theApp自己还是基类的对象？

它返回的就是theApp的，也就是派生类对象的地址。

其实派生类对象中就有基类部分。

那么基类构造函数里的this是基类的临时对象还是派生类的对象theApp，是派生类对象的地址指针this,不是基类的。调用基类的构造函数，就是对派生类继承基类的部分的数据进行赋值。

先要理解class的意思。class应该理解为一种类型，象int,char一样，是用户自定义的类型。（虽然比int char这样build-in类型复杂的多，但首先要理解它们一样是类型)。用这个类型可以来声明一个变量，比如int x, myclass my等等。这样就像变量x具有int类型一样，变量my具有myclass类型。

理解了这个，就好解释this了，my里的this 就是指向my的指针。如果还有一个变量myclass mz，mz的this就是指向mz的指针。 这样就很容易理解this 的类型应该是myclass ,而对其的解引用this就应该是一个myclass类型的变量。

通常在class定义时要用到类型变量自身时，因为这时候还不知道变量名（为了通用也不可能固定实际的变量名），就用this这样的指针来使用变量自身。

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

例如，调用dateSetMonth(9) <===> SetMonth(&date, 9)，this帮助完成了这一转换 2 this指针的使用:一种情况就是，在类的非静态成员函数中返回类对象本身的时候，直接使用 return this；另外一种情况是当参数与成员变量名相同时，如this->n = n （不能写成n = n）。 3 this指针程序示例:this指针是存在与类的成员函数中,指向被调用函数所在的类实例的地址。根据以下程序来说明this指针

#include<iostreamh>

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

point1MovePoint(2,2);

point1print( );

}当对象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的数据成员被调用并更新了值。

即该函数过程可写成 point1x+= a; point1 y + = b;4 关于this指针的一个精典回答:当你进入一个房子后，

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

但是房子你是看不到全貌了。对于一个类的实例来说，

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

但是实例本身呢？

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

--------------------------------------------------------------------------------------------------------------------------------------------------------------------

它实际上是类定义中一个缺省的预定义的指针。当调用一个成员函数时，系统保证this 指针始终指向产生这个调用的对象，并将该指针作为一个变元自动传递给该函数。同时，只有对象和成员函数之间才存在 this 指针。

示例下面一段程序创建一个叫做power的类来计算一个数的幂：

power

{

private:

double b, val;

int e;

public:

power(double base, int exp);

double get_power() { return val;}

};

power::power(double base ,int exp)

{

b = base;

e = exp;

val = 1;

if(exp == 0)

return;

for(; exp > 0; exp--)

val = val b;}

void main()

{

power x(40, 2), y(25, 1), z(57, 0);

cout << xget_power() <<"";

cout << yget_power() <<"";

cout << zget_power() <<"\n";

}

在一个类的成员函数内部（如power()），可以直接引用一个类的数据成员，而无需用任何对象或类的限制性说明。所以在 power 类的构造函数 power() 里语句b = base; 意味着参数 base 的值将被赋予产生这个调用的对象中的数据成员 b。在程序中分别定义了 power 的三个对象 x、y 和z，编译器将对象的成员函数与同一对象的数据成员在调用时联系在一起，为此编译器实际上给成员函数传递了一个隐藏的指向函数调用所要引用的对象的指针，即 this 指针。相同的语句可以改写如下：

this->b = base;

这表明，当发生函数调用时（例如当新建一个 power 类的对象x时），编译器传给构造函数 power() 一个指向对象 x 的 this 指针，并隐式地使用这个指针访问属于对象x的b的拷贝。其实上述 power() 函数中的 b=base 等语句只是简写形式，下面是用 this 指针改写的完整的 power（）函数：

power::power(double base , int exp)

{

this->b = base;

this->e = exp;

this->val = 1;

if(exp == 0) return;

for(; exp>0; exp--)

this->val = this->valthis->b;

}

在这个例子中，数据成员的名字前缀表达式 this-> 是合法的但没有什么效果，因为this 指针的使用本来就是隐式的。友元函数不是类的成员，而且没有this指针，静态成员函数也没有 this 指针。但在另一些情况下，必须用 this 指针明确当前调用的对象，如在重载运算符时，可以看到 this 指针是非常重要的，它在某些类型的链表管理中往往也是必要的

----------------------------------------------------------------------------------------------------------trackback：http://topiccsdnnet/u/20070306/22/81af1a98-6633-4be4-9690-59575f42ee3ahtmlthis在成员函数的开始前构造，在成员的结束后清除。

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

因为，成员函数默认第一个参数就是this。

举例：

class A{

public:

int func(int p){}

};

func的原型在编译器看来，应该是

int func(A const this, int p);

即开始执行成员函数之前，构造。

成员函数执行结束，清除。

如果class或者struct里没有成员函数，this是没有构造函数的。只能当作C的STRUCT使用

Student(string name, int age, string major) : Human(name,age) // 为什么觉得这样写不对

{

this->major = major;

}

1this指针只在类的成员函数中使用，当类的成员函数需要用到自己的指针时就要用到this指针。但静态函数不能使用。比如：

class ExamThis

{

int ShowThis()//定义一个显示自己指针的成员函数。

{

printf（“This is my this pointer:%x

",this);

}

}；

2this的另一个用途是调用当前对象的另一个构造函数

3在你的方法中的某个形参名与当前对象的某个成员有相同的名字，这时为了不至于混淆，你便需要明确使用this关键字来指明你要使用某个成员，使用方法是“this成员名”，而不带this的那个便是形参。

4this后加参数则调用的是当前具有相同参数的构造函数

class Person{

public static void prt(String s){

Systemoutprintln(s);

}

Person(){

prt("A Person");

}

Person(String name){

prt("A person name is:"+name);

}

}

public class Chinese extends Person{

Chinese(){

super(); //调用父类构造函数（1）

prt("A chinese");//(4)

}

Chinese(String name){

super(name);//调用父类具有相同形参的构造函数（2）

prt("his name is:"+name);

}

Chinese(String name,int age){

this(name);//调用当前具有相同形参的构造函数（3）

prt("his age is:"+age);

}

public static void main(String[] args){

Chinese cn=new Chinese();

cn=new Chinese("kevin");

cn=new Chinese("kevin",22);

}

}

在构造函数中this用于限定被相同的名称隐藏的成员，例如：

class Employee{public Employee(string name, string alias) { thisname = name; thisalias = alias; }}

将对象作为参数传递到其他方法时也要用this表达，例如：

CalcTax(this);

声明索引器时this更是不可或缺，例如：

public int this [int param]{ get { return array[param]; } set { array[param] = value; }}

static用法：

静态方法

　　通常，在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法。如下所示：

class Simple{

static void go(){

Systemoutprintln("Go");

}

}

public class Cal{

public static void main(String[] args){

Simplego();

}

}

　　调用一个静态方法就是“类名方法名”,静态方法的使用很简单如上所示。一般来说，静态方法常常为应用程序中的其它类提供一些实用工具所用，在Java的类库中大量的静态方法正是出于此目的而定义的。