• 嵌入式C++（一）

    文章目录

    一、面向对象

    1.0 环境配置

    虚拟机上网（ping www.baidu.com）
    sudo apt-get update //更新软件包
    sudo apt-get install -f //更新软件依赖
    sudo apt-get install g++ //安装c++编译器

    1.1 C++ 发展

    c++98,第一版
    c++03,c++11,c++17

    1.2 为什么学习C++

    在这里插入图片描述

    1.3 面向对象和面向过程

    c语言：面向过程，以后过程为中心，面向记录的编程思想
    特点：

    • 强调做算法

    • 以函数为单位，分割成一个一个的小程序

    • 数据开放：如何提供相应的头文件和库文件，可以任意调用其所有的功能
      c++：面向对象，以事物为中心的编程思想
      特点

    • 以类为单位：每个类实现某个特定的功能

    • 维护的代码期待更少的修改（主要依赖于抽象）
      在这里插入图片描述

    • 面向对象封装性好；可以区分内部函数和对外开放的函数，对于前者，我们可以随意修改，只要保证外部接口一致就可以

    1.4 课程体系

    14天：c++基本语法,stl,（23种）设计模式c++11,c++17新特性
    5天：QT（界面处理）

    1.5 面向对象的三要素

    封装：把客观的事物封装成类，并且可以把自己的数据和方法集成在类中，进行信息隐藏，内部使用或者对外开放等操作
    继承：表达类之间的关系，这种关系使得类可以继承另一个类的所有特性和能力
    多态：简单概括：一个接口，多种方法，字面意思，多种形态

    • 静态多态：早在编译阶段就已经确定了函数地址（函数重载，运算符重载）
    • 在代码运行的时候，才能确定函数的地址（虚函数，纯虚函数，虚析构函数，纯析构函数）

    四要素：封装，## 标题继承，多态，抽象

    二、c到c++的过度

    2.1 第一个代码

    #include <iostream> //标准输入输出流头文件
using namespace std; //使用标准命令空间 std

int main(int argc, char const *argv[])
{
    cout<<"hello world"<<endl; //cout:输出流对象 <<:输出运算符（运算符重载）endl:换行符
    return 0;
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    2.2 作用域限定符（::）

    #include <iostream>
using namespace std;

int num = 100;
int main(int argc, char const *argv[])
{
    cout<<"num ="<<num<<endl;//operator<<(cout,)
    int num = 888;
    cout<<"num ="<<num<<endl;//operator<<(cout,)
    //::域解析符，这里可以用于操作全局变量
    cout<<"num ="<<::num<<endl;//operator<<(cout,)
    ::num = 999;
    cout<<"num ="<<::num<<endl;//operator<<(cout,)
    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    在这里插入图片描述

    2.3 命名空间

    1. 目的

    为了解决合作开发时不同代码段之间命名冲突的问题，所以引入命名空间概念
    在这里插入图片描述

    #include <iostream>
using namespace std;
//定义一个命名空间
namespace zhangsan
{
    int num = 333;
    void func()
    {
        cout<<"hello i am zhangsan"<<endl;
    }
}

namespace lisi
{
    int num = 999;
    void func()
    {
        cout<<"hello i am lisi"<<endl;
    }
}

void test1()
{
	//方法1：
    using zhangsan::num;
    cout<<"zhangsan num ="<<num<<endl;
    num = 1000;
    cout<<"zhangsan num ="<<num<<endl;
    using zhangsan::func;
    func();
}

void test2()
{
	//方法2：使用域解析符
    cout<<"zhangsan num ="<<zhangsan::num<<endl;
    cout<<"lisi num ="<<lisi::num<<endl;
    zhangsan::func();
    lisi::func();
}
//方法3：如果在一个代码中都要使用某一个命名空间的成员，
//可以通过using来标识整个命令空间，这样里面所有的成员操作的时候就不需要通过命名空间来访问了,
//一般都是放在最上面
using namespace zhangsan;
void test3()
{
    cout<<"num ="<<num<<endl;
    func();
    lisi::func();

} 

int main(int argc, char const *argv[])
{
    //test1();
    //test2();
    test3();
    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59

    2.4 c++标准库

    在这里插入图片描述

    2.5 c++的输入和输出

    cout//标准输出
cin//标准输入

    • 1
    • 2
    #include <iostream>

using namespace std;
void test1()
{
    int e = 999;
    int a = 333;
    char b = 'w';
    char c[] = "helloworld";
    float d = 3.1415926;
    cout<<"a = "<<endl;
    //输出十六进制
    cout<<hex<<a<<endl;
    //输出八进制
    cout<<oct<<a<<endl;
    cout<<dec;
    cout<<"a = "<<a<<endl;
    cout<<"b = "<<b<<endl;
    cout<<"c = "<<c<<endl;
    cout<<"d = "<<d<<endl;
    cout<<"e = "<<e<<endl;
}

void test2()
{
    int a,b,c;
    cin>>a>>b>>c;
    cout<<"a = "<<a<<endl;
    cout<<"b = "<<b<<endl;
    cout<<"c = "<<c<<endl;

}

int main(int argc, char const *argv[])
{
    test2();
    return 0;
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    2.6 register关键词（……）

    register关键词的作用是请求编译器让变量直接存放在寄存中，以提升变量的访问速率
    C语言：register关键词不可以取地址，因为不在内存之中
    c++中：register关键词可以取地址，一旦取地址后，regitser关键词变得无效，被定义的变量会被放到内
    存中

    #include <iostream>
using namespace std;

int main(int argc, char const *argv[])
{
    register int i = 0;
    register int j = 0;
    &i;
    &j;
    for (i = 0; i < 1000; i++)
    {
        for (j = 0; j < 1000; j++);
    }
    return 0;
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    2.7 struct的增强

    #include <iostream>
using namespace std;
/*
struct Chinese{
    char name[32];
#if 0 //C语言中结构体不允许内部定义函数
    void func()
    {
        printf("hello");
    }
#endif
}
*/
struct Chinese
{
    char name[32] = {0};
    void fun()
    {
        cout<<"hello world"<<endl;
    }
    void Introduce()
    {
        cout<<name<<"是一个中国人"<<endl;
    }
};

struct USA
{
    char name[32] = {0};
    int b;
    void fun()
    {
        cout<<"hello world"<<endl;
    }
    void Introduce()
    {
        cout<<name<<b<<"是一个美国人"<<endl;
    }
};

void test()
{
    Chinese ch = {"张三"};
    USA u = {"bb",2};
    ch.Introduce();
    u.Introduce();   
}
int main(int argc, char const *argv[])
{
    test();
    return 0;
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53

    c语言中：认为结构体是一个数据类型的集合，不是一种新的数据类型，所以在定义结构体变量前要加上
    struct
    c++中：认为struct是一种新的数据类型的声明，可以直接使用结构体名来定义变量

    2.8 bool类型

    用法

    1. 占用一个字节
    2. bool类型只有两个取值，----true和false（编译器内部分别用1和0标识）
      用途：表示逻辑运算的结果，关系运算符的结构体以及开关变量的值等
    #include <iostream>
#include <cstring>
using namespace std;

int main(int argc, char const *argv[])
{
    bool a = true;
    cout<<"a = "<<a<<endl;
    bool b = false;
    cout<<"b = "<<b<<endl;
    cout<<"sizeof(a) = "<<sizeof(a)<<endl;

    char c[] = "helloworld";
    cout<<"sizeof(c) = "<<sizeof(c)<<endl;
    cout<<"strlen(c) = "<<strlen(c)<<endl;
    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    2.9 三目运算符的区别

    c语言中：返回一个具体的数值，是一个常量
    c++中：返回是一个变量，可以作为左值使用

    #include <iostream>
using namespace std;

int main(int argc, char const *argv[])
{
    int a = 1,b = 2;
    int num = (a > b)? a : b;
    cout<<num<<endl;

    a > b ? a : b = 100;  //c++中，b = 100; c语言中：2 = 200
    cout<<b<<endl;
    return 0;
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    2.10 c++中的const

    区别

    c语言：const修饰的局部变量是一个只读变量，可以通过地址去修改其值，不可以通过变量名修改
    c++中，修饰的局部变量是真真的常量，会被编译器放在符号表中,类似于宏，不占用内存，符号表类似

    #include <iostream>
using namespace std;

const int m_a = 0;  //c语言中，全局变量被const修饰是一个真正的常量
int main(int argc, char const *argv[])
{
    int b = 2, c = 3;
    //const int *a = &b; //const修饰的是*a,表示指向的地址的值是一个常量
    //int const *a = &b; //同上
    //int * const a = &b; //指向的地址不能改变，但是指向的地址中的值可以修改
    const int* const a = &b; //指向的地址不能改变，但是指向的地址中的值也不可以修改
    //*a = 1;
    //a = &c;

    //m_a = 1;
    //int *p = &m_a;
    //*p = 2;

    const int f = 1;
    int *pf = (int *)&f;
    *pf = 2;
    cout<<"f = "<<f<<endl;
    cout<<"pf = "<<*pf<<endl;
    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    2.11 c++ 引用

    1. 概念
    #include <iostream>
using namespace std;

struct Test
{
    int &a;   //相当于一个常指针，大小为8个字节，两个为16个字节
    char &b;
};

int main(int argc, char const *argv[])
{
    int a = 1;
    char c = 'c';
    int &pa = a; //引用定义的时候必须初始化
    char &pc = c;
    pa = 100;
    cout<<"a = "<<a<<endl;
    cout<<sizeof(pa)<<endl;
    cout<<sizeof(pc)<<endl;
    cout<<sizeof(struct Test)<<endl;//分析正常语法现象的时候，当别名分析
                                    //分析奇怪语法现象的时候，当常指针分析
    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    1. 例
    #include <iostream>
using namespace std;
void Swap(int &a, int &b)
{
    int tmp = a;
    a = b;
    b = tmp;
}

int main(int argc, char const *argv[])
{
    int a = 100, b = 200;
    cout<<"a = "<<a<<", b = "<<b<<endl;
    Swap(a,b);
    cout<<"a = "<<a<<", b = "<<b<<endl;
    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    2.12 引用作为函数的返回值

    使用方式

    1. 不接受函数返回值
    2. 用一个普通变量去接收函数返回值
    3. 用一个引用接收函数的返回值
    4. 当成左值使用
    #include <iostream>
using namespace std;
int g = 100;
int& func()
{
    int x = 1;
    //return x;  //不能返回局部变量
    return g;
}

int main(int argc, char const *argv[])
{
    func();   //不接受函数的返回值
    int a = func();   //int a = g;
    cout<<a<<endl;

    int &b = func();  //int &b = g;
    b = 200;
    cout<<"g = "<<g<<endl;
    cout<<"b = "<<b<<endl;
    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    在这里插入图片描述

    2.13 指针引用

    #include <iostream>
#include <cstring>
using namespace std;

struct student
{
    int id;
    char name[20];
};

void print(student *sl)
{
    cout<<"id = "<<sl->id<<"name = "<<sl->name<<endl;
}

void GetStudent(student *&s2)
{
    student *tmp = (student *)malloc(sizeof(student));
    if (NULL == tmp)
    {
        s2 = NULL;
        return;
    }
    tmp->id = 10;
    strcpy(tmp->name,"zhangsan");
    s2 = tmp;
}
int main(int argc, char const *argv[])
{
    //int * &pc = &a;
    student *ptr = NULL;
    GetStudent(ptr);
    print(ptr);
    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    2.14 常引用

    （1）

    所谓常引用，是指不能通过引用来修改变量的值

    （2）

    int a = 1;
const int &b = a   //b是a的常引用，a和b代表同一块空间，但是不能使用b去修改A的值
const &num = 10;

    • 1
    • 2
    • 3

    (3)例：

    #include <iostream>
using namespace std;

int main(int argc, char const *argv[])
{
    int a = 1;
    int &pa = a; //普通变量初始化普通引用
//  int &pc = 1; //常量不能初始化普通引用

    const int &pb = a; //变量初始化常引用
    //pb++;
    a++;
    cout<<"pb = "<<pb<<endl;

    const int &pd = 100; //可以使用常量初始化常引用
    int *p = (int *)&pd;
    (*p)++; 
    *p++; //char[p++];
    cout<<"pd = "<<pd<<endl;
    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
  • 相关阅读:
    Python | R | MATLAB群体消息和遗传病筛选多元统计模型
    学会Spring Cloud微服务架构绝活，渣本也能进大厂
    寒假训练——第三周（状压DP）
    【Final Project】Kitti的双目视觉里程计（3）前端及整体过程理解
    kernel 定时数据机构和API
    精益项目管理的流程
    CodeWhisperer 的安装及体验
    【Mybatis】常见面试题：处理表与表之间的关系：多对一，一对多
    酷开会员享受海量影视资源，尽在酷开系统！
    VoLTE基础自学系列 | VoLTE终端哪些场景会触发CSFB？
  • 原文地址：https://blog.csdn.net/m0_52592798/article/details/125581146