一、面向对象

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++

嵌入式C++（一）_开发语言

1.3 面向对象和面向过程

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

  • 强调做算法
  • 以函数为单位，分割成一个一个的小程序
  • 数据开放：如何提供相应的头文件和库文件，可以任意调用其所有的功能

c++：面向对象，以事物为中心的编程思想
特点

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

  • 维护的代码期待更少的修改（主要依赖于抽象）
    嵌入式C++（一）_开发语言_02

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

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;
}

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;
}

嵌入式C++（一）_开发语言_03

2.3 命名空间

  1. 目的

为了解决合作开发时不同代码段之间命名冲突的问题，所以引入命名空间概念
嵌入式C++（一）_其他_04

#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;
}

2.4 c++标准库

嵌入式C++（一）_c++_05

2.5 c++的输入和输出

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

#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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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. 例
#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;
}

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;
}

嵌入式C++（一）_c++_06

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;
}

2.14 常引用

（1）

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

（2）

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

(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;
}