【无标题】
这里写目录标题
-
- 类和对象
-
- 对象的初始化
- 构造函数的必要性
- 带参数的构造函数
- 重载构造函数
- 析构函数
-
- 例题
- 静态成员
-
- 静态成员变量
- 创建对象，对象分配空间、初始化
- 静态成员函数
- 友元
-
- 1) 将非成员函数声明为友元函数。
- 2) 将其他类的成员函数声明为友元函数
- 友元类
构造函数创建类对象，初始化其成员；
析构函数撤销类对象
构造函数和析构函数是类的特殊成员函数
类和对象
对象的初始化
根据变量定义，全局变量和静态变量在定义（分配空间）时，将位模式清0；
局部变量在定义时，分配的内存空间内容保持原样，故为随
机数
C++建立和初始化对象的过程专门由该类的构造函数来完成。这个构造函数很特殊，只要对象建立，它马上被调用，给对象分配内存空间和初始化。
C++另有一种析构函数，它也是类的成员函数，当对象撤销时，就
会马上被调用，其作用是释放与对象捆绑的资源，做一些善后处理。
构造函数的必要性
类的封装性就体现在一部分数据是不能让外界访问的。
类对象的初始化任务自然就落在了类的成员函数身上，因为它们可
以访问保护和私有数据成员
类只有一个名字，但可以有多个对象名，每个对象创建时，都要调用该类的构造函数。类的唯一性和对象的多样性，使我们马上想到用类名而不是对象名来作为构造函数名是比较合适的
C++规定与类同名的成员函数是构造函数，在该类的对象创建时，
自动被调用。
与成员函数相同，构造函数可以放在类的外部定义
构造函数另一个特殊之处是它没有返回类型，函数体中也不允许返回值，但可以有无值返回语句“return；”。因为构造函数专门用于创建对象并为其初始化，所以它不能随意被调用。没有返回类型，正显得它与众不同。
定义对象数组的语句会调用多次构造函数
类在工作过程中分工十分明确，每个类只负责初始化它自己的对象。当TutorPair类要初始化成员Student类对象的时
候，马上调用Student构造函数，而不是由自己去包办，正所谓“你做你
的事，我做我的事”
带参数的构造函数
重载构造函数
class student
{
string name;
double score;
public:
student(string n, double s)：name(n),score(s)//用列表初始化
{
cout << "构造函数\n";
}
}
/*等价于*/
class student
{
string name;
double score;
public:
student(string n, double s)：
{
name = n;
score = s;
cout << "构造函数\n";
}
}
struct student{
string name;
double score;
student(string n, double s)：name(n),score(s){
}
};
析构函数
#include 例题
静态成员
静态成员变量
有时候我们希望在多个对象之间共享数据，对象 a 改变了某份数据后对象 b 可以检测到。共享数据的典型使用场景是计数，以前面的 Student 类为例，如果我们想知道班级中共有多少名学生，就可以设置一份共享的变量，每次创建对象时让该变量加 1。
在C++中，我们可以使用静态成员变量来实现多个对象共享数据的目标。静态成员变量是一种特殊的成员变量，它被关键字static修饰，例如：
class Student{
public:
Student(char *name, int age, float score);
void show();
public:
static int m_total; //静态成员变量
private:
char *m_name;
int m_age;
float m_score;
};
static 成员变量必须在类声明的外部初始化，具体形式为：static 成员变量必须在类声明的外部初始化，具体形式为：
int Student::m_total = 0;
**静态成员变量在初始化时不能再加 static，但必须要有数据类型。**被 private、protected、public 修饰的静态成员变量都可以用这种方式初始化。
注意：static 成员变量的内存既不是在声明类时分配，也不是在创建对象时分配，而是在（类外）初始化时分配。反过来说，没有在类外初始化的 static 成员变量不能使用。
static 成员变量既可以通过对象来访问，也可以通过类来访问。请看下面的例子：
//通过类类访问 static 成员变量
Student::m_total = 10;
//通过对象来访问 static 成员变量
Student stu("小明", 15, 92.5f);
stu.m_total = 20;
//通过对象指针来访问 static 成员变量
Student *pstu = new Student("李华", 16, 96);
pstu -> m_total = 20;
#include 创建对象，对象分配空间、初始化
Student *pstu = new Student("李华", 16, 96);//有参的构造函数
一个在队，一个在栈？
静态成员函数
编译器在编译一个普通成员函数时，会隐式地增加一个形参 this，并把当前对象的地址赋值给 this，所以普通成员函数只能在创建对象后通过对象来调用，因为它需要当前对象的地址。而静态成员函数可以通过类来直接调用，编译器不会为它增加形参 this，它不需要当前对象的地址，所以不管有没有创建对象，都可以调用静态成员函数。
普通成员变量占用对象的内存，静态成员函数没有 this 指针，不知道指向哪个对象，无法访问对象的成员变量，也就是说静态成员函数不能访问普通成员变量，只能访问静态成员变量。
普通成员函数必须通过对象才能调用，而静态成员函数没有 this 指针，无法在函数体内部访问某个对象，所以不能调用普通成员函数，只能调用静态成员函数。
静态成员函数与普通成员函数的根本区别在于：普通成员函数有 this 指针，可以访问类中的任意成员；而静态成员函数没有 this 指针，只能访问静态成员（包括静态成员变量和静态成员函数）
#include 在C++中，静态成员函数的主要目的是访问静态成员。getTotal()、getPoints() 当然也可以声明为普通成员函数，但是它们都只对静态成员进行操作，加上 static 语义更加明确。
和静态成员变量类似，静态成员函数在声明时要加 static，在定义时不能加 static（函数的定义 对应 静态变量的初始化）。静态成员函数可以通过类来调用（一般都是这样做），也可以通过对象来调用，上例仅仅演示了如何通过类来调用。
友元
借助友元（friend），可以使得其他类中的成员函数以及全局范围内的函数访问当前类的 private 成员。
1) 将非成员函数声明为友元函数。
//成员函数
public:
friend void show(Student *pstu); //将show()声明为友元函数
//非成员函数
void show(Student *pstu){
cout<<pstu->m_name<<"的年龄是 "<<pstu->m_age<<"，成绩是 "<<pstu->m_score<<endl;
}
Student stu("小明", 15, 90.6);
show(&stu); //调用友元函数
注意，友元函数不同于类的成员函数，在友元函数中不能直接访问类的成员，必须要借助对象。下面的写法是错误的：
void show(){
cout<<m_name<<"的年龄是 "<<m_age<<"，成绩是 "<<m_score<<endl;
}
完整代码
#include show() 是一个全局范围内的非成员函数，它不属于任何类，它的作用是输出学生的信息。m_name、m_age、m_score 是 Student 类的 private 成员，原则上不能通过对象访问，但在 show() 函数中又必须使用这些 private 成员，所以将 show() 声明为 Student 类的友元函数。读者可以亲自测试一下，将上面程序中的第 8 行删去，观察编译器的报错信息。
2) 将其他类的成员函数声明为友元函数
friend 函数不仅可以是全局函数（非成员函数），还可以是另外一个类的成员函数
//student类
public:
void show(Address *addr);
//类外
void Student::show(Address *addr){
cout<<m_name<<"的年龄是 "<<m_age<<"，成绩是 "<<m_score<<endl;
cout<<"家庭住址："<<addr->m_province<<"省"<<addr->m_city<<"市"<<addr->m_district<<"区"<<endl;
}
//Address类
public:
//将Student类中的成员函数show()声明为友元函数
friend void Student::show(Address *addr);
一个函数可以被多个类声明为友元函数，这样就可以访问多个类中的 private 成员。
#include 友元类
public:
//将Student类声明为Address类的友元类
friend class Student;
不仅可以将一个函数声明为一个类的“朋友”，还可以将整个类声明为另一个类的“朋友”，这就是友元类。友元类中的所有成员函数都是另外一个类的友元函数。
例如将类 B 声明为类 A 的友元类，那么类 B 中的所有成员函数都是类 A 的友元函数，可以访问类 A 的所有成员，包括 public、protected、private 属性的。
更改上例的代码，将 Student 类声明为 Address 类的友元类：
#include 关于友元，有两点需要说明：
-
友元的关系是单向的而不是双向的。如果声明了类 B 是类 A 的友元类，不等于类 A 是类 B 的友元类，类 A 中的成员函数不能访问类 B 中的 private 成员。
-
友元的关系不能传递。如果类 B 是类 A 的友元类，类 C 是类 B 的友元类，不等于类 C 是类 A 的友元类。
-
除非有必要，一般不建议把整个类声明为友元类，而只将某些成员函数声明为友元函数，这样更安全一些。
摘自here