嵌入式系统开发小白学习笔记（25）

C++基础

构造函数

（一）特点

（1）函数名和类名相同
（2）无返回值，返回值就是构造函数本身
例：complex（）{}

构造函数允许重载
1、每一个类都有自带的默认构造函数
2、一旦自己定义了构造函数，会将原本的默认函数覆盖
3、复制构造函数不能是对象本身
4、 complex s4 = s1；（s1未复制函数）
5、当类没有复制函数时，=就相当于是引用
6、类的对象作为参数传入时，会调用复制构造函数，产生新的对象
7、stactic可以延长变量的生命周期，直至程序运行结束才被销毁

this指针，谁调用了自己的函数，this指针就会指向谁。

（二）匿名对象（独属于C++）

（1）生命周期只存在于创建的那一行

析构函数

（1）名字和类相同
（2）无返回值
（3）无形参

friend关键字：友元函数

（1）函数定义在类外，通过友元函数的定义，可以调用类的元素
（2）会破坏类的封装性

关键字：new和delete

（1）malloc在堆上申请对象空间，不会调用构造函数；new会自动调用构造函数和析构函数
（2）
（3）new构造数组时，内存是动态分配的；malloc函数构造数组是需要用sizeof*字节大小。

初始化表（可以初始化变量或者常量）

（1）若想对const修饰的成员变量，只能在初始化表中进行初始化。

void show(complex &s1)：s1的值不可被修改
const int show(complex &s1)：返回值不可被修改
int show(complex &s1)const（常成员函数）：该函数不可修改任何成员变量
const *：常量指针，指针所指的量的值不可被更改
*const：指针常量，指针的地址不可被更改

（2）static（C++）
1、静态成员不归对象管
2、修饰成员变量，变量只能在类外初始化，被所有对象共享
3、修饰成员函数，只能操作静态成员变量。

继承

（一）继承种类

（1）public公有继承：子类继承可使用
（2）基类类型是private，继承之后也无法使用，只在private本类中可用。
若子类private继承基类，那么子类的子类也无法继承子类。
（3）protect保护继承，子类继承可使用
（4）名字遮蔽原则：如果派生类的函数和基类函数同名，则优先使用派生类自己的函数，而不是用基类中的函数。

（二）继承构造函数

（1）派生类中允许调用基类的构造函数，但仅限于在初始化表中调用。

#include <iostream>

using namespace std;

class People
{
    public:
         void setname(const char * name);
         void setage(int age);
         const char * getname();
         int getage();
         void diaplay()
         {
             cout<<getname()<<"age is "<<getage()<<endl;
         }

    private:
         int m_age;
         const char *m_name;



};

void People::setname(const char * name){m_name = name;}
void People::setage(int age){m_age = age;}
const char * People::getname(){return m_name;}
int People::getage(){return m_age;}

class Student:public People
{
    public:
        void setscore(float score);
        float getscore();
    private:
        float m_score;

};
void Student::setscore(float score){m_score = score;}
float Student::getscore(){return m_score;}

class midStu:public Student
{
    public:
        void setrank(int rank);
        void display();
    private:
        int m_rank;

};
void midStu::setrank(int rank){m_rank = rank;}
void midStu::display()
{
    cout<<getname()<<" age = "<<getage()<<" ,the score is "<<getscore()<<",his rank is "<<m_rank<<endl;//名字遮蔽原则
}

int main()
{
    midStu stu1;
    stu1.setname("xiaoming");
    stu1.setage(13);
    stu1.setscore(98.5f);
    stu1.setrank(1);
    stu1.display();
    
    People peo;
    peo.setname("xiaogang");
    peo.setage(14);
    peo.diaplay();


    return 0;
}

（三）继承构造函数

（1）继承函数的调用顺序和内部函数函数顺序无关，只和继承函数顺序有关。

#include <iostream>
 using namespace std;

class BaceA
{
    public: 
    BaceA(int a,int b);
    ~BaceA();
    void show()
    {
        cout<<m_a<<" "<<m_b<<endl;
    }
    protected:
    int m_a;
    int m_b;

};

BaceA::BaceA(int a,int b):m_a(a),m_b(b)
{
    cout<<"A constructor!"<<endl;
}
BaceA::~BaceA()
{
    cout<<"A discontrcutor!"<<endl;
}
class BaceB
{
    public:
    BaceB(int c,int d);
    ~BaceB();
    void show()
    {
        cout<<m_c<<" "<<m_d<<endl;
    }
    protected:
    int m_c;
    int m_d;
};
BaceB::BaceB(int c,int d):m_c(c),m_d(d)
{
    cout<<"B constructor!"<<endl;
}
BaceB::~BaceB()
{
    cout<<"B disconstrutor!"<<endl;
}
class C:public BaceA,public BaceB
{
    public:
    C(int a,int b,int c,int d,int e);
    ~C();
    void show()
    {
        BaceA::show();
        BaceB::show();
        cout<<m_a<<","<<m_b<<","<<m_c<<","<<m_d<<","<<m_e<<endl;
    }
    private:
    int m_e;


};
C::C(int a,int b,int c,int d,int e):BaceA(a,b),BaceB(c,d),m_e(e)
{
    cout<<"C constructor!"<<endl;
}
C::~C()
{
    cout<<"C discontructor !"<<endl;
}
 int main()
 {
     C obj(1,2,3,4,5);
     obj.show();
     return 0;
 }

（2）命名冲突：

class D:public B,public C
{
    public:
    void seta(int a){m_a = a;}//命名冲突，分不清是B还是C的a
    private:
    int m_d;

};

解决办法

1、加上域解析符：C：：m_a = a（不推荐该方法）
2、

（四）多态

（1）定义：一个接口，多种方法（代码的复用性）->一行代码，实现不同的功能。
（2）重写：子类的同名函数会将父类的同名函数遮蔽，称之为重写。
（3）虚函数：virtual
虚函数指针和虚函数表。
派生类中所有的的同名函数，自动变成虚函数。
（4）纯虚函数：virtual = 0；
1、没有函数体
2、纯粹的函数声明
3、包含纯虚函数的类成为抽象类：无法实例化的类（没有办法创建对象）
4、一般作为基类存在，所以又称模板类。
5、一个类若想要实例化，就要将继承的所有的纯虚函数全部重写。

#include <iostream>

using namespace std;

class  people
{
    public:
    people(const char *name,int age);
    virtual void display();
    protected:
    int m_age;
    const char *m_name;
};

people::people(const char *name,int age):m_name(name),m_age(age)
{

}
void people::display()
{
    cout<<m_name<<" age is "<<m_age<<endl;
}

class teacher:public people
{
    public:
    teacher(const char *name,int age,int salary):people(name,age),m_salary(salary){}
    void display(){cout<<m_name<<" age is "<<m_age<<",his salary is "<<m_salary<<endl;}
    private:
    int m_salary;
   
    
};
int main()
{
    people *p = new people("xiaoming",23);
    p->display();

    p = new teacher("xioagang",45,8000);
    p->display();

    return 0;
}

补充

（1）虚继承定义：派生类中只留下一份间接基类的成员
（2）向上转型