下载文档原格式
this的四种⽤法及注意事项1.代表成员变量我们如何区分开：同名的成员变量和在构造⽅法中的局部变量呢？---⽤this。
package com.dh.oop;public class ThisDemo {public String name;public ThisDemo(String name){//将构造⽅法的参数值赋值给成员变量 = name;}}在构造⽅法中，this代表的就是成员变量。
2.代表当前对象的引⽤我们知道，在实例化对象时，会利⽤构造⽅法进⾏初始化成员变量，所以每调⽤⼀次构造⽅法，初始化的都是正在实例化的这个对象的成员变量，即this，所以在构造⽅法中输出this，结果为当前对象的哈希码值。
对象是引⽤数据类型，直接输出，输出的就是其地址。
package com.dh.oop;public class ThisDemo {public String name;public ThisDemo(){//在构造⽅法中输出this，为当前调⽤构造⽅法实例化对象的哈希码值System.out.println(this);}public static void main(String[] args) {ThisDemo tom = new ThisDemo();ThisDemo jerry = new ThisDemo();}}3.在构造⽅法中使⽤this调⽤其它构造⽅法package com.dh.oop;public class ThisDemo {public String name;public int age;//第⼀个构造⽅法public ThisDemo(String name){//调⽤第⼆个构造⽅法this(name,18);}//第⼆个构造⽅法public ThisDemo(String name,int age) { = name;this.age = age;}public static void main(String[] args) {//调⽤第⼀个构造⽅法ThisDemo tom = new ThisDemo("tom");System.out.println(+"\t"+tom.age);}}分析结果，虽然在main⽅法中调⽤的是第⼀个构造⽅法，但由于在第⼀个构造⽅法中调⽤了第⼆个构造⽅法，所以输出了tom 18。
探讨一下构造函数中base和this的用法与区别(C#版)探讨一下构造函数中base和this的用法与区别(C#版)这篇文章主要介绍一下在构造函数中base和this的用法和区别的。
接下来的文章会陆续介绍一下静态变量和静态构造函数。
希望大家能够将意见反馈给我。
代码最具有说服性了，看下面代码吧：//代码段一public class ConstructorProgram1{private string name;public ConstructorProgram1(){Console.WriteLine("No Info Left");}public ConstructorProgram1(string name){ = name;Console.WriteLine("name=" + );}}这里我重载了另外一个构造函数，里面的this作为一个指针指示了一个类的引用。
即是ConstructorProgram1类的引用。
这个很简单，但不是重点。
这篇文章最重点要说一下：this和base在构造函数中扮演的角色。
看下面的代码：public class ConstructorProgram{private string name;private int age;public ConstructorProgram():this("bell"){//Console.WriteLine("No Info Left.");}public ConstructorProgram(string name):this("Simple Programmer",20){ = name;Console.WriteLine("name=" + );}public ConstructorProgram(string name, int age){ = name;this.age = age;Console.WriteLine("name=" + );Console.WriteLine("age=" + this.age);}public static void Main(){ConstructorProgram cp1= new ConstructorProgram("goal");ConstructorProgram cp2 = new ConstructorProgram();}}运行结果:name=Simple Programmerage=20name=goalname=Simple Programmerage=20name=bell在上面的代码当中，可以看出来这里红色字体的this用来调用ConstructorProgram类的自身的构造函数。
this指针及用法this指针是C++中的一个特殊指针，它指向当前对象的地址。
它主要用于在类的成员函数中访问当前对象的成员变量和成员函数。
使用this指针有以下几个方面的用法：1. 访问成员变量：在类的成员函数中，可以使用this指针来访问当前对象的成员变量。
这是因为成员函数中的变量名可能与成员变量名相同，使用this指针可以明确指出要访问的是成员变量而不是局部变量。
例如：cpp.class MyClass {。
public:void setX(int x) {。
this->x = x; // 使用this指针访问成员变量x.}。
private:int x;};2. 返回当前对象：在类的成员函数中，可以使用this指针返回当前对象的引用。
这可以方便地实现链式调用。
例如：cpp.class MyClass {。
public:MyClass& setX(int x) {。
this->x = x;return this; // 返回当前对象的引用。
}。
private:int x;};3. 在构造函数中使用：在构造函数中，this指针指向正在创建的对象。
这可以用于在构造函数中进行成员变量的初始化。
例如： cpp.class MyClass {。
public:MyClass(int x) {。
this->x = x; // 使用this指针初始化成员变量x.}。
private:int x;};4. 解决命名冲突：当类的成员变量与函数参数或局部变量同名时，可以使用this指针来区分它们。
例如：cpp.class MyClass {。
public:void setData(int data) {。
this->data = data; // 使用this指针访问成员变量data.}。
private:int data;};总结起来，this指针在C++中用于在类的成员函数中访问当前对象的成员变量和成员函数，解决命名冲突以及返回当前对象的引用。
c++this的用法在C++中，this是一个特殊的指针，它指向当前对象的地址。
this常常在类方法中使用，用于在类方法中访问对象的成员变量和成员函数。
一、this的基本用法在类方法中，this指针指向调用该方法的对象。
通过使用this指针，可以在类方法中直接访问对象的成员变量和成员函数，而无需使用对象名。
例如：```cppclassMyClass{intx;public:voidsetX(intvalue){x=value;//直接访问成员变量，无需使用对象名}voidprintX(){cout<<x;//直接访问成员变量，无需使用对象名，也可以使用this->x}};```在上面的例子中，setX()和printX()都是类方法，它们都使用了this指针来访问对象的成员变量x。
二、this的注意事项1.避免重复使用对象名和this指针：在类方法中，尽量避免重复使用对象名和this指针来访问对象的成员变量和成员函数。
这会导致代码冗余和难以阅读。
2.使用this指针时需要小心指针赋值：如果一个类方法被另一个类方法返回，并且该方法返回一个指向当前对象的指针，那么这个指针需要使用对象的地址来赋值。
否则，会导致悬空指针或未定义的行为。
3.this指针是类的内部指针：this指针是类的内部指针，不应该被外部代码直接访问。
如果外部代码需要访问对象的成员变量和成员函数，应该使用对象名来访问。
4.this指针的传递：如果需要在类方法中使用其他类的方法，可以将this 指针作为参数传递给其他类的方法。
但是需要注意，传递this指针可能会导致代码难以理解和维护。
三、this的常见用法示例下面是一些使用this指针的常见用法示例：1.在构造函数中使用this指针：在构造函数中，可以使用this指针来访问对象的成员变量和成员函数。
例如：```cppclassMyClass{intx;public:MyClass(intvalue):x(value){}//使用this指针初始化成员变量x};```2.在析构函数中使用this指针：在析构函数中，可以使用this指针来释放对象的资源。
vc++实现非窗口类中使用定时器的方法2010-09-17 21:44:35| 分类：默认分类| 标签：非窗口回调函数|字号大中小订阅定时器在视窗系统的程式中的作用不可忽略，也随处可见。
设定一个时间间隔每0.5秒或1秒钟刷新一次时钟，这样就能完成一个简单的电子钟程式。
在不同的编程工具中定时器的用法也不同，Visual C++中也给我们提供了实现这种功能的方法，而且方法不只一种。
在窗口类中是使用定时器比较简单，用SetTimer()设置了定时器之后，并在Class Wizard中添加了WM_TIMER消息映射后，你就能在映射函数OnTimer()中添加代码实现，来定时完成你的任务，而且还支持任意多个定时器，这种方法大家可能都会用。
不过在非窗口的类中，使用定时器就没那么简单了，在类消息映射中就未找到OnTimer()方法了，类中也没有hWnd 这个属性，SetTimer()也不能象原来那样使用了，下面给出了一种既不破坏类的完整性的同时又能巧妙的使用定时器的方法。
一、实现方法在非窗口类中使用定时器，需要了解的知识比较多。
首先非窗口类中没有消息映射，也没有象CWnd 类具有的SetTimer()方法来设置定时器。
没有消息映射，就只能靠我们自己定义的回调函数来处理定时器的消息，因此大家有必要了解一下回调函数的概念。
因为回调函数只能用全局函数或静态成员函数来实现，而为了维持类的完整性，又需求使用类的静态成员函数来作为回调函数，所以我们又需要了解一下静态数据成员和静态成员函数的性质。
又因为定时器是在我们的程式中产生的，这又需要来管理定时器，所以又用到了映射表类CMap，因此介绍一下CMap的简单用法也是必不可少的。
所谓回调函数就是按照一定的形式由研发人员定义并编写实现内容，当发生某种事件时由系统或其他函数来调用的函数。
使用回调函数实际上就是在调用某个函数（通常是API函数）时，将自己编写的一个函数（也就是回调函数）的地址作为参数传递给那个函数。
this（C# 参考）this关键字引用类的当前实例。
以下是this的常用用途：∙限定被相似的名称隐藏的成员，例如：复制代码public Employee(string name, string alias){ = name;this.alias = alias;}∙将对象作为参数传递到其他方法，例如：复制代码CalcTax(this);∙声明索引器，例如：复制代码public int this [int param]{get { return array[param]; }set { array[param] = value; }}由于静态成员函数存在于类一级，并且不是对象的一部分，因此没有this指针。
在静态方法中引用this是错误的。
示例在本例中，this用于限定Employee类成员name和alias，它们都被相似的名称隐藏。
this还用于将对象传递到属于其他类的方法CalcTax。
复制代码// keywords_this.cs// this exampleusing System;class Employee{private string name;private string alias;private decimal salary = 3000.00m;// Constructor:public Employee(string name, string alias){// Use this to qualify the fields, name and alias: = name;this.alias = alias;}// Printing method:public void printEmployee(){Console.WriteLine("Name: {0}\nAlias: {1}", name, alias);// Passing the object to the CalcTax method by using this: Console.WriteLine("Taxes: {0:C}", Tax.CalcTax(this));}public decimal Salary{get { return salary; }}}class Tax{public static decimal CalcTax(Employee E){return 0.08m * E.Salary;}}class MainClass{static void Main(){// Create objects:Employee E1 = new Employee("John M. Trainer", "jtrainer");// Display results:E1.printEmployee();}}输出Name: John M. TrainerAlias: jtrainerTaxes: $240.00比如你的类中有一个成员变量为a。
java中的this和super的作⽤和异同和C++中调⽤⽗类的构造函数这⼏天看到类在继承时会⽤到this和super，这⾥就做了⼀点总结，与各位共同交流，有错误请各位指正~thisthis是⾃⾝的⼀个对象，代表对象本⾝，可以理解为：指向对象本⾝的⼀个指针。
this的⽤法在java中⼤体可以分为3种：1.普通的直接引⽤这种就不⽤讲了，this相当于是指向当前对象本⾝。
2.形参与成员名字重名，⽤this来区分：1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17class Person {private int age = 10;public Person(){System.out.println("初始化年龄："+age);}public int GetAge(int age){this.age = age;return this.age;}}public class test1 {public static void main(String[] args) {Person Harry = new Person();System.out.println("Harry's age is "+Harry.GetAge(12)); }}运⾏结果：初始化年龄：10Harry's age is 12可以看到，这⾥age是GetAge成员⽅法的形参，this.age是Person类的成员变量。
3.引⽤构造函数这个和super放在⼀起讲，见下⾯。
supersuper可以理解为是指向⾃⼰超（⽗）类对象的⼀个指针，⽽这个超类指的是离⾃⼰最近的⼀个⽗类。
super也有三种⽤法：1.普通的直接引⽤与this类似，super相当于是指向当前对象的⽗类，这样就可以⽤super.xxx来引⽤⽗类的成员。
2.⼦类中的成员变量或⽅法与⽗类中的成员变量或⽅法同名12 3 4 5 6 7 8 9 10 11 12 13class Country {String name;void value() {name = "China";}}class City extends Country {String name;void value() {name = "Shanghai";super.value(); //调⽤⽗类的⽅法 System.out.println(name);13 14 15 16 17 18 19 20 21 System.out.println(name);System.out.println();}public static void main(String[] args) { City c=new City();c.value();}}运⾏结果：ShanghaiChina可以看到，这⾥既调⽤了⽗类的⽅法，也调⽤了⽗类的变量。
简述this指针的作用一、概述this指针是C++中的一个关键字，它代表当前对象的指针。
在类的成员函数中，使用this指针可以访问当前对象的成员变量和成员函数。
本文将详细介绍this指针的作用。
二、this指针的定义在C++中，每个对象都有一个隐含的指向自身的指针，这个指针就是this指针。
在类成员函数中，可以使用this关键字来访问当前对象。
三、this指针的作用1. 解决命名冲突当类中存在与全局变量或局部变量同名的成员变量时，在成员函数中使用该变量时会出现命名冲突。
此时可以使用this关键字来明确表示要访问的是类中的成员变量而不是全局或局部变量。
2. 返回当前对象在某些情况下，需要返回当前对象本身。
此时可以使用return *this;语句来返回当前对象。
3. 实现链式编程链式编程是一种编程风格，在调用函数后返回自身以便于链式调用其他函数。
例如：```object.func1().func2().func3();```其中，func1()返回object本身，可以直接调用func2()；func2()同样返回object本身，可以直接调用func3()。
这样就实现了链式编程。
使用this指针可以方便地实现链式编程。
4. 实现拷贝构造函数和赋值运算符重载在拷贝构造函数和赋值运算符重载中，需要将一个对象的值复制到另一个对象中。
此时可以使用this指针来访问当前对象的成员变量，再将其赋值给另一个对象。
5. 解决多态性问题在多态性中，父类指针指向子类对象时，如果调用子类对象的成员函数，则需要使用this指针来访问子类对象的成员变量和成员函数。
四、使用this指针的注意事项1. this指针只能在成员函数中使用。
2. this指针不能被修改。
3. 在静态成员函数中不能使用this指针。
4. 在全局作用域中不能使用this关键字。
五、总结本文介绍了this指针在C++中的作用。
通过使用this关键字，可以解决命名冲突、返回当前对象、实现链式编程、实现拷贝构造函数和赋值运算符重载以及解决多态性问题等。
MFC中的This的用法一、This指针的定义在MFC中，This指针是一个特殊的指针，它指向当前对象实例。
在类的成员函数中，可以通过"this"关键字访问This指针。
This指针主要用于在类的成员函数中引用当前对象，以便访问对象的属性和方法。
二、This指针的用途1. 访问对象的成员变量：通过This指针，可以在类的成员函数中访问对象的成员变量。
例如，在一个类的成员函数中，可以使用"this->变量名"的形式来访问对象的成员变量。
2. 调用对象的方法：通过This指针，可以在类的成员函数中调用对象的其他方法。
例如，在一个类的成员函数中，可以使用"this->方法名()"的形式来调用对象的其他方法。
3. 判断对象自身：在某些情况下，我们需要在类的成员函数中判断调用该方法的对象是否为当前对象实例。
这时可以使用This指针进行判断。
例如，在MFC中的消息处理函数中，可以使用"this == this"的形式来判断是否是同一对象实例。
三、This指针的使用场景1. 在类的成员函数中使用：在类的成员函数中，可以通过This指针访问当前对象的成员变量和方法。
2. 在回调函数中使用：在某些情况下，我们需要将类的成员函数作为回调函数传递给其他函数或线程。
这时可以使用This指针来访问当前对象实例。
3. 在多重继承中使用：在多重继承中，可以使用This指针来确定调用方法的对象的实际类型。
四、This指针与MFC框架的关系MFC框架是微软提供的一套用于Windows应用程序开发的C++类库，它基于C++编程语言。
在MFC框架中，类的成员函数通常都会使用This指针来引用当前对象实例。
通过使用This指针，MFC框架能够方便地实现面向对象编程的各种特性，如封装、继承和多态等。
同时，MFC框架也充分利用了C++的特性，如动态内存分配和异常处理等，使得Windows 应用程序的开发更加高效和可靠。
VC++中this指针的用法
this指针只能在一个类的成员函数中调用，它表示当前对象的地址。
下面是一个例子：
void Date::setMonth( int mn )
{
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指针会因编译器不同，而放置的位置不同。
可能是栈，也可能是寄存器，甚至全局变量。
#3:this指针如何传递给类中函数的?绑定?还是在函数参数的首参数就是this 指针.那么this指针又是如何找到类实例后函数的?
this是通过函数参数的首参数来传递的。
this指针是在调用之前生成的。
类实例后的函数，没有这个说法。
类在实例化时，只分配类中的变量空间，并没有为函数分配空间。
自从类的函数定义完成后，它就在那儿，不会跑的。
#4:this指针如何访问类中变量的/?
如果不是类，而是结构的话，那么，如何通过结构指针来访问结构中的变量呢？如果你明白这一点的话，那就很好理解这个问题了。
在C++中，类和结构是只有一个区别的：类的成员默认是private，而结构是public。
this是类的指针，如果换成结构，那this就是结构的指针了。
#5:我们只有获得一个对象后,才能通过对象使用this指针,如果我们知道一个对象this指针的位置可以直接使用吗?
this指针只有在成员函数中才有定义。
因此，你获得一个对象后，也不能通过对象使用this指针。
所以，我们也无法知道一个对象的this指针的位置（只有在成员函数里才有this指针的位置）。
当然，在成员函数里，你是可以知道this指针的位置的（可以&this获得)，也可以直接使用的。
#6:每个类编译后,是否创建一个类中函数表保存函数指针,以便用来调用函数?
普通的类函数（不论是成员函数，还是静态函数），都不会创建一个函数表来保存函数指针的。
只有虚函数才会被放到函数表中。
但是，既使是虚函数，如果编译器能明确知道调用的是哪个函数，编译器就不会通过函数表中的指针来间接调用，而是会直接调用该函数。
# 7:这些编译器如何做到的？
#8:能否模拟实现?
知道原理后，这两个问题就很容易理解了。
其实，模拟实现this的调用，在很多场合下，很多人都做过。
例如，系统回调函数。
系统回调函数有很多，如定时，线程啊什么的。
举一个线程的例子：
class A
{
int n;
public:
static void run(void* pThis)
{
A* this_ = (A*)pThis;
this_->process();
}
void process()
{
}
};
main()
{
A a;
_beginthread( A::run, 0, &a );
}
这里就是定义一个静态函数来模拟成员函数。
也有许多C语言写的程序，模拟了类的实现。
如freetype库等等。
其实，有用过C语言的人，大多都模拟过。
只是当时没有明确的概念罢了。
如：
typedef struct student
{
int age;
int no;
int scores;
}Student;
void initStudent(Student* pstudent);
void addScore(Student* pstudent, int score);
...
如果你把 pstudent改成this，那就一样了。
它相当于：
class Student
{
public:
int age; int no; int scores;
void initStudent();
void addScore(int score);
}
const常量可以有物理存放的空间，因此是可以取地址的
///this指针是在创建对象前创建.
this指针放在栈上,在编译时刻已经确定.
并且当一个对象创建后,并且运行整个程序运行期间只有一个this指针.
问题的提出：编写程序实现对象资源的拷贝（要求使用this指针）。
#include <iostream>
#include <string>
using namespace std;
class student{
private:
char *name;
int id;
public:
student(char *pName="no name",int ssId=0)
{
id=ssId;
name=new char[strlen(pName)+1];
strcpy(name,pName);
cout<<"construct new student "<<pName<<endl; }
void copy(student &s)
{
if (this==&s)
{
cout<<"Erro:can't copy one to oneself!"<<endl; return;
}else
{
name=new char[strlen()+1];
strcpy(name,);
id=s.id;
cout<<"the function is deposed!"<<endl;
}
}
void disp()
{
cout<<"Name:"<<name<<" Id:"<<id<<endl;
}
~student()
{
cout<<"Destruct "<<name<<endl;
delete name;
}
};
int main()
{
student a("Kevin",12),b("Tom",23);
a.disp();
b.disp();
a.copy(a);
b.copy(a);
a.disp();
b.disp();
return 0;
}
end!。
