标签：写代码 nbsp 参数表 范围 c声明 成员变量 this指针 指针变量 ios
对象的自身引用是面向对象程序设计语言中特有的、十分重要的一种机制。在C++中，为这种机制设立了专门的表示：this指针变量。
在类的每一个成员函数的形参表中都有一个隐含的指针变量this，该指针变量的类型就是成员函数所属类的类型。
当程序中调用类的成员函数时，this指针变量被自动初始化为发出函数调用的对象的地址。
例如：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 #include <iostream> using namespace std; class Sample { int x, y; public: Sample(int a=0, int b=0) { x=a; y=b; } void print() { cout<<x<<endl; cout<<y<<endl; } }; int main() { Sample obj(5,10); obj.print(); return 0; }
上述程序可用this指针显示改写为完全等价的形式：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 #include <iostream> using namespace std; class Sample { int x, y; public: Sample(int a=0, int b=0) { this->x=a; //在此例中this=&obj this->y=b; } void print() { cout<<this->x<<endl; //在此例中this=&obj cout<<this->y<<endl; } }; int main() { Sample obj(5,10); //当程序中调用类的成员函数时，this指针变量被自动 obj.print(); //初始化为发出函数调用的对象的地址。 return 0; }
那么何时使用this指针呢？
例如：
1 2 3 4 void Sample::fun(int x) { this->x=x; }
一种使用this指针的应用是一个类的方法需要返回当前对象的引用。
例如：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 class Sample { private: int x; char* ptr; public: Sample & Set(int i, char *p); //.. }; Sample& Sample::Set(int i, char *p); //方法Set返回当前对象的引用，*this就是当前对象。 { x=i; ptr=p; return *this; }
对象数组与对象指针 对象数组 所谓对象数组是指每一数组元素都是对象的数组，也就是说，若一个类有若干个对象，我们把这一系列的对象用一个数组来存放。
例如：
1 2 3 Student stu[3]; 定义了类Student的对象数组stu。 系统调用无参构造函数3次。
如果类Student有2个数据成员姓名（char name[10]）、年龄(int age)，那么在定义对象数组时也可以实现初始化。
1 Student stu[3]={ Student(“zhao”,22), Student(“qian”,20), Student(“sun”，8,90) };
在建立对象数组时，分别调用构造函数，对每个元素初始化。
对象数组的应用：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 #include <iostream> using namespace std; class Sample { private: int x; public: void Set_x(int n) { x=n; } int Get_x() { return x; } }; int main() { Sample obj[4]; int i; for(i=0; i<4; i++) obj[i].Set_x(i); for(i=0; i<4; i++) cout<<obj[i].Get_x()<<” ”; cout<<endl; return 0; }
运行结果为：0 1 2 3
堆对象 使用new运算符动态分配的对象属于堆对象，其所占存储空间被分配在堆区。
利用new建立对象会自动调用构造函数，利用delete删除对象会自动调用析构函数。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 #include <iostream> using namespace std; class Date //定义日期类Date { private: int month, day, year; public: Date(int m, int d, int y); //声明构造函数 }; Date::Date(int m, int d, int y) //定义构造函数 { if (m>0 && m<13) month=m; if (d>0 && d<32) day=d; if (y>0 && y<3000) year=y; } int main() { Date *pd; //定义一个指向Date类的对象的指针变量pd pd=new Date(1,1,2008); //pd指向新建Date类的对象的起始地址 //…… delete(pd); //释放pd所指向的内存空间 return 0; }
对象指针 指向类对象的指针称为对象指针。
声明指向类对象的指针变量的一般形式为类名 *对象指针名;指针变量名->成员名(*指针变量名).成员名
例如：
1 2 Date obj, *pt; pt=&obj;
定义指向Date类对象obj的指针变量pt。
1 2 3 4 5 *pt //pt所指向的对象，即obj (*pt).year //pt所指向的对象obj中的year成员，即obj.year pt->year //pt所指向的对象obj中的year成员，即obj.year (*pt).get_date() //调用所指向的对象obj中的get_date函数，即obj.getdate() pt->get_date //调用所指向的对象obj中的get_date函数，即obj.getdate()
有关对象指针的使用方法
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 #include <iostream> using namespace std; class Date //定义日期类Date { private: int month, day, year; public: Date(int m, int d, int y); //声明构造函数 void showDate(); //声明显示数据成员值的成员函数 }; Date::Date(int m, int d, int y) //定义构造函数 { if (m>0 && m<13) month=m; if (d>0 && d<32) day=d; if (y>0 && y<3000) year=y; } void Date::showDate() { cout<<year<<”.”<<month<<”.”<<day<<endl; } int main() { Date obj(2008,1,1); //定义Date类对象obj int *pt1=&obj.year; //定义指向整型数据的指针变量pt1，并使pt1 指向obj.year cout<<*pt1<<endl; //输出pt1所指向的数据成员obj.year obj.showDate(); //调用对象obj的成员函数showDate() Date *pt2=&obj; //定义指向Date类对象的指针变量pt2，并使pt2指向obj pt2->showDate(); //调用pt2所指向对象obj的showDate()函数 return 0; }
运行结果为：
静态成员 为了实现一个类的不同对象之间的数据和函数共享，C++提出了静态成员的概念。静态成员包括:
在类的定义中，可以用关键字static声明成员为静态成员，这些静态成员可以在同一个类的不同对象之间提供数据共享。
静态数据成员 公有的静态数据成员可以在对象定义之前被访问，形式为：类名：：公有静态成员变量名；对象名.公有静态成员变量名；
静态数据成员的定义与使用示例:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 #include<iostream> using namespace std; class Ctype {private: int a; static int s; //定义私有的静态数据成员s public: void print(); Ctype(int x=0); }; void Ctype::print() { cout<<”a=”<<++a<<endl; //输出普通数据成员 cout<<”s=”<<++s<<endl; //输出静态数据成员，两者作比较 } Ctype::Ctype(int x) { a=x; } int Ctype::s=0; //静态数据成员赋初值在类体外进行，前面不能再加static int main() { Ctype c1,c2,c3; //定义3个对象，都使用默认的参数值 c1.print(); c2.print(); c3.print(); return 0; }
运行结果为：
静态数据成员和一般数据成员的不同
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 #include<iostream> using namespace std; class Student { private: static int count; //声明静态数据成员count，统计学生的总数 int StudentNo; //普通数据成员，用于表示每个学生的学号 public: Student() //构造函数 { ++count; //每创建一个学生对象，学生数加1 StudentNo=count; //给当前学生的学号赋值 } void Print() //成员函数，显示学生的学号和当前学生数 { cout<<”Student”<<StudentNo<<” ”; cout<<”count=”<<count<<endl; } }; int Student::count=0; //给静态数据成员couny赋初值 int main() { Student Student1; //创建第1个学生对象 Student1.print(); cout<<"---------"<<endl; Student Student2; //创建第2个学生对象 Student2 Student1.Print(); Student2.Print(); cout<<"----------"<<endl; Student Student3; //创建第3个学生对象Student3 Student1.Print(); Student2.Print(); Student3.Print(); cout<<"----------"<<endl;; Student Student4; //创建第4个学生对象Student4 Student1.Print(); Student2.Print(); Student3.Print(); Student4.Print(); return 0; }
运行结果为：
1 2 3 4 5 6 7 8 9 10 11 12 13 Studentl count=1 ---------- Studentl count=2 Student2 count=2 ---------- Studentl count=3 Student2 count=3 Student3 count=3 ---------- Studentl count=4 Student2 count=4 Student3 count=4 Student4 count=4
静态成员函数 在类定义中，声明为static的成员函数能在类的范围内共享，把这样的成员函数称为静态成员函数。
定义静态成员函数的格式为static返回类型 静态成员函数名（参数表）；类名：：静态成员函数名（实参表）对象．静态成员函数名（实参表）
关于静态成员函数的使用有以下几点说明：
静态成员函数可以定义成内嵌的，也可以在类外定义，在类外定义时，不用static前缀。
一般情况下，静态函数成员主要用来访问全局变量或同一个类中的静态数据成员。特别是，当它与静态数据成员一起使用时，达到了对同一个类中对象之间共享数据进行维护的目的。
私有静态成员函数不能被类外部函数和对象访问。
使用静态成员函数的一个原因是，可以用它在建立任何对象之前处理静态数据成员，这是普通成员函数不能实现的功能。
编译系统将静态成员函数限定为内部连接，也就是说，与现行文件相连接的其他文件中的同名函数不会与该函数发生冲突，维护了该函数使用的安全性，这是使用静态成员函数的另一个原因。
在一般的成员函数中都隐含有一个this指针，用来指向对象自身，而在静态成员函数中是没有this指针的。
一般而言，静态成员函数不访问类中的非静态成员。若确实需要，静态成员函数只能通过对象名（或指向对象的指针）访问该对象的非静态成员。
友元 类的一个很重要的特点就是实现了数据隐藏和封装。在类定义的时候，一般都将数据成员声明为私有成员（或保护成员），只能在类定义的范围内使用，也就是说私有成员（或保护成员）只能通过它的成员函数来访问。
但是，调用公有函数接口是需要时间开销的，且有时候需要在类的外部访问类的私有成员（或保护成员）。
在C++语言中，通过定义友元 （friend member）来实现这一功能。类的友元包括友元函数 和友元类 。
友元函数 友元函数有2种形式：
一个不属于任何类的普通函数声明为当前类的友元，称为当前类的友元函数。
一个其他类的成员函数声明为当前类的友元，称为当前类的友元成员。
友元函数是在类中说明的由关键字friend修饰的非成员函数。
友元函数的使用：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 #include<iostream.h> #include<cmath> class Point { int x, y; public: Point(int a=0, int b=0) { x=a; y=b; } ~Point() { } void Show() { cout<<”x=”<<x<<” y=”<<y<<endl; } int Get_x() { return x; } int Get_y() { return y; } friend double Distance(Point &p1, Point &p2); //友元函数声明 }; double Distance(Point &p1, Point &p2) //友元函数定义 { return sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y)); } int main() { Point p1, p2(1,1); cout<<Distance(p1,p2)<<endl; return 0; }
友元函数的说明：
友元函数不是类的成员函数。因此，对友元函数指定访问权限无效，可以把友元函数的说明放在private、public、protected的任意段中。在类的外部定义友元函数时，不必像成员函数那样，在函数名前加上类名::。
使用友元函数的目的是提高程序的运行效率。
慎用友元函数，因为它可在类外直接访问类的私有或保护成员，破坏了类的信息隐藏的特性。
友元成员 除了一般的函数可以作为某个类的友元外，一个类的成员函数也可以作为另一个类的友元。
将一个类的成员函数说明为另一个类的友元函数
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 #include<iostream> using namespace std; class N; //N类的前向说明，因为N的定义在M之后，而M中使用了N class M { int a, b; public: M(int x, int y) { a=x; b=y; } void Print() { cout<<”a=”<<a<<” b=”<<b<<endl; } void Setab(N &); }; class N { int c, d; public: N(int a, int b) { c=a; d=b; } void Print() { cout<<”c=”<<c<<” d=”<<d<<endl; } friend void M::Setab(N&); //将M类的成员函数说明为本类的友元函数 }; void M::Setab(N &obj) //M类的成员函数Setab()是类N的友元函数 { a=obj.c; //在Setab()中可以直接访问类N的私有成员 b=obj.d; } int main() { M m(25, 40); N n(55,66); cout<<”m: ”; m.Print(); cout<<”n: ”; n.Print(); m.Setab(n); cout<<”m: ”; m.Print(); return 0; }
运行结果为：
友元类 友元还可以是类，即一个类可以作为另一个类的友元。friend 类名；
将一个类说明为另一个类的友元类:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 #include<iostream> using namespace std; class B; // 前向说明，因为在后面定义的A类中用到B类 class A { int x; public: A(int a) { x=a; } friend class B; //将类B声明为类A的友元类 }; class B { public: void Show(A a) { cout<<”x=”<<a.x<<endl; } }; int main() { A a(10); B b; b.Show(a); return 0; }
运行结果为：
说明：
本例中，类B是类A的友元，因此，在类B的成员函数中可以访问类A的任何成员。
友元关系是单向的，不具有交换性，即类A中将类B声明为自己的友元类，但类B中没有将类A声明为友元类，所以类A的成员函数不可以访问类B的私有成员。
当两个类都将对方声明为自己的友元时，才可以实现互访。
友元关系也不具备传递性，即类A将类B声明为友元，类B将类C声明为友元，此时，类C不一定是类A的友元。
原文:大专栏 类和对象(二)
类和对象(二)
标签：写代码 nbsp 参数表 范围 c声明 成员变量 this指针 指针变量 ios
原文地址：https://www.cnblogs.com/petewell/p/11584743.html
