嵌入式学习——4——c++ 结构体+类

1、数据类型

基本数据类型：char、int 、float、 double、string、bool

构造数据类型：数组、指针、结构体、共用体、枚举、类

2、引用

引用就是 别名

数据类型 &引用名 = 同类型的变量名 （&引用符号）

 int a = 10;
 int &b = a;  // b引用a.  或者给a取个别名叫b

引用的目标一旦指定，就不可以改变

数组引用

 //定义一个数组
    int a[5] = {10,20,30,40,50};
 //数组指针
    int (*p)[5] = &a;
 //数组引用
    int (&b)[5] = a;

    b[2] = 900; //==   a[2] = 900

函数引用

int max(int x, int y)
{
    return  x>y ? x:y;
}


 //函数指针
    int (*p)(int, int) = max;
    cout << p(23, 78) << endl;


    //函数引用
    int (&fun)(int, int) = max;
    cout << fun(66, 99) << endl; // ==   max(66, 99)

当结构体中有引用成员时，如果用该结构体类型定义变量，就必须定义的同时初始化，否则报错

当函数返回一个引用变量时

1> 该变量的生命周期要长

2> 静态变量、 在堆区申请的变量

int &fun()  // int &num = num;
{
    static int num = 100; //要求返回的变量生命周期要长
    return num;
}

int main()
{

    int a = fun();  
    
    return 0;
}

总结： 指针与引用的区别

指针：存储地址的变量

引用：就是一个别名

1、初始化有区别，别名必须带值初始化，指针不一定

2、定义指针需要申请空间，引用不需要申请空间

3、指针指向可以改变，引用不可以改变

4、引用不是数据类型，没有引用数组以及二级引用，但是有指针数组和二级指针

3、const

const 修饰变量时，该变量不可以改变， 只读变量

const int *p; //指针指向里的值不可变，指向可变
int * const p; //指针指向里的值可变，指向不可变
int const * const p;//都不变

int a = 10;
const int b = 20;
int *pa = &a; //合法
//int *pb = &b; // 不合法
//*pb = 30;
//保存常变量地址  需要对指针加以限制
const int *pb = &b;


int a = 10;
const int b = 20;
int &ppa = a; //合法
//int &ppb = b; // 不合法
//ppb = 30;
//如果想给常变量取个别名， 需要对别名（引用）加以限制
const int &ppb = b;// （ppb  常引用）

4、函数重载

4.1 概念

在同一个作用域下，两个以上的函数，取相同的函数名，其参数的个数或者参数的类型不同，编译器会根据实参的参数个数或类型，自动调用匹配的函数，这就是函数重载。

注意：不以返回值作为标准

int add(int x, int y)
{
    return x+y;
}


int add(char x, char y)
{
    return x+y;
}


string add(string x, string y)
{
    return x+y;
}


double add(double x, double y)
{
    return x+y;
}

4.2 默认参数

具体的使用：如果函数调用没有给实参，那么就使用形参的默认值。如果函数调用给了具体实参，那么就使用所传递的实参。

4.3 内联函数

概念： 就是在函数前加个关键字 inline ---->该函数就是内联函数。

内联函数的要求：

1> 要求代码量比较小，程序代码一般不超过5行

2> 不能有复杂的语句，比如循环，分支

3> 递归函数不能作内联

作用：提高代码的运行效率 （原因：内联函数是在编译时展开）

内联函数和带参宏替换的区别：

1> 内联函数是函数调用，带参宏是替换。

2> 内联函数是在编译时展开，而宏替换是在预处理时展开

4.4  哑元

用于代码的升级优化。

在定义函数的形参时，只定义类型，不定义形参名，在函数体中也不使用。

作用：没有作用，占位

5、c++中的结构体

C++中的结构体和C语言中的结构体的区别：

1>C语言中的结构体在C++中依然使用

2> C++中的结构体可以有函数，而C语言中的结构体不可以。

3> C++定义结构体类型时，可以给变量赋初始值，而C语言中的结构体不可以。

4> C++中结构体，使用结构体类型定义变量时，可以省略关键字struct不写。而C语言中的结构体不可以。

5> C++中的结构体中有访问权限，而C语言中的结构体没有访问权限。

6> C++中的结构体有继承，而C语言中的结构体没有继承。

7> C++中的结构体有特殊的成员函数，而C语言中的结构体没有。

注意：在C++中定义结构体的结构名时，首字母大写。

C++的结构体访问权限：默认是public 共有权限

访问权限：public公有 、protected受保护、private私有

6、类

6.1 概念

C++中的类是由C++中的结构体演变而来，一般有变量又有函数的构造类型，用类来完成。

只是默认访问权限和默认继承方式以及关键字不同。（C++中的类和C++中的结构体区别）

结构体的关键字：struct

结构体的默认访问权限：public(共有的)

结构体的默认继承方式：public(共有的)

类的关键字：class

类的默认访问权限：private(私有的)

类的默认继承方式：private(私有的)

6.2 格式

class 类名
{
    public:
        公共的数据成员、成员函数
    protected:
        受保护的数据成员、成员函数
    private:
        私有的数据成员、成员函数
};

6.3 访问权限的介绍

1> public: 该权限是公共的， 表示该权限下的属性（变量）、方法（函数），可以在类内、子类、类外被访问。

2> protected:该权限是受保护的， 表示该权限下的属性（变量）、方法（函数）， 可以在类内、子类被访问，类外不可以被访问。

3> private：该权限是私有的， 表示该权限下的属性（变量）、方法（函数），只能在类内被访问，子类、类外不可以被访问。

6.4 封装

面向对象：封装、继承、多态

类的三大属性：封装、继承、多态

封装：对数据和对数据的处理捆绑在一起的过程。

                属性   +   方法   =   封装

             （变量）（函数）

类中的内容，都可以称为成员，成员又可以分为：数据成员、成员函数

一般类中的数据成员封装成private权限，成员函数封装成public权限。

练习

/*
自己封装一个矩形类(Rect)，拥有私有属性:宽度(width)、高度(height)，
定义公有成员函数:
初始化函数:void init(int w, int h)
更改宽度的函数:set_w(int w)
更改高度的函数:set_h(int h)
输出该矩形的周长和面积函数:void show()
*/

#include 

using namespace std;

class Rect {
private:
    int _width;
    int _height;
public:
    void init(int width = 1, int height = 1) {
        _width = width;
        _width = height;
    }
    void set_w(int width){
        _width = width;
    }
    void set_h(int height) {
        _height = height;
    }
    void show(){
        cout << "周长：" << 2*(_width+_height) << ",面积：" << _width * _height << endl;
    }
};

int main()
{
    Rect rect;
    rect.init(10,30);
    rect.show();
    return 0;
}