C++ 从遗忘到入门

int a; // 声明未初始化，使用前建议手动初始化char b = 'a';float c = 1.0f; // C++中默认小数是double类型，加上f可以指定为floatdouble d = 2.0;auto e = 20; // 编译器自动推导auto为 int 类型

// 结构体定义struct Person { std::string name; int age;}
// 结构体初始化，Person person = {"Jim", 20}; 
Person person2; // 创建另一个实例person2 = person;// 将person中的值复制到person2中，默认是浅拷贝，在有指针的情况下有潜在风险枚举（enum）

enum Color { RED, GREEN, BLUE };
// 使用Color myColor = RED;

enum class Color { RED, GREEN, BLUE};
Color myColor = Color::RED; // 使用作用域解析运算符(::)访问枚举值

// 联合体的定义union Data { int intValue; float floatValue; char charValue;}
// 联合体一次只能保存一种类型的数据，每次赋值都会覆盖内存中之前的值// 因此联合体一般是配合结构体来使用，下面是一个示例
// 定义数据类型的枚举enum DataType { INT, FLOAT, CHAR};
// 定义一个结构体，它包含一个联合体和一个枚举标签struct SafeUnion { // 标记当前联合体中存储的数据类型 DataType type;
 // 定义联合体 union { int intValue; float floatValue; char charValue; } data;};
// 赋值操作SafeUnion su;su.type = FLOAT;su.data.floatValue = 1.0f;
// 使用时，通过type判断类型然后访问联合体对应的成员变量switch(su.type) { case FLOAT: cout << su.data.floatValue << endl; break;
}

class Person {
public: void doWork(); // 方法，类对外提供的一系列操作实例的函数
private: std::string name; // 成员变量，封装到类中的属性，保存内部状态信息 int age;};

// 基础类型int a{0}; double b{3.14}; 
// 结构体struct MyStruct { int x; double y;};
MyStruct s{1, 2.0};
// 类class MyClass {public: MyClass(int a, double b) : a_(a), b_(b) {}private: int a_; double b_;};
MyClass obj{5, 3.14}; // MyClass 必须有一个匹配这个参数列表的构造函数
// 数组int arr[3]{1, 2, 3};

// 上面介绍的都是现代C++推荐写法，省略 = // 下面的2种写法绝大多数情况下是等价的float arr[2]{1, 2}; // 写法1float arr[2] = {1, 2}; // 写法2// 编译器对这两种写法的处理是一致的，方法2并不会产生临时变量和拷贝赋值，包括类的声明

int a = 7.7; // 编译能通过，但是有warningint b = {1.0}; // 编译器拒绝通过，因为浮点到整形的转换会丢失精度

Typename arrayName[Size]; 
// 基本类型int arr[10];char charArr[30];
// 复杂类型struct Point { int x; int y;}Point points[10];

int arr[] = {1, 2, 3, 4, 5}; // 数组大小为5，编译器自动确定int arr[10] = {1, 2, 3}; // 数组前三项确定为1，2，3，其余被初始化为0int arr[10] = {0}; // 整个数组全部为0

int arr[10] = {}; // 零初始化arr[0] = 10; // 修改数组第一个元素值为10

int arr[10] = {0}; int a = arr[10]; // 最大的有效索引是9，这里出现越界，但编译器能顺利编译通过（有警告）// a中的值是不确定的，没有实际意义的，这里是读取，危害可能有限
arr[10] = 99; // 可怕的是该语句也能通过编译，但这里进行了更加危险的操作，// 越界访问了一块内存并修改了其内容，这很可能导致程序崩溃

Typename arrayName[Rows][Columns]; // Rows是行数， Columns是列数， 必须常量
// 实际示例int arr[10][10]; // 定义了一个10*10的二维数组

// 完全初始化int matrix[2][3] = { {1, 2, 3}, {4, 5, 6}};
// 部分初始化int matrix[2][3] = { {1, 2}, // 第一行的最后一个元素将被初始化为 0 {4} // 第二行的第二个和第三个元素将被初始化为 0};
// 单行初始化int matrix[2][3] = {1, 2, 3}; // 只初始化第一行，其他行将默认初始化为0
// 自动推断，和一维数组一样，编译器会根据数组推断二维数组第一维的大小int matrix[][3] = { {1, 2, 3}, {4, 5, 6}};

Typename arrayName[Depth][Rows][Columns];

Typename * ptrName;
// 指针定义风格，下面的声明都正确int *p; // C风格，旨在强调 （*p）是一个整形值int* p; // 经典C++风格，只在强调 p是一个整形指针类型（int*）
// 集团推荐的风格,指针、引用都是居中，两边留空格int * p; // 指针int & a = xx; // 左值引用int && a = xx; // 右值引用

int a = 123; // 假设 a 地址为 0xfffff100int * p = &a; // 此时 p 中存储的值为 0xfffff100p = p + 1; // 此时 p 中存储的值为 0xfffff104 （0xfffff100偏移4个字节，即int变量占用的大小）

int a = 5;int * p = &a; // & 取地址运算符
// * 用在指针这里是解引用运算符，可以获取指针指向的地址的值cout << *p << endl; // 输出 5
int b = 10;p = &b; // 指针变量可以修改其指向地址cout << *p << endl; // 输出 10

int value = 5;const int * p = &value; // p是一个常量指针int const * q = &value; // 和上面的声明等价 *p = 10; // 非法，*p是常量不能修改
int a = 6;p = &a; // 合法，p本身不是常量，可以重新赋值

int value = 5;int * const p = &value; // p是常量*p = 6; // 合法
int a = 7;p = &a; // 非法

int arr[5] = {1, 2, 3, 4, 5};int * p1 = arr; // arr 被当做指向数组首元素的指针int * p2 = &arr[0]; // 取arr首个元素的地址// 这种情况下 p1 和 p2 是等价的if (p1 == P2) { // 检测会通过 cout << "p1,p2是等价的" << endl;  cout << *p1 << endl; // 打印 1 cout << *p2 << endl; // 打印 1}
// 使用指针访问数组// 指针方式cout << *(p1 + 1) << endl; // 访问数组第二个元素，这种方式符合指针的计算规则// 类似数组名的使用方式cout << p1[1] << endl;// p1虽然是指针，索引访问方式依然有效，本质是*(p1 + 1)的语法糖

int arr[5] = {1, 2, 3, 4, 5};int * p1 = arr;
cout << sizeof(arr) << endl; // 打印结果：20 cout << sizeof(p1) << endl; // 打印结果：8// sizeof(arr)为数组本身的大小，这里是 5个int占用20字节// sizeof(p1)为指针本身大小，64位系统中占用8个字节

cout << &arr << endl; // 0x16b98aa40cout << &arr + 1 << endl; // 0x16b98aa54cout << &arr[0] << endl; // 0x16b98aa40cout << &arr[0] + 1 << endl; // 0x16b98aa44
// 可以看出 &arr 和 &arr[0] 的值是一样的，但是指针偏移1后// (&arr + 1) 在 &arr 的基础上偏移了20（0x14）个字节// (&arr[0] + 1) 在 &arr[0] 的基础上偏移了4个字节

int * arr = new int[10]; // new操作符在堆内存中申请10个int类型大小的连续空间，并返回首地址arr[0] = 1;arr[1] = 2;// ...delete[] arr; // new操作符申请的内存需要使用delete操作符释放，数组使用delete[]

// 二维数组的动态创建 & 释放int rows = 5; // 行数int cols = 3; // 列数
// 动态创建二维数组int ** array = new int*[rows]; // 创建行指针for (int i = 0; i < rows; ++i) { array[i] = new int[cols]; // 为每行分配内存}
// 初始化二维数组for (int i = 0; i < rows; ++i) { for (int j = 0; j < cols; ++j) { array[i][j] = i * cols + j; // 或者任何其他的赋值逻辑 }}
// 使用二维数组，例如打印它for (int i = 0; i < rows; ++i) { for (int j = 0; j < cols; ++j) { std::cout << array[i][j] << ' '; } std::cout << std::endl;}
// 动态释放二维数组for (int i = 0; i < rows; ++i) { delete[] array[i]; // 释放每行的内存}delete[] array; // 释放行指针数组的内存

int * p[10]; // p是一个包含10个int变量的数组int (*p)[10]; // p是一个指向拥有10个int变量的数组的指针
// * [] 两个运算符的优先级不同，[]的优先级更高// 第一个语句声明了 p[10], int * 是类型// 第二个语句有括号改变了优先级，因此 p 是一个指针，剩下的部分定义了类型
// 下面函数指针也会有类似的定义int (*pf)(int, int); // pf是指向形如 int func(int, int) 的函数指针

// 这是一个简单函数定义int add(int a, int b) { return a + b;}
// 调用int sum = add(3, 7); // sum值为10

// 下面是一个函数原型的定义int draw(int, int); // 函数原型的参数列表可以省略参数名int draw(int width, int height);// 建议加上参数名，可以更直观的了解参数含义

void swap(int a, int b) { int tmp = a; a = b; b = tmp;}
int x = 5; int y = 7;swap(x, y); // x = 5 y = 7

void swap(int * a, int * b) { int tmp = *a; *a = *b; *b = tmp;}
int x = 5;int y = 7;swap(&x, &y); // x = 7 y = 5

int sum(int arr[], int size);// 定义1，这种定义的好处是清晰，调用者一看就知道传递数组指针
int sum(int * arr, int size);// 定义2，这种定义更符合数组传参的本质
// 特殊说明// 不管定义1还是定义2，通过参数传递数组指针后，数组指针（前面介绍过，即数组名）会退化为首个元素// 的地址指针，因此一定要通过size参数传递数组的大小给函数

int a = 5；int & ra = a; // ra的类型是 int&（引用），必须声明时立即初始化
int b = 6;ra = b; // 非法，引用变量不支持重新赋值

void swap(int & a, int & b) { int tmp = a; a = b; b = tmp;}
int x = 5;int y = 7;swap(x, y); // x = 7 y = 5

// 下面指针传递示例void printInfo(int arr[]， int size); // 内部可修改arr
void printInfo(const int arr[], int size); // 内部不可修改arr
// 下面是引用传递示例void printInfo(std::string& info); // 内部可以修改info
void printInfo(const std::string& info); // 内部不可以修改info

// 下面是一组重载函数，同样是计算两个数的和，针对不同类型提供了不同的定义int add(int a, int b) { // 版本1 return a + b;} 
float add(float a, float b) { // 版本2 return a + b;} 
double add(double a, double b) { // 版本3 return a + b;} 
add(1, 2); // 匹配版本1add(1.0f, 2.0f); // 匹配版本2add(1.0, 2.0); // 匹配版本3
add(1.0f, 2.0) // 匹配 ？？？（匹配版本3，原因可以搜索 ”重载解析“）

// 下面两个版本的函数不算重载，因为两者调用时的表达式都是 add(x, y), 编译器无法区分int add(int a, int b);int add(int & a, int & b);
// 下面两个版本算重载，编译器会根据实参是否是常量来匹配更合适的版本int add(const int a, const int b);int add(int a, int b);

template <typename T>T add(T a, T b) { return a + b;}
// 多类型的定义template <typename T1, typename T2>void funcName(T1 a, T2 b);

#include <iostream>using namespace std;
// 函数原型template <typename T>T add(T a, T b); 
int main() { cout << add(1, 2) << endl; // 3 cout << add(1.0f, 2.1f) << endl; // 3.1 cout << add(1.0, 3.2) << endl; // 4.2
 return 0;}
template <typename T>T add(T a, T b) { return a + b;}

// 函数原型template <typename T>T add(T a, T b);
template <class T> // 声明模板时 typename 和 class 等价T add(T a, T b, T c);
// 函数定义略

template <typename T1, typename T2>void funcName(T1 x, T2 y) { ... ?type? temp = x + y; ...}

template <typename T1, typename T2>void funcName(T1 x, T2 y) { ... decltype(x + y) temp = x + y; ...}

template <typename T1, typename T2>？type？funcName(T1 x, T2 y) { ... return x + y;}

// 正常函数声明int add(int a, int b);// 返回类型后置声明auto add(int a, int b) -> int;
// 利用该语法可以这么声明上面的函数（推荐C+11中使用）template <typename T1, typename T2>auto funcName(T1 x, T2 y) -> decltype(x + y) { ... return x + y;}
// C++14及以后得标准拓展了auto的类型推导能力auto funcName(T1 x, T2 y) { ... return x + y;}

// 返回类型 (*指针变量名)(参数列表);
// 示例int add(int a, int b) { return a + b;}
int (*pf)(int, int) = add; // 可以这么理解定义：因为(*pf)表示函数，那么pf就是函数的指针
// 类似数组，函数指针也有两种使用方式cout << (*pf)(2, 3) << endl; // 5 指针使用方式cout << pf(2, 3) << endl; // 5 直接作为函数名使用
// 函数指针的定义一般都不怎么直接，使用也不方面
// 经典C++中可以使用typedef简化这个定义typedef int (*p_fun)(int, int); // 现在p_fun就是一种类型名称p_fun pAdd = add; // 精简很多
// 现代C++提供了 using 语法让这个过程更加直观，推荐使用using p_fun = int (*)(int, int); // 可读性更强p_fun pAdd = add;
// auto大杀器auto pAdd = add; // 懒人利器

#include <iostream>
void callBack(int costTimeMs);void work(void (*pf)(int));
int main() { work(callBack);}
void callBack(int costTimeMs) { using namespace std;
 cout << "costTime:" << costTimeMs << endl; }
void work(void (*pf)(int)) { std::cout << "do some work" << std::endl; // ... pf(123); // (*pf)(123) 也ok}

#include <functional>#include <iostream>
using namespace std;
void callBack(int costTimeMs) { cout << "costTime:" << costTimeMs << endl; }
void work(function<void(int)> callBack) { callBack(1234);}
int main() { function<void(int)> func = callBack; work(func); return 0;}

class MyClass {public: // 公共成员，通常的对外提供的方法定义 void setMember(int member);private: // 私有成员，成员变量，仅供内部调用函数 int mMember; // 集团规范推荐,使用m前缀 void innerFunc(); // 函数一律小驼峰protected: // 受保护成员，成员变量，供子类调用函数};

// person.hpp// C++一般使用 hpp 后缀的头文件，表明包含C++特性的代码（模板、引用、类等）// .h .hpp只是约定的做法，不是语法上的必要性// 类的定义一般放到头文件中，用来对外声明类// 类的头文件规范：类名小写 + '_'分割(如果有多个单词的case)// 如果类名：PersonInfo 对应头文件：person_info.hpp#ifndef PERSON_H#define PERSON_H
#include <string>#include <iostream>
// 声明 'Person' 类class Person {public: // 构造函数声明 Person(const std::string & name, int age);
 // 成员函数声明 void printInfo() const; // const成员函数，保证函数不会修改调用对象
 // Setters 和 Getters 声明 void setName(const std::string & name); const std::string & getName() const;
 void setAge(int age); int getAge() const;
private: // 成员变量 std::string mName; int mAge;};
#endif // PERSON_H
// person.cpp// 实现代码放到同名cpp文件中#include "person.hpp"
// 构造函数定义Person::Person(const std::string & name, int age) : mName(name), mAge(age) {}
// 成员函数定义void Person::printInfo() const { std::cout << "Name: " << mName << ", Age: " << mAge << std::endl;}
// Setters 和 Getters 定义void Person::setName(const std::string & name) { mName = name;}
const std::string & Person::getName() const { return mName;}
void Person::setAge(int age) { mAge = age;}
int Person::getAge() const { return mAge;}

class MyClass {public: MyClass(int m1, int m2, int m3) : mM1(m1), mM2(m2), mM3(m3) {}private: int mM1; const int mM2； int & mM3;};
// 类的初始化方式MyClass a1(1, 2, 3); // 传统构造函数MyClass a1 = MyClass(1, 2, 3); // 同上MyClass a2 = {1, 2, 3}; // 列表初始化，会匹配最合适的构造函数MyClass a3{1, 2, 3}; // 同上

class MyClass {public: MyClass() { // 构造函数分配资源或执行初始化 data = new int[10]; // 假设动态分配了内存 }
 ~MyClass() { // 析构函数释放资源 delete[] data; // 释放动态分配的内存 }
private: int* data; // 指向动态分配的内存};

class MyClass {public: MyClass() : data(new int[10]) { } // 构造函数 ~MyClass() { delete[] data; } // 析构函数
 // 拷贝赋值运算符 MyClass & operator=(const MyClass& other) { if (this != &other) { // 避免自赋值 std::copy(other.data, other.data + 10, data); } return *this; }
private: int* data;};
// 使用MyClass a;MyClass b = a; // 默认的赋值操作是浅拷贝，这里因为重载了 = 运算符，变成深拷贝
// C++11开始可以删除默认的赋值操作符，从而防止因浅拷贝带来的风险class MyClass2 { // ... MyClass2 & operator=(const MyClass2 & other) = delete; // 禁用赋值操作符 // ...};
MyClass2 a;MyClass2 b = a; // 非法，MyClass2的 = 运算符被禁用

#include <iostream>
class MyClass {public: MyClass() : data(new int[10]) { } // 默认构造函数
 ~MyClass() { delete[] data; } // 析构函数
 // 拷贝构造函数 MyClass(const MyClass & other) : data(new int[10]) { std::copy(other.data, other.data + 10, data); std::cout << "copy init" << std::endl; }
 // 拷贝赋值运算符 MyClass & operator=(const MyClass & other) { if (this != &other) { // 避免自赋值 std::copy(other.data, other.data + 10, data); } std::cout << "copy =" << std::endl; return *this; }
private: int* data;};

int main() { MyClass a; MyClass b; MyClass c = a; c = b; return 0;}
// 程序输出// copy init// copy =

#include <iostream>
using namespace std;
class BigMemoryPool { private: static const int POOL_SIZE = 4096; int* mPool;
 public: BigMemoryPool() : mPool(new int[POOL_SIZE]{0}) { cout << "call default init" << endl; }
 // 编译器会优化移动构造函数，正常情况可能不会被执行 // 可以添加编译选项 “-fno-elide-constructors” 关闭优化来观察效果 BigMemoryPool(BigMemoryPool && other) noexcept { mPool = other.mPool; other.mPool = nullptr; cout << "call move init" << endl; }
 BigMemoryPool & operator=(BigMemoryPool && other) noexcept { if (this != &other) { this->mPool = other.mPool; other.mPool = nullptr; } cout << "call op move" << endl; return *this; } void showPoolAddr() { cout << "pool addr:" << &(mPool[0]) << endl; }
 ~BigMemoryPool() { cout << "call destructor" << endl; }};
BigMemoryPool makeBigMemoryPool() { BigMemoryPool x; // 调用默认构造函数 x.showPoolAddr(); return x; // 返回临时变量，属于右值}
int main() { BigMemoryPool a(makeBigMemoryPool());  a.showPoolAddr(); a = makeBigMemoryPool();  a.showPoolAddr(); return 0;}
// 输出内容call default initpool addr:0x152009600instance addr:0x16fdfeda0pool addr:0x152009600instance addr:0x16fdfeda0 // 编译器优化，这里a和x其实是同一个实例，因此不会触发移动构造call default initpool addr:0x15200e600 // 新的临时变量，堆内存重新分配instance addr:0x16fdfed88 // 临时变量对象地址call op move // 移动赋值call destructorpool addr:0x15200e600 // a的Pool指向的内存地址变成新临时对象分配的地址，完成转移instance addr:0x16fdfeda0 // a对象的地址没有变化call destructor

#include <iostream>
// 声明 Vector2D 类class Vector2D {private: float x_; float y_;
public: Vector2D(float x = 0.0f, float y = 0.0f) : x_(x), y_(y) {}
 // 友元函数声明，用于重载 + 操作符 friend Vector2D operator+(const Vector2D & a, const Vector2D & b);
 // 输出 Vector2D 对象的友元函数 friend std::ostream & operator<<(std::ostream & out, const Vector2D & v);};
// 重载 + 操作符的友元函数定义Vector2D operator+(const Vector2D & a, const Vector2D & b) { return Vector2D(a.x_ + b.x_, a.y_ + b.y_);}
// 重载 << 操作符的友元函数定义，用于输出 Vector2D 对象std::ostream & operator<<(std::ostream & out, const Vector2D & v) { out << "(" << v.x_ << ", " << v.y_ << ")"; return out;}
int main() { Vector2D vec1(1.0, 2.0); Vector2D vec2(3.0, 4.0); Vector2D vec3;
 vec3 = vec1 + vec2; // 使用友元函数重载的 + 操作符
 std::cout << "vec1: " << vec1 << std::endl; std::cout << "vec2: " << vec2 << std::endl; std::cout << "vec3: " << vec3 << std::endl; // 输出: vec3: (4, 6)
 return 0;}

#include <iostream>
class MyClass; // 前向声明
// 声明一个类（FriendClass），该类将访问MyClass的私有和受保护成员class FriendClass {public: void accessMyClass(MyClass & obj);};
// 声明主类（MyClass）class MyClass {private: int secret;
public: MyClass(int val) : secret(val) {}
 // 声明FriendClass为MyClass的友元类 friend class FriendClass;};
// FriendClass成员函数实现void FriendClass::accessMyClass(MyClass & obj) { // 可以访问MyClass的私有成员'secret' std::cout << "MyClass secret value is: " << obj.secret << std::endl;}
int main() { MyClass obj(42); // 创建MyClass对象 FriendClass friendObj; // 创建FriendClass对象
 friendObj.accessMyClass(obj); // 访问MyClass的私有成员 return 0;}

class Base { // 基类成员};
class Derived : public Base { // 派生类成员};

#include <iostream>
class Base {public: void baseMethod() { std::cout << "Base method" << std::endl; }
 virtual void polymorphicMethod() { std::cout << "Base polymorphic method" << std::endl; }
 virtual ~Base() {} // 虚析构函数，用于多态};
// 公有继承派生类class Derived : public Base {public: // 重写基类的虚函数 void polymorphicMethod() override { Base::polymorphicMethod(); // 可以通过添加限定域调用基类实现 std::cout << "Derived polymorphic method" << std::endl; }};
int main() { Derived d; d.baseMethod(); // 调用基类的方法 d.polymorphicMethod(); // 调用派生类重写的方法
 Base *b = &d; b->polymorphicMethod(); // 通过基类指针调用派生类的方法，体现多态 return 0;}

// Interface in C++class IShape {public: virtual void draw() const = 0; // 纯虚函数 virtual ~IShape() {} // 虚析构函数以确保派生类的析构函数被调用};
class Circle : public IShape {public: void draw() const override { // 实现绘制圆形的代码 }};
class Rectangle : public IShape {public: void draw() const override { // 实现绘制矩形的代码 }};

template <typename T>class MyTemplateClass { const T& getValue();public: T myValue;};

// 简单示例// 定义智能指针// C++11语法std::unique_ptr<MyClass> my_unique_ptr(new MyClass());std::shared_ptr<MyClass> my_shared_ptr(new MyClass());// C++14提供了更安全更现代的方法auto my_unique_ptr = std::make_unique<MyClass>();auto my_shared_ptr = std::make_shared<MyClass>(); // 可以按照构造函数的定义传参
// 调用类的方法和普通指针类似my_unique_ptr->func();my_shared_ptr->func();
// 在需要传对象指针和引用的场景// 类指针类型void testFunc1(MyClass * p);testFunc1(my_unique_ptr.get()); // 通过get获取原始指针
// 引用类型void testFunc2(MyClass & ref);testFunc2(*my_unique_ptr); // 通过*运算符获取对象的引用

// 封装函数void printHello() { std::cout << "Hello, World!" << std::endl;}std::function<void()> func = printHello;
// 封装Lambda表达式std::function<int(int, int)> add = [](int a, int b) -> int { return a + b;};
int sum = add(2, 3); // sum 的值为 5
// 封装成员函数class MyClass {public: void memberFunction() const { std::cout << "Member function called." << std::endl; }};
MyClass obj;std::function<void(const MyClass &)> f = &MyClass::memberFunction;f(obj); // 输出: Member function called.
// 封装带有绑定参数的函数void printSum(int a, int b) { std::cout << "Sum: " << a + b << std::endl;}
int main() { using namespace std::placeholders; // 对于 _1, _2, _3...
 // 绑定第二个参数为 10，并将第一个参数留作后面指定 std::function<void(int)> func = std::bind(printSum, _1, 10); func(5); // 输出: Sum: 15 return 0;}