C++知识框架梳理

封装，继承，多态被称为面向对象的三大法宝。

一：封装

1.类：

a.如何创建自己的类

形式如下：

class student //类名：student
{
string name;//类里面两个内容，年龄名字，叫做类的成员数据，也叫作属性
int age;
}

早期的类是从结构体发展过来的，形式和C语言中的结构体几乎长的一样

b.公有，私有的初步概念

在定义类的时候，形式如下：

class student
{
public :
        string name;
private:
        int age;
}

在上面的类定义中，属性name为公有的：类的外部（主函数中或者其他的类）是可以读写name的值的；但是age是私有的，在类的外面是看不到的，是不可以读写的。

我们在定义类的时候，可以先不写private，没有private的类相当于结构体。

c.为什么要设置一个private，来使age变成私有呢？

答：是为了体现封装性，在进行大型项目的编写时，可以防止别人乱改数据。

高手回答：对类的外部隐藏了类内部的工作机制，即所谓的封装性

新手回答：public中的内容，可以在主函数中看到，private中的内容只可以在类的内部中看到

下面来举一个例子：

class student :
{
public:
        void print_name();
private:
        void print_age();
}
void studnet ::print_name()
{
cout<<"张三";
}
void student ::print_age()
{
cout<<20;
}
//以下是主函数
student aa;
aa.print_name();//调用共有方法，可以
aa.print_age();//调用私有发放，不可以，这行会报错，提示student类不存在print_age()这个方法

d.怎么使用private中的属性和方法：

答：private可以用，但是有一定的条件：

核心思想：就是通过共有方法的外壳去调用私有方法

下面是一个例子：

class student:
{
public:
    void print_age_public();
private:
    void print_age_privare();
}
void student::print_age_public()
{print_age_private();}
void student::print_age_private()
{cout<<20;}
student aa;
aa.print_age_public()://这里通过公有函数外壳，调用了私有然后打印出来年龄20
aa.print_age_private();//这里出错，是不可以直接调用私有函数的

e.如何去使用一个类：

答：类被定义以后，就可以去创建类的对象，形式和int a 一样

student aa;//就创建了一个student类的对象，名字叫做aa
//也可以对aa的属性进行赋值，和结构体一样
aa.name="张三";

2.什么是成员函数？

答：成员函数就是类中定义的函数，也被称为方法。具体内容写在类的外面，就是成员函数的定义写在类的外面，然后成员函数要在类定义中进行声明。

a.成员函数的重载：

答：和C语言中普通函数一样，成员函数也可以重载。不同函数可以有相同的函数名，但是不可以有相同的输入参数类型，因为是通过不同的输入参数来进行识别这个函数执行哪一个功能。

一个面向对象的代码最少有三部分：

答：类的定义；成员函数的定义；创建对象然后调用方法；

3.构造函数：

a.为什么要有构造函数？

答：构造函数的本质就是对类的属性进行初始化，及对象初始化。使用构造函数以后，就不用再一个一个的对成员数据进行一一赋值了，就可以通过构造函数来直接进行初始赋值。构造函数的名字必须和类的名字相同。

下面是一个构造函数的例子：

class student
{
public :
        int age;
        string name;
        student();//这是一个构造函数，（的声明），他没有输入值和返回值，并且名字和类的名字是一样的
}
student::studnet()
{
age=20;
name="张三";
}
//主函数
student aa;//创建一个student类的对象，这里将自动调用构造函数给年龄和名字赋默认值

我们也可以构造带参数的构造函数，这样就可以为属性赋其他的值

例：

student ::student(int a,string b)
{
    age=a;
    name=b;
}
student bb(25,"李四");

4.析构函数：

a.什么是析构函数：

答：析构函数是用来销毁内存数据的；比如说对象aa被创建后，他的数据就一直在内存中，这块内存什么时候被释放，就是使用析构函数的时候；

但是主函数中并不能直接运行student aa; delete aa; 只有以这样的形式来写，才可以运行析构函数：student *P= new student (20,"张三"）； delete p;

为什么会出现上述情况呢？

答：C++将内存分为了五个区域，通过 student aa 和student *p=new student 创建的对象是放在不同的区域里面的，所以原理是不同的。

b.怎么写析构函数：

答：写法和构造函数类似

student ::~student ()
{
cout<<"delete object";
}

5.常成员函数 const

a.什么是常成员函数：

答：一个方法只读取属性，而不修改属性，就是常成员函数。

class student
{
public :
int age;
string name;
bool set(int);
bool read() const;//后面加了const 说明这个函数只读不写
}
bool student::read() const//常成员函数内容，后面加了const,说明他只读不写
{
cout << name;
cout<<age;
}
student aa;
aa.read();//在创建aa对象后，调用read（） 函数，打印出aa中属性的内容

实际上也可以不适用const，普通方法也可以读数据，加上const 只是安全起见，防止意外的修改数据。更加不正规的做法是直接读取aa.age;在正规的程序中，还是会用const 来进行读取。

6.静态成员 static

a.什么是静态成员(数据)，静态成员函数：

答：一个类可以创建多个对象，需要一个变量cnt 来表示程序中已经创建了几个这样的对象，cnt这个数，与student 类有关，但是又不属于aa,bb等属于student的对象。这种描述全局，又与某个对象属性无关的，叫做静态成员数据。读取静态成员数据的方法，叫做静态成员函数。

class student
{
public :
    int age;
    string name;
    student ();
    static int cnt;
    static int count():
}
//定义静态成员：
student::student()
{
age =20;
name="张三"；
cnt=cnt+1;//每次调用构造函数创建对象的时候，cnt加1，这样就可以统计出有多少个对象了。
}
int student ::count//静态成员函数的定义，注意这里不写static了
{
return cnt;  //返回静态成员数据，统计有多少个对象。
}

7.正规程序定义类的写法：

下面来写一个正规程序定义类的写法：

//正规写法：
class student
{
public:
    bool set(int a);
    bool set(string a);
    bool read() const;
    student():
    student(int a,string b);
private:
    int age;
    string name;
}

我们一般是把“方法”全部放在public中，属性都放在private中。目的是防止类外部随便篡改数据，通过函数来进行修改数据的时候，一般都具有防错机制，满足了条件以后才可以让你去修改。