面向对象复习提纲（一 类的基本知识）

参考网址：https://blog.csdn.net/zqixiao_09/article/details/51474556
参考网址：http://c.biancheng.net/cpp/biancheng/cpp/rumen/

1.类 class

类只是一个模板（Template），编译后不占用内存空间，所以在定义类时不能对成员变量进行初始化，因为没有地方存储数据。只有在创建对象以后才会给成员变量分配内存，这个时候就可以赋值了。

举个栗子

class Student
{
public:
	Student();
	~Student();
private:
	string name='\0';//错误不能初始化
	int score;	
};

当成员函数定义在类外时，就必须在函数名前面加上类名予以限定。::被称为域解析符（也称作用域运算符或作用域限定符），用来连接类名和函数名，指明当前函数属于哪个类。
成员函数必须先在类体中作原型声明，然后在类外定义，也就是说类体的位置应在函数定义之前。

2.构造函数

1.构造函数主要：用来初始化和内存分配
2.构造函数的调用是强制性的，一旦在类中定义了构造函数，那么创建对象时就一定要调用，不调用是错误的。如果有多个重载的构造函数，那么创建对象时提供的实参必须和其中的一个构造函数匹配；反过来说，创建对象时只有一个构造函数会被调用。

3.构造函数的一项重要功能是对成员变量进行初始化，为了达到这个目的，可以在构造函数的函数体中对成员变量一一赋值，还可以采用参数初始化表。

//采用参数初始化表
Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ //TODO:}

注意，参数初始化顺序与初始化表列出的变量的顺序无关，它只与成员变量在类中声明的顺序有关。

举个栗子

#include 
using namespace std;

class Demo{
private:
    int m_a;
    int m_b;
public:
    Demo(int b);
    void show();
};

Demo::Demo(int b): m_b(b), m_a(m_b){ }//-----------重点看这里顺序------//
void Demo::show(){ cout<<m_a<<", "<<m_b<<endl; }

int main(){
    Demo obj(100);
    obj.show();
    return 0;
}

3.析构函数

new 创建的对象位于堆区，通过 delete 删除时才会调用析构函数；如果没有 delete，析构函数就不会被执行。（先构造着后析构）

举个栗子

#include 
#include 
using namespace std;

class Demo{
public:
    Demo(string s);
    ~Demo();
private:
    string m_s;
};
Demo::Demo(string s): m_s(s){ }
Demo::~Demo(){ cout<<m_s<<endl; }

void func(){
    //局部对象
    Demo obj1("1");
}

//全局对象
Demo obj2("2");

int main(){
    //局部对象
    Demo obj3("3");
    //new创建的对象
    Demo *pobj4 = new Demo("4");
    func();
    cout<<"main"<<endl;
    return 0;
}

这个问题是考试重点一定要了解变量的分配时期和表示的范围
变化一下把25行的func()移动到24行或者26行后面，聪明的你能知道运行结果吗？不知道耶没有关系的哦，你可以试着运行一下哦，记住一个

秘诀就是先构造着后析构，加上变量生存期。

你就可以掌握了。

4.静态成员 static

聪明的你知道什么时候用静态成员吗？当这个类的所有公用一个变量或者函数最好用静态成员，只花销一个空间。看到这是不是还是很模糊，那么给你举个最简单的例子，要统计计科182班的总成绩或者总人数，不管哪个变量访问总成绩的时候都是一样的。

和静态成员变量类似，静态成员函数在声明时要加 static，在定义时不能加 static static函数是全域函数(global
functions)，但是像一个指定class的对象成员一样被调用。它们只能够引用static
数据，永远不能引用class的非静态成员。它们也不能够使用关键字this，因为this实际引用了一个对象指针，但这些
static函数却不是任何object的成员，而是class的直接成员。

举个栗子

#include 
using namespace std;

class Student{
public:
    Student(char *name, int age, float score);
    void show();
public:  //声明静态成员函数
    static int getTotal();
    static float getPoints();
private:
    static int m_total;  //总人数
    static float m_points;  //总成绩
private:
    char *m_name;
    int m_age;
    float m_score;
};

int Student::m_total = 0;
float Student::m_points = 0.0;

Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){
    m_total++;
    m_points += score;
}
void Student::show(){
    cout<<m_name<<"的年龄是"<<m_age<<"，成绩是"<<m_score<<endl;
}
//定义静态成员函数
int Student::getTotal(){
    return m_total;
}
float Student::getPoints(){
    return m_points;
}

int main(){
    (new Student("小明", 15, 90.6)) -> show();
    (new Student("李磊", 16, 80.5)) -> show();
    (new Student("张华", 16, 99.0)) -> show();
    (new Student("王康", 14, 60.8)) -> show();

    int total = Student::getTotal();
    float points = Student::getPoints();
    cout<<"当前共有"<<total<<"名学生，总成绩是"<<points<<"，平均分是"<<points/total<<endl;

    return 0;
}

一个class的静态数据成员也被称作类变量"class variables"，因为它们的内容不依赖于某个对象，对同一个class的所有object具有相同的值。

例如，它可以被用作计算一个class声明的objects的个数

举个栗子

#include 
using namespace std;

class CDummy
{
public:
	static int n;
	CDummy () { n++; };
	~CDummy () { n--; };
};
int CDummy::n = 0;

int main ()
{
	CDummy a;
	CDummy b[5];
	CDummy * c = new CDummy;
	cout << a.n << endl;
	delete c;
	cout << CDummy::n << endl;
	return 0;
}

//上面代码11行
int CDummy::n = 0;

初始化的时候才分配空间。

注意：static 成员变量的内存既不是在声明类时分配，也不是在创建对象时分配，而是在（类外）初始化时分配。反过来说，没有在类外初始化的
static 成员变量不能使用。
静态成员函数与普通成员函数的根本区别在于：普通成员函数有 this
指针，可以访问类中的任意成员；而静态成员函数没有 this 指针，只能访问静态成员（包括静态成员变量和静态成员函数）。

5.const成员变量

const 成员变量的用法和普通 const 变量的用法相似，只需要在声明时加上 const 关键字。初始化 const 成员变量只有一种方法，就是通过参数初始化表

举个栗子

#include
using namespace std;
int main()
{
	//初始化列表必须放在构造函数的后面 
	char a[]="hello",b[]="world";
	char *p=a;
	cout<<p[2]<<endl;
	const char *p1=a;//数据不能改 
	p1=b;//可以修改指针
	//p1[2]='w';不可行，不行修改指针指向的数据
	cout<<p1[2]<<endl; 
	char *const p2=a;//指针不能移动
	p2[2]='s';
	//p2=b; 不可行
	cout<<p2[2]<<endl; 
	const char *const p3=a;
	//p3[2]='1';不可行 
	//p3=b;不可行 
	
}

const
离变量名近就是用来修饰指针变量的，离变量名远就是用来修饰指针指向的数据，如果近的和远的都有，那么就同时修饰指针变量以及它指向的数据。

一旦将对象定义为常对象之后，不管是哪种形式，该对象就只能访问被 const 修饰的成员了（包括 const 成员变量和 const 成员函数），因为非 const 成员可能会修改对象的数据（编译器也会这样假设），C++禁止这样做。

举个栗子

#include 
using namespace std;

class Student{
public:
    Student(char *name, int age, float score);
public:
    void show();
    char *getname() const;
    int getage() const;
    float getscore() const;
private:
    char *m_name;
    int m_age;
    float m_score;
};

Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }
void Student::show(){
    cout<<m_name<<"的年龄是"<<m_age<<"，成绩是"<<m_score<<endl;
}
char * Student::getname() const{
    return m_name;
}
int Student::getage() const{
    return m_age;
}
float Student::getscore() const{
    return m_score;
}

int main(){
    const Student stu("小明", 15, 90.6);
    stu.show();  //error
    cout<<stu.getname()<<"的年龄是"<<stu.getage()<<"，成绩是"<<stu.getscore()<<endl;

    const Student *pstu = new Student("李磊", 16, 80.5);
    //pstu -> show();  //error
    cout<<pstu->getname()<<"的年龄是"<<pstu->getage()<<"，成绩是"<<pstu->getscore()<<endl;

    return 0;
}

6.友元函数friend

举个栗子

#include 
using namespace std;

class Student{
public:
    Student(char *name, int age, float score);
public:
    friend void show(Student *pstu);  //将show()声明为友元函数
private:
    char *m_name;
    int m_age;
    float m_score;
};

Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }

//非成员函数
void show(Student *pstu){
    cout<<pstu->m_name<<"的年龄是 "<<pstu->m_age<<"，成绩是 "<<pstu->m_score<<endl;
}

int main(){
    Student stu("小明", 15, 90.6);
    show(&stu);  //调用友元函数
    Student *pstu = new Student("李磊", 16, 80.5);
    show(pstu);  //调用友元函数

    return 0;
}

举个栗子

#include 
using namespace std;

class Address;  //提前声明Address类

//声明Student类
class Student{
public:
    Student(char *name, int age, float score);
public:
    void show(Address *addr);
private:
    char *m_name;
    int m_age;
    float m_score;
};

//声明Address类
class Address{
private:
    char *m_province;  //省份
    char *m_city;  //城市
    char *m_district;  //区（市区）
public:
    Address(char *province, char *city, char *district);
    //将Student类中的成员函数show()声明为友元函数
    friend void Student::show(Address *addr);
};

//实现Student类
Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }
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类
Address::Address(char *province, char *city, char *district){
    m_province = province;
    m_city = city;
    m_district = district;
}

int main(){
    Student stu("小明", 16, 95.5f);
    Address addr("陕西", "西安", "雁塔");
    stu.show(&addr);
   
    Student *pstu = new Student("李磊", 16, 80.5);
    Address *paddr = new Address("河北", "衡水", "桃城");
    pstu -> show(paddr);

    return 0;
}

友元类
不仅可以将一个函数声明为一个类的“朋友”，还可以将整个类声明为另一个类的“朋友”，这就是友元类。友元类中的所有成员函数都是另外一个类的友元函数。
例如将类 B 声明为类 A 的友元类，那么类 B 中的所有成员函数都是类 A 的友元函数，可以访问类 A 的所有成员，包括
public、protected、private 属性的。

下一篇博客链接：https://blog.csdn.net/weixin_43732535/article/details/106623681