C++ 快速学习（一）

总感觉学计算机不该只关注计算机技术，结合计算机技术做一些跨领域
的事情会更有意义。计算机视觉是一个不错的方向，鉴于图像处理一般用C++的场景比较多，决定先从C++入手。

预备知识

熟悉C、Java、Python任意一门语言，了解编程语言的通用特性：数据类型、流程控制、函数、面向对象、文件IO、网络。

一. C++的语言特性

1 初始化方式，C++支持赋值符号=之外的初始化方式。

int a = 1024;
string a = "aaa"
int a[5] = [0,1,2,3,4]

int a(1024) // 新的赋值方式
string a("aaa") 
int a[5]{0,1,2,3,4}
vector<int> iv{1, 2, 3};  
map<int, string>{{1, "a"}, {2, "b"}}

---

2 类型推测与空指针

• C++11中可以自动推到数据类型，建议使用类型推导，关键字为auto

• 类型反推特性。类似于auto的反过程。

• 使用nullptr来代替NULL，使空指针的意义更加明确。

auto* p = new Person();

int a = 10;
decltype(a) b = 20 ; // 类型检测

int* p = nullptr;

---

3 for迭代器与lambda表达式

• 使用for可以进行for…in遍历
• 使用lambda函数，形式为 =-> 函数体

// 类似于java，使用for...in进行迭代
map<string, int>  m{{'name',12}, {'age',14}};
for(auto p: m){
    cout <<
}

auto func = [=](int& a)-> {reutrn a+10};
auto func = [b](int& a)-> {reutrn a+10};
// 中括号中等号表示lambda中能范围所有全局变量
// 中括号中b，表示lambda中能访问外围b

4 引用、指针与const

• 引用相当于取别名

• 指针表示内存地址

• const修饰在谁的前面，谁就是不可变的。

    const int* p = 10; // 常量的指针，*p不能被重新赋值
    int a = 999;
    int* const p =  & a; // 指针常量，表示指针p不能被重新赋值

---

5 进制转换

    using namespace
    int a = 10;
    int b;
    cout << 'hex' << a;
    cout << 'oct' << a;
    cout << 'bin' << a;

6 字符串与整型的互相转换

借助于sstream

#include 

stringstream ss();
int a = 10;
ss << a;

return ss.str()

二. C++面向对象之封装性

类的结构
C++中完整类的定义一般是分文件写的，例如Person类有Person.h和Person.cpp组成，.h文件负责定义属性和方法（类似接口，只定义不实现），而.cpp文件对.h文件中的定义的方法进行实现。

//  #### Person.h
class Person {
private:
    string name;
    int age;
    string gender;

public:
    Person(); // 构造
    ~Person() // 析构
    Person(const Person& ); // 拷贝构造函数
    string toString();
}

// #### Person.cpp 实现头文件中定义的方法
Person::Person(){
    cout << "构造函数"
}

~Person::Person(){
    cout << "析构函数"
}

string Person::toString(){
    return this -> name;
}

对象的初始化

C++中初始化方式有两种：从堆中初始化和从栈中初始化。从堆中初始化需要手动去申请内存，从栈中初始化时系统自动管理内存。

构造函数初始化列表
构造函数在实现时，可以通过初始化列表对象的成员进行赋值。

 // Person.h
class Person{
private:
    string _name;
    int _age;
public:
    Person(string name, int age);
    toString():
}

 //Person.cpp
 #include "Person.h"
 #include 
 using namespace std;

Person::Person(string name, int age):_name(name),_age(age){
}

Person p('hk', 10); // 初始化对象

深拷贝、浅拷贝与拷贝构造函数
通过赋值、传值、初始化参数得到的对象均会调用拷贝构造函数，默认拷贝构造函数只会做浅拷贝，如果需要深拷贝，需要在拷贝构造函数中进行处理。

Person p('hk', 12);
Person p_1(p); // 调用拷贝构造
auto p_2 = p_1; // 调用拷贝构造
// 通过传值传递如函数的对象、通过return在函数中返回的对象，均会调用拷贝构造。

// 当对象有对象类型的成员，则需要进行深拷贝

class Point{
private:
    int _x;
    int _y;
public:
Point(int x, int y):_x(x),_y(y){}
}

class Line{
private:
    int _count;
    Point _p;
public:
    Line(x,y,count):_count(count){
        _p(x,y); //实例化Point对象
    }
}

// 针对Line对象，其中包含对象成员Point，在需要深拷贝的场景下，默认拷贝构造无法满足需求，需要特殊定义。

Line(const Line &cp_line){
    cp_line.count = this -> count;
//  cp_line.p = this. -> p;  //只能实现浅拷贝
    cp_line.p = Point p(this->x, this->y); // 深拷贝
}

在C++对象中直接返回this代表的对象时，也会触发拷贝构造，因此返回的并不是原对象，而是一个新对象。

二. C++面向对象之继承性

C++中调用父类方法的写法（同样适用于调用父类构造函数）

class Person{
private:
    string name;
    int age;
public:
    Person(string name, int age):name(name), age(age){}
    void say(){
        cout << "Hello world!";
    }
}

// 继承的写法
class Female:public Person{
private:
    bool longhair;
public:
    // 构造函数通过:符号调用父类构造，通过longhair初始化本类参数
    Female(string name, int age, bool longhair)
        :Person(name, age), longhair(longhair){
    }

    void action(){
    // 关于父类的调用，java用super，C#用base，而C++用父类的名字
        Person::say(); // 通过这样的方式调用父类的方法
    }
}