C++的基础知识（引用、类、封装、继承、多态、函数重载）

C++的基础知识

1、前言
2、引用
- [2.1 引用的概念](#2.1 引用的概念)
- [2.2 引用与指针的区别](#2.2 引用与指针的区别)
3、封装
4、C++的类
- [4.1 什么是类和对象](#4.1 什么是类和对象)
- [4.2 类的访问限制](#4.2 类的访问限制)
- [4.3 类的继承](#4.3 类的继承)
- - [4.3.1 public继承](#4.3.1 public继承)
  - [4.3.2 protected继承](#4.3.2 protected继承)
  - [4.3.3 private继承](#4.3.3 private继承)
5、多态
- [5.1 多态的实现](#5.1 多态的实现)
6、函数重载
7、总结

1、前言

|----------------------------------------|
| 记录一下C++的一些基础知识，方便自己日后回顾，也可以给有需要的人提供帮助。 |

2、引用

2.1 引用的概念

|------------------------|
| 引用就是给变量起别名，引用必须在声明时初始化 |

cpp 复制代码

int main()
{
    int a = 1;
    int &b = a;     //b是a的别名，引用声明的时候必须初始化
    cout << b << endl;
    cout << a << endl;
    return 0;
}

2.2 引用与指针的区别

|--------------------------------------------------------------------------------|
| 1. 引用无空值（不能为NULL），指针可以； 2. 引用初始化后不可更改，指针可重新指向； 3. 支持多级指针，不支持多级引用； 4. 无需解引用操作符。 |

3、封装

|----------------------------------------------------------------------|
| 封装就是将数据（成员变量）和操作数据的方法（成员函数）绑定在一起，并隐藏（private）内部实现细节，重新提供外部访问接口进行访问。 |

cpp 复制代码

#include <iostream>

using namespace std;

//定义一个银行类
class BankAccount{

//封装封装敏感数据
private:
    string owner;       //账户
    double balance = 0.0;     //余额

// 暴露安全操作接口
public:
    // 添加构造函数，初始化 balance 为 0.0
    BankAccount() : balance(0.0) {}

    //设置账户名
    void setOwner(const string& o){
        owner = o;
        cout << "重置用户名成功，当前用户名为：" << o << endl;

    }

    //取款
    void deposit(double amount){
        balance += amount;
        cout << "存款成功，当前余额为：" << balance << endl;

    }

};
int main()
{
    BankAccount ba;
    ba.setOwner("叶子");
    ba.deposit(10.21);
    return 0;
}

4、C++的类

4.1 什么是类和对象

|---------------------------------------------------------------------------------------|
| 类是创造对象的模板，对象是类的定义出来的变量；类的成员不但可以是变量，还可以是函数；一个类可以创建多个对象，每个对象都是类类型的一个变量；创建对象的过程叫类的实例化。 |

cpp 复制代码

//定义一个狗类
class Dog{
public:
    string name;
    int age;
    
    //函数
    void run(){
        cout << "小狗会跑" << endl;
    };
protected:
    double weight;
private:
    string color;
};
int main()
{
    //在栈上创建对象
    Dog dog1;
    //在堆上创建对象
    Dog *dog2 = new Dog();
    return 0;
}

4.2 类的访问限制

访问权限	特点
public	成员无访问限制
protected	成员在派生类中可访问
private	成员只能在类内部访问

cpp 复制代码

//定义一个狗类
class Dog{
public:
    string name;
    int age;
    
    //函数
    void run(){
        cout << "小狗会跑" << endl;
    };
    
    //公有方法可以访问保护和私有成员
    void setColor(const string &c){
        color=c;
    }
protected:
    double weight;
private:
    string color;
};

//狗类的派生类
class xiaohei:public Dog{
    void setWeight(){
        weight = 20;    //可以访问基类的 protected 成员
    }
    
    void setColor(){
        //color = "黑色";  //错误，基类的私有成员在派生类中不可访问
    };
};
int main()
{
    //在栈上创建对象
    Dog dog1;
    dog1.name = "小黑";       //公有成员可访问
    //dog1.weight = 20;        //错误，保护成员不能在类外直接访问
    //dog1.color = "黑色";      //错误，私有成员不能在类外直接访问
    //在堆上创建对象
    Dog *dog2 = new Dog();
    dog2->setColor("黑色");   //通过公有方法间接设置私有成员
    return 0;
}

4.3 类的继承

继承方式	基类public成员	基类protected成员	基类private成员	外部代码
public	在派生类中仍为 public	在派生类中为 protected	不可访问	只能访问派生类的 public 成员
protected	在派生类中变为 protected	在派生类中仍为 protected	不可访问	无法直接访问基类成员
private	在派生类中变为 private	在派生类中变为 protected	不可访问	无法直接访问基类成员

4.3.1 public继承

cpp 复制代码

//创建一个动物基类
class Animal{
public:
    int age;
    void setAge();
protected:
    double weight;
    void setWeight();
private:
    string color;
    void setcolor();
};

//创建一个狗类继承动物基类
class Dog : public Animal{
public:
    /*
    age = 10;
    错误，不能直接在类作用域内赋值操作
    */
    void setPropetry(){
        age = 10;          //允许访问基类 public 成员
        weight = 20;       //允许访问基类 protected 成员
        //color = "黑色";   //错误：基类 private 成员不可访问
        setAge();          //允许调用基类 public 方法
        setWeight();       // 允许调用基类 protected 方法
        //setcolor();       错误：基类 private 方法不可访问
    }
//外部代码无法调用
protected:
    void setPropetry2(){
        age = 100;
        weight = 200;
        //color = "白色";
    }
    
};

int main()
{
    Dog dog1;
    dog1.age;
    //dog1.weight;              //错误，基类的protected成员在派生类中为protected,外部代码无法访问
    //dog1.setPropetry2();        //错误，外部代码无法调用 protected 成员 
    return 0;

4.3.2 protected继承

cpp 复制代码

//protected继承
class Cat : protected Animal{
public:
    void setPropetry(){
        age = 2;                 //基类 public 成员变为 protected
        weight = 100;           //基类 protected 成员仍为 protected
        //color = ""白色";      //错误：基类 private 成员不可访问
        setAge();              //允许调用基类 public 方法（变为 protected）
        setWeight();           //允许调用基类 protected 方法
        //setcolor()；           //错误，基类 private 方法不可访问
    }
};

int main()
{
    //public派生类实例化
    Dog dog1;
    dog1.age;
    //dog1.weight;              //错误，基类的protected成员在派生类中为protected,外部代码无法访问
    //dog1.setPropetry2();        //错误，外部代码无法调用 protected 成员 
    
    //protected派生类实例化
    Cat cat;
    //cat.age;            //错误，基类 public 成员在派生类中变为 protected
    //cat.setAge();         //错误,基类 public 方法在派生类中变为 protected
    return 0;
}

4.3.3 private继承

cpp 复制代码

//private继承
class Duck : private Animal{
public:
    void setPropetry(){
        age = 3;                // 基类 public 成员变为 private
        weight = 30;           // 基类 protected 成员变为 private
        //color = "黄色";      // 错误：基类 private 成员不可访问
        setAge();              //允许调用基类 public 方法（变为 protected）        
    }
};

int main()
{
    //public派生类实例化
    Dog dog1;
    dog1.age;
    //dog1.weight;              //错误，基类的protected成员在派生类中为protected,外部代码无法访问
    //dog1.setPropetry2();        //错误，外部代码无法调用 protected 成员 
    
    //protected派生类实例化
    Cat cat;
    //cat.age;              //错误，基类 public 成员在派生类中变为 protected
    //cat.setAge();         //错误,基类 public 方法在派生类中变为 protected
    return 0;
    
    //private继承
    Duck duck;
    //duck.age;             // 错误：基类 public 成员在派生类中变为 private
    //duck.setAge();        // 错误：基类 public 方法在派生类中变为 private
}

5、多态

|-----------------------|
| 多态就是通过统一的接口操作不同类型的对象。 |

5.1 多态的实现

|----------------------------------------------------------------------------|
| 1. 基类定义虚函数（virtual 关键字） 2. 派生类重写虚函数（override 关键字） 3. 通过基类指针或引用调用虚函数，触发动态绑定 |

cpp 复制代码

#include <iostream>

using namespace std;

class Animal{
public:
    //创建虚函数
    virtual void speek(){
        cout << "Animal sound" << endl;
    };

     virtual ~Animal() {}  // 虚析构函数
};

class Dog : public Animal{
public:
    //重写虚函数
    void speek() override{
        cout << "wang" << endl;
    }
};
class Cat : public Animal {
public:
    //重写虚函数
    void speek() override{
        cout << "mi" << endl;
    }

};
int main()
{
    Animal *animal1 = new Dog();
    Animal *animal2 = new Cat();

    animal1->speek();       //调用wang
    animal2->speek();       //调用mi

    delete  animal1;
    delete  animal2;
    return 0;
}

6、函数重载

|---------------------------------------------|
| 函数重载就是函数名称相同，但这些函数的参数列表不同（参数类型、参数个数或参数顺序不同） |

cpp 复制代码

int add(int a, int b){
    return a+b;
}

int add(int a, int b, int c){
    return a+b+c;
}

double add(double a, double b){
    return a+b;
}

int main()
{
    cout << add(1,2) << endl;           //调用 int add(int, int)
    cout << add(2,3,4) << endl;         //调用 int add(int, int, int)
    cout << add(1.5, 1.3) << endl;       //调用 double add(double, double)
    return 0;
}

7、总结

|-----------------------------------------------------------------------------------------------|
| 以上就是C++的一些基础知识了，浏览过程中，如若发现错误，欢迎大家指正，有问题的欢迎评论区留言或者私信。最后，如果大家觉得有所帮助，可以点一下赞，谢谢大家！祝大家天天开心，顺遂无虞！ |