嵌入式C++（一）

• 一、面向对象
• • 1.0 环境配置
  • 1.1 C++ 发展
  • 1.2 为什么学习C++
  • 1.3 面向对象和面向过程
  • 1.4 课程体系
  • 1.5 面向对象的三要素
• 二、c到c++的过度
• • 2.1 第一个代码
  • 2.2 作用域限定符（::）
  • 2.3 命名空间
  • 2.4 c++标准库
  • 2.5 c++的输入和输出
  • 2.6 register关键词（……）
  • 2.7 struct的增强
  • 2.8 bool类型
  • 2.9 三目运算符的区别
  • 2.10 c++中的const
  • 2.11 c++ 引用
  • 2.12 引用作为函数的返回值
  • 2.13 指针引用
  • 2.14 常引用

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

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

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

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

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

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

• 维护的代码期待更少的修改（主要依赖于抽象）
  

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

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

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

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

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

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

int main(int argc, char const *argv[])
{
    cout<<"hello world"< 
2.2 作用域限定符（::） 
#include 
using namespace std;

int num = 100;
int main(int argc, char const *argv[])
{
    cout<<"num ="<#include 
using namespace std;
//定义一个命名空间
namespace zhangsan
{
    int num = 333;
    void func()
    {
        cout<<"hello i am zhangsan"<
    int num = 999;
    void func()
    {
        cout<<"hello i am lisi"<
	//方法1：
    using zhangsan::num;
    cout<<"zhangsan num ="<cout//标准输出
cin//标准输入
 
#include 

using namespace std;
void test1()
{
    int e = 999;
    int a = 333;
    char b = 'w';
    char c[] = "helloworld";
    float d = 3.1415926;
    cout<<"a = "<#include 
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 
using namespace std;

struct Chinese
{
    char name[32] = {0};
    void fun()
    {
        cout<<"hello world"<
        cout<
    char name[32] = {0};
    int b;
    void fun()
    {
        cout<<"hello world"<
        cout<
    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类型 
 
 
用法
 
 
占用一个字节
bool类型只有两个取值，----true和false（编译器内部分别用1和0标识）
 用途：表示逻辑运算的结果，关系运算符的结构体以及开关变量的值等
 
 
#include 
#include 
using namespace std;

int main(int argc, char const *argv[])
{
    bool a = true;
    cout<<"a = "<#include 
using namespace std;

int main(int argc, char const *argv[])
{
    int a = 1,b = 2;
    int num = (a > b)? a : b;
    cout< b ? a : b = 100;  //c++中，b = 100; c语言中：2 = 200
    cout< 
2.10 c++中的const 
区别
 
 
 
c语言：const修饰的局部变量是一个只读变量，可以通过地址去修改其值，不可以通过变量名修改
 c++中，修饰的局部变量是真真的常量，会被编译器放在符号表中,类似于宏，不占用内存，符号表类似
 
 
#include 
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 = "<#include 
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 = "< 
例
 
#include 
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 = "<#include 
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<#include 
#include 
using namespace std;

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

void print(student *sl)
{
    cout<<"id = "<id<<"name = "<name<
    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 
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 = "<