目录
1. C++简介
C++的历史与发展
C++是一种面向对象的编程语言，由Bjarne Stroustrup在20世纪80年代初开发。它是在C语言的基础上增加了面向对象的特性，从而既具有C语言的高效性，又提供了高级的编程抽象。C++已经成为许多系统级软件、游戏、嵌入式系统以及高性能计算应用程序的主要编程语言。
C++的特点与优势
- 面向对象编程：支持类和对象、继承、多态和封装。
- 高效性：C++编译后的程序运行速度很快，接近于C语言。
- 灵活性：支持多范式编程，包括面向对象、泛型编程和过程式编程。
- 丰富的库：拥有丰富的标准库（STL），提供了大量的容器和算法。
2. 基本语法
注释
C++支持单行注释和多行注释。
// 这是单行注释
/*
这是
多行
注释
*/
数据类型与变量
C++支持多种基本数据类型，包括整型（int）、字符型（char）、浮点型（float, double）等。
int a = 10;
char b = 'A';
float c = 3.14;
C++还支持布尔型（bool），用于表示真（true）或假（false）。
bool isTrue = true;
常量
常量可以使用const关键字定义，一旦定义不能改变。
const int MAX = 100;
在C++11及之后的版本中，可以使用constexpr关键字定义常量表达式。
constexpr int MIN = 1; // 常量表达式
运算符
C++提供了丰富的运算符，包括算术运算符、关系运算符、逻辑运算符等。
int a = 5 + 3; // 加法
bool b = (a > 3) && (a < 10); // 逻辑与
C++还支持位运算符，用于按位操作。
int x = 5; // 0101
int y = 3; // 0011
int z = x & y; // 0001，按位与运算
输入与输出
使用cin进行输入，使用cout进行输出。
int num;
std::cin >> num;
std::cout << "Number is " << num << std::endl;
还可以使用getline函数读取一整行输入。
std::string line;
std::getline(std::cin, line); // 读取一整行输入
std::cout << "Line is: " << line << std::endl;
3. 控制结构
条件语句
条件语句用于根据条件执行不同的代码段。
if (condition) {
// statements
} else if (another_condition) {
// statements
} else {
// statements
}
switch (variable) {
case value1:
// statements
break;
case value2:
// statements
break;
default:
// statements
}
示例：根据用户输入的年龄判断是否成年。
int age;
std::cin >> age;
if (age >= 18) {
std::cout << "You are an adult." << std::endl;
} else {
std::cout << "You are not an adult." << std::endl;
}
循环语句
循环语句用于重复执行代码块。
for (int i = 0; i < 10; ++i) {
// statements
}
while (condition) {
// statements
}
do {
// statements
} while (condition);
示例：打印从1到10的数字。
for (int i = 1; i <= 10; ++i) {
std::cout << i << std::endl;
}
4. 函数
函数定义与声明
函数是执行特定任务的代码块。
// 函数声明
int add(int a, int b);
// 函数定义
int add(int a, int b) {
return a + b;
}
示例：定义一个函数计算两个数的乘积。
int multiply(int a, int b) {
return a * b;
}
参数传递
参数传递可以通过值传递和引用传递。
void swap(int &a, int &b) {
int temp = a;
a = b;
b = temp;
}
示例：通过引用传递数组元素。
void increment(int &num) {
num++;
}
返回值
函数可以返回一个值，也可以返回多个值（通过指针或引用）。
int max(int a, int b) {
return (a > b) ? a : b;
}
示例：返回两个数的较大值。
int getMax(int a, int b) {
return (a > b) ? a : b;
}
函数重载
C++支持函数重载，即允许多个同名函数根据参数类型或数量的不同而存在。
int add(int a, int b) {
return a + b;
}
double add(double a, double b) {
return a + b;
}
示例：定义一个函数用于打印整数和一个用于打印浮点数。
void print(int num) {
std::cout << "Integer: " << num << std::endl;
}
void print(double num) {
std::cout << "Double: " << num << std::endl;
}
5. 数组与字符串
一维数组
一维数组用于存储相同类型的多个元素。
int arr[5] = {1, 2, 3, 4, 5};
示例：遍历数组并打印元素。
for (int i = 0; i < 5; ++i) {
std::cout << arr[i] << std::endl;
}
多维数组
多维数组用于存储矩阵等结构。
int matrix[3][3] = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
示例：打印二维数组的元素。
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
std::cout << matrix[i][j] << " ";
}
std::cout << std::endl;
}
字符串处理
C++标准库提供了string类用于字符串处理。
#include <string>
std::string str = "Hello, World!";
示例：拼接两个字符串。
std::string str1 = "Hello";
std::string str2 = "World";
std::string result = str1 + ", " + str2 + "!";
std::cout << result << std::endl;
6. 指针
指针的定义与使用
指针用于存储变量的内存地址。
int a = 10;
int *p = &a;
示例：通过指针修改变量的值。
*p = 20;
std::cout << "a = " << a << std::endl; // 输出20
指针运算
指针可以进行算术运算。
p++; // 移动到下一个内存位置
示例：遍历数组的指针。
int arr[5] = {1, 2, 3, 4, 5};
int *p = arr;
for (int i = 0; i < 5; ++i) {
std::cout << *(p + i) << std::endl;
}
指针与数组
指针可以用于遍历数组。
int arr[5] = {1, 2, 3, 4, 5};
int *p = arr;
for (int i = 0; i < 5; ++i) {
std::cout << *(p + i) << std::endl;
}
示例：数组名实际上是指向第一个元素的指针。
int *p = arr; // 数组名arr是一个指针，指向第一个元素
函数指针
函数指针用于指向函数。
void print(int a) {
std::cout << a << std::endl;
}
void (*funcPtr)(int) = print;
funcPtr(10);
示例：使用函数指针数组调用不同的函数。
void func1(int a) { std::cout << "Function 1: " << a << std::endl; }
void func2(int a) { std::cout << "Function 2: " << a << std::endl; }
void (*funcArray[2])(int) = {func1, func2};
funcArray ;
funcArray ;
7. 引用
引用的定义与用法
引用是变量的别名。
int a = 10;
int &ref = a;
示例：通过引用修改变量的值。
ref = 20;
std::cout << "a = " << a << std::endl; // 输出20
引用与指针的区别
引用必须在定义时初始化且不能更改引用对象，而指针可以改变指向。
int a = 10;
int b = 20;
int *p = &a;
p = &b; // 允许
int &ref = a;
// ref = b; // 错误
示例：使用引用作为函数参数。
void increment(int &num) {
num++;
}
int value = 5;
increment(value);
std::cout << "value = " << value << std::endl; // 输出6
8. 结构体与联合体
结构体定义与使用
结构体用于定义新的数据类型，包含多个成员变量。
struct Person {
std::string name;
int age;
};
Person person = {"John", 30};
示例：访问结构体成员。
std::cout << "Name: " << person.name << std::endl;
std::cout << "Age: " << person.age << std::endl;
联合体定义与使用
联合体用于在相同的内存位置存储不同类型的数据。
union Data {
int i;
float f;
char c;
};
Data data;
data.i = 10;
示例：访问联合体成员。
data.f = 3.14;
std::cout << "Float: " << data.f << std::endl;
枚举类型
枚举类型用于定义一组命名常量。
enum Color { RED, GREEN, BLUE };
Color color = RED;
示例：使用枚举类型。
if (color == RED) {
std::cout << "The color is red." << std::endl;
}
9. 类与对象
类的定义与成员
类是面向对象编程的基本单元，包含成员变量和成员函数。
class Box {
public:
int length;
int width;
int height;
};
示例：定义类的成员函数。
class Box {
public:
int length;
int width;
int height;
int volume() {
return length * width * height;
}
};
对象的创建与使用
对象是类的实例，通过对象可以访问类的成员。
Box box;
box.length = 10;
示例：通过对象调用成员函数。
Box box;
box.length = 10;
box.width = 5;
box.height = 2;
std::cout << "Volume: " << box.volume() << std::endl;
构造函数与析构函数
构造函数用于初始化对象，析构函数用于清理资源。
class Box {
public:
Box(int l, int w, int h) : length(l), width(w), height(h) {}
~Box() {}
private:
int length;
int width;
int height;
};
示例：定义和使用构造函数和析构函数。
Box box(10, 5, 2);
std::cout << "Volume: " << box.volume() << std::endl;
类的继承
继承用于创建新的类，该类从现有类继承属性和行为。
class Rectangle : public Box {
public:
Rectangle(int l, int w) : Box(l, w, 0) {}
};
示例：定义和使用派生类。
Rectangle rect(10, 5);
std::cout << "Area: " << rect.length * rect.width << std::endl;
多态与虚函数
多态允许通过基类指针或引用调用派生类的函数。
class Base {
public:
virtual void show() {
std::cout << "Base class" << std::endl;
}
};
class Derived : public Base {
public:
void show() override {
std::cout << "Derived class" << std::endl;
}
};
示例：使用多态调用虚函数。
Base *b;
Derived d;
b = &d;
b->show(); // 输出"Derived class"
运算符重载
运算符重载允许自定义运算符的行为。
class Complex {
public:
int real, imag;
Complex operator + (const Complex &obj) {
Complex res;
res.real = real + obj.real;
res.imag = imag + obj.imag;
return res;
}
};
示例：重载加法运算符。
Complex c1{1, 2}, c2{3, 4};
Complex c3 = c1 + c2;
std::cout << "Sum: " << c3.real << " + " << c3.imag << "i" << std::endl;
10. 模板
函数模板
函数模板用于定义泛型函数。
template <typename T>
T add(T a, T b) {
return a + b;
}
示例：使用函数模板
std::cout << "Int sum: " << add(1, 2) << std::endl;
std::cout << "Double sum: " << add(1.1, 2.2) << std::endl;
类模板
类模板用于定义泛型类。
template <typename T>
class Box {
T data;
public:
Box(T val) : data(val) {}
T getData() { return data; }
};
示例：使用类模板。
Box<int> intBox(10);
Box<double> doubleBox(3.14);
std::cout << "Int data: " << intBox.getData() << std::endl;
std::cout << "Double data: " << doubleBox.getData() << std::endl;
11. STL（标准模板库）
容器
STL容器用于存储和管理数据。
#include <vector>
std::vector<int> vec = {1, 2, 3, 4, 5};
示例：使用vector容器。
vec.push_back(6);
for (int val : vec) {
std::cout << val << " ";
}
std::cout << std::endl;
算法
STL算法用于操作容器数据。
#include <algorithm>
std::sort(vec.begin(), vec.end());
示例：使用sort算法对vector排序。
std::vector<int> numbers = {4, 2, 5, 3, 1};
std::sort(numbers.begin(), numbers.end());
for (int num : numbers) {
std::cout << num << " ";
}
std::cout << std::endl;
迭代器
迭代器用于遍历容器。
std::vector<int>::iterator it;
for (it = vec.begin(); it != vec.end(); ++it) {
std::cout << *it << std::endl;
}
示例：使用反向迭代器遍历容器。
for (std::vector<int>::reverse_iterator rit = vec.rbegin(); rit != vec.rend(); ++rit) {
std::cout << *rit << " ";
}
std::cout << std::endl;
12. 文件操作
文件读写
C++提供了fstream库用于文件读写操作。
#include <fstream>
std::ofstream outFile("example.txt");
outFile << "Hello, World!" << std::endl;
outFile.close();
std::ifstream inFile("example.txt");
std::string line;
std::getline(inFile, line);
std::cout << line << std::endl;
inFile.close();
示例：写入和读取多个数据。
std::ofstream outFile("data.txt");
outFile << 1 << " " << 2 << " " << 3 << std::endl;
outFile.close();
std::ifstream inFile("data.txt");
int a, b, c;
inFile >> a >> b >> c;
std::cout << a << " " << b << " " << c << std::endl;
inFile.close();
文件流
文件流用于处理文件输入输出。
std::fstream file("example.txt", std::ios::in | std::ios::out);
示例：使用文件流进行读写操作。
std::fstream file("example.txt", std::ios::out | std::ios::in);
file << "New content" << std::endl;
file.seekg(0); // 移动到文件开头
std::string content;
std::getline(file, content);
std::cout << "Read from file: " << content << std::endl;
file.close();
13. 异常处理
异常处理用于处理程序中的错误情况。
try {
// 可能抛出异常的代码
} catch (const std::exception &e) {
std::cerr << "Exception: " << e.what() << std::endl;
} catch (...) {
std::cerr << "Unknown exception" << std::endl;
}
示例：自定义异常类并抛出异常。
class MyException : public std::exception {
public:
const char* what() const noexcept override {
return "My custom exception";
}
};
void functionThatThrows() {
throw MyException();
}
int main() {
try {
functionThatThrows();
} catch (const MyException &e) {
std::cerr << "Caught exception: " << e.what() << std::endl;
}
return 0;
}