C++编程学习

1.程序基本结构

   C++ 程序的最小可执行单元由头文件引入、命名空间、主函数等核心部分组成，示例如下：

// 1. 头文件引入：使用#include，<>表示系统头文件，""表示自定义头文件
#include <iostream>  // 输入输出流（cout/cin）的核心头文件

// 2. 命名空间：避免命名冲突，std是C++标准库的命名空间
using namespace std;

// 3. 主函数：程序入口，必须有且仅有一个，返回int类型
int main() {
    // 输出语句：cout是输出流，<<是流插入运算符，endl表示换行+刷新缓冲区
    cout << "Hello, C++!" << endl;
    
    // 4. 返回值：0表示程序正常结束，非0通常表示异常
    return 0;
}

2.数据类型

   C++ 数据类型分为基本类型、复合类型和自定义类型，核心如下：

类型分类	具体类型	说明	示例
基本类型	整型（int/short/long）	存储整数，长度随平台略有差异	int age = 18;
	浮点型（float/double）	存储小数，double 精度更高	double pi = 3.1415926;
	字符型（char）	存储单个字符（ASCII），占 1 字节	char ch = 'A';
	布尔型（bool）	仅存 true/false（本质 1/0）	bool flag = true;
复合类型	数组（array）	同类型元素的连续集合	int arr[5] = {1,2,3};
	指针（pointer）	存储变量内存地址，*解引用，&取地址	int* p = &age;
	引用（reference）	变量的别名，必须初始化且不可更改	int& ref = age;
自定义类型	结构体（struct）	封装不同类型数据	struct Person {string name; int age;};
	类（class）	面向对象核心，封装数据和方法	见 “面向对象” 部分

   关键注意：
   指针与引用的区别：引用是 “别名”（无独立地址），指针是 “地址变量”（可空、可重指向）；
   数组下标从 0 开始，越界访问会导致未定义行为；
   C++11 新增auto类型推导：auto num = 10;（编译器自动推导 num 为 int）。

3.变量与常量

   (1)变量
       定义格式：类型 变量名 = 初始值;（C++ 要求变量先定义后使用）；
       作用域：局部变量（函数 / 代码块内）、全局变量（函数外）、静态变量（static修饰，生命周期贯穿程序）。
   (2)常量
       const：只读常量，编译期确定，不可修改（推荐）：const int MAX = 100;；
       #define：预处理宏替换，无类型检查：#define PI 3.14（不推荐，易出错）；
       constexpr（C++11）：编译期常量，强制常量表达式：constexpr int N = 5;。

4.运算符

   C++ 运算符按功能分为：

类别	运算符示例	说明
算术运算符	+ - * / %	% 为取模（仅整型），/ 整除（整型）
赋值运算符	= += -= *= /=	复合赋值，如a += 3等价a=a+3
比较运算符	== != > < >= <=	返回 bool 值
逻辑运算符	`&& !`	短路求值（&& 前假则不执行后）
位运算符	`& ^ ~ << >>`	按二进制位操作
三目运算符	条件 ? 表达式1 : 表达式2	简化 if-else，如max = a>b ? a : b
指针 / 引用运算符	* &	* 解引用指针，& 取变量地址

5.控制流语句

  (1)分支语句
     if-else：

int score = 85;
if (score >= 90) {
    cout << "优秀" << endl;
} else if (score >= 80) {
    cout << "良好" << endl;
} else {
    cout << "及格" << endl;
}

     switch：基于整型 / 枚举值分支，break终止分支：

int day = 1;
switch (day) {
    case 1: cout << "周一"; break;
    case 2: cout << "周二"; break;
    default: cout << "其他";
}

  (2)循环语句
     for：适合已知循环次数：

for (int i = 0; i < 5; i++) {  // 初始化;条件;增量
    cout << i << " ";  // 输出：0 1 2 3 4
}

     while：先判断条件再执行：

int i = 0;
while (i < 5) {
    cout << i++ << " ";
}

     do-while：至少执行一次，后判断条件：

int i = 0;
do {
    cout << i++ << " ";
} while (i < 5);

  (3)跳转语句
     break：终止当前循环 /switch；
     continue：跳过当前循环剩余语句，进入下一次循环；
     return：终止函数并返回值（主函数 return 结束程序）。

6.函数

  函数是封装可复用逻辑的单元，核心语法：
  (1)函数定义

// 返回值类型 函数名(参数列表) { 函数体 }
int add(int a, int b) {  // a、b为形参
    return a + b;       // 返回值
}

  (2)函数调用

int main() {
    int res = add(3, 5);  // 3、5为实参，res=8
    return 0;
}

  (3) 函数重载（C++ 核心特性）
      同一作用域下，函数名相同、参数列表（个数 / 类型 / 顺序）不同，称为重载：

int add(int a, int b) { return a + b; }
double add(double a, double b) { return a + b; }  // 重载
int add(int a, int b, int c) { return a + b + c; } // 重载

  (4)其他函数特性
      默认参数：参数指定默认值，需从右到左连续设置：int add(int a, int b = 0) { return a + b; }；
      内联函数（inline）：建议编译器将函数体嵌入调用处，减少调用开销（适用于短小函数）；
      递归函数：函数调用自身，需有终止条件：

int factorial(int n) {
    if (n == 1) return 1;  // 终止条件
    return n * factorial(n-1);
}

7.面向对象编程（OOP）

  C++ 核心特性，三大支柱：封装、继承、多态。
  (1)类与对象
      类（class）：封装数据（成员变量）和行为（成员函数），默认访问权限为private；
      对象：类的实例化。

class Person {
private:  // 私有成员：仅类内可访问
    string name;
    int age;
public:   // 公有成员：外部可访问
    // 构造函数：创建对象时初始化，与类名同名，无返回值
    Person(string n, int a) : name(n), age(a) {}  // 初始化列表
    
    // 成员函数：访问/修改私有成员
    void showInfo() {
        cout << "姓名：" << name << "，年龄：" << age << endl;
    }
    
    // 析构函数：对象销毁时调用，清理资源，~类名，无参数无返回值
    ~Person() {
        cout << name << "已销毁" << endl;
    }
};

// 创建对象（实例化）
int main() {
    Person p("张三", 20);
    p.showInfo();  // 调用公有成员函数
    return 0;
}

  (2)继承
      复用已有类（基类 / 父类）的代码，派生类 / 子类可扩展功能：

// 基类
class Student : public Person {  // public继承：基类公有/保护成员在子类保持原权限
private:
    int score;
public:
    // 派生类构造函数：先调用基类构造函数
    Student(string n, int a, int s) : Person(n, a), score(s) {}
    
    void showStudentInfo() {
        showInfo();  // 调用基类成员函数
        cout << "成绩：" << score << endl;
    }
};

  (3)多态
      通过虚函数实现，分为编译期多态（重载）和运行期多态（重写）：
      虚函数：基类中用virtual修饰的成员函数，子类可重写；
      纯虚函数：virtual 返回值 函数名() = 0;，包含纯虚函数的类为抽象类，不可实例化。

class Shape {  // 抽象类
public:
    virtual double getArea() = 0;  // 纯虚函数
};

class Circle : public Shape {
private:
    double r;
public:
    Circle(double r) : r(r) {}
    // 重写纯虚函数
    double getArea() override {  // override（C++11）：显式声明重写，避免错误
        return 3.14 * r * r;
    }
};

// 多态调用：基类指针/引用指向子类对象，调用子类重写的函数
int main() {
    Shape* s = new Circle(5);
    cout << "圆面积：" << s->getArea() << endl;  // 调用Circle的getArea
    delete s;
    return 0;
}

8.泛型编程（模板）

  C++ 实现代码复用的核心方式，分为函数模板和类模板，支持 “类型参数化”。
  (1)函数模板

// 模板参数T：通用类型
template <typename T>
T maxVal(T a, T b) {
    return a > b ? a : b;
}

int main() {
    cout << maxVal(3, 5) << endl;    // T推导为int
    cout << maxVal(3.14, 2.71) << endl;  // T推导为double
    return 0;
}

  (2)类模板（如 STL 容器）

template <typename T>
class MyArray {
private:
    T* arr;
    int size;
public:
    MyArray(int s) : size(s) {
        arr = new T[size];
    }
    ~MyArray() {
        delete[] arr;
    }
};

// 使用类模板：显式指定类型
MyArray<int> arr1(5);
MyArray<double> arr2(10);

9.标准库（STL）

  C++ 标准模板库（Standard Template Library）提供了丰富的容器、算法和迭代器：
  容器：存储数据的结构，如vector（动态数组）、string（字符串）、map（键值对）、list（双向链表）等；
  算法：通用操作，如sort（排序）、find（查找）、reverse（反转）等；
  迭代器：遍历容器的 “指针”，如vector<int>::iterator it。

#include <vector>
#include <algorithm>  // sort算法头文件

int main() {
    vector<int> vec = {3, 1, 4, 2};
    sort(vec.begin(), vec.end());  // 排序：1 2 3 4
    // 遍历
    for (auto it = vec.begin(); it != vec.end(); it++) {
        cout << *it << " ";
    }
    return 0;
}

10.异常处理

  捕获运行时错误，避免程序崩溃：

try {
    int a = 10, b = 0;
    if (b == 0) {
        throw "除数不能为0";  // 抛出异常
    }
    cout << a / b << endl;
} catch (const char* msg) {  // 捕获异常
    cout << "错误：" << msg << endl;
} catch (...) {  // 捕获所有未匹配的异常
    cout << "未知错误" << endl;
}

11.核心特性补充

  (1)内存管理：
      手动管理：new（分配堆内存）/delete（释放）、new[]/delete[]（数组）；
      智能指针（C++11）：unique_ptr（独占所有权）、shared_ptr（共享所有权），避免内存泄漏。
  (2)Lambda 表达式（C++11）：匿名函数，简化回调 / 算法调用：

vector<int> vec = {3,1,4,2};
sort(vec.begin(), vec.end(), [](int a, int b) { return a > b; });  // 降序排序

  (3)命名空间：避免命名冲突，可嵌套 / 别名：

namespace ns1 {
    int a = 10;
}
using namespace ns1;  // 导入命名空间
// 或
cout << ns1::a << endl;  // 限定访问

  总结: C++ 语法的核心是 “高效” 与 “灵活”
      基础层：变量、运算符、控制流、函数，延续 C 语言的面向过程特性；
      核心层：类 / 对象、继承、多态，实现面向对象；
      扩展层：模板、STL、Lambda 等，支持泛型编程和现代编程范式。
      学习建议：先掌握基础语法，再深入面向对象和模板，结合 STL 实践，理解内存管理和多态的底层逻辑，是掌握 C++ 的关键。