C++核心语法快速整理

前言

欢迎来到我的博客

个人主页:北岭敲键盘的荒漠猫-CSDN博客

本文主要为学过多门语言玩家快速入门C++

没有基础的就放弃吧。

全部都是精华，看完能直接上手改别人的项目。

输出内容

std::代表了这里的cout使用的标准库，避免不同库中的相同命名导致混乱

std::cout <<输出内容

右侧可以输出代码执行的结果，字符串，数字

可以多段<<进行拼接

std::endl等价于\n，表示结束语句换行

#include <iostream>int main()
{std::cout << 123+456<<"\n";std::cout << "我喜欢"<< 1+1<<"\n";std::cout << "Hello World!\n"<<"我还有一行哦"<< std::endl;std::cout << "你好你好" << std::endl;
}

变量定义

#include <iostream>
#include <string>int main()
{int a = 5; //整形变量std::string b = "Hello World"; //字符串变量float c = 3.14; //浮点型变量std::cout << a << "\n" << b << "\n" << c;}

运算符

#include <iostream>
#include <string>int main()
{int a = 5; //整形变量std::string b = "Hello World"; //字符串变量float c = 3.14; //浮点型变量std::cout << a + c << '\n'; //输出a+c的值std::cout << a - c << '\n'; //输出a-c的值std::cout << a * c << '\n'; //输出a*c的值std::cout << a / c << '\n'; //输出a/c的值std::cout << a % 2 << '\n'; //输出a对2取模的值std::cout << a++ << '\n'; //输出a的值并将a加1std::cout << a-- << '\n'; //输出a的值并将a减1std::cout << ++a << '\n'; //输出a的值并将a加2std::cout << --a << '\n'; //输出a的值并将a减2}

条件语句

if-else语句

#include <iostream>int main()
{int a = 5; //整形变量if (a > 10) //判断a是否大于10{std::cout << "a大于10" << std::endl; //输出a大于10}else if (a == 10) //判断a是否等于10{std::cout << "a等于10" << std::endl; //输出a等于10}else //如果a不大于10也不等于10{std::cout << "a小于10" << std::endl; //输出a小于10}
}

switch语句

#include <iostream>int main()
{int a = 5; //整形变量switch (a){case 1:std::cout << "a=1" << std::endl;break;case 2:std::cout << "a=2" << std::endl;break;case 3:std::cout << "a=3" << std::endl;break;case 4:std::cout << "a=4" << std::endl;break;case 5:std::cout << "a=5" << std::endl;break;default:std::cout << "a>5" << std::endl;break;}
}

循环语句

while循环

#include <iostream>int main()
{int a = 5; //整形变量while (a < 10) {std::cout << "a is " << a << std::endl;a++;}
}

do-while循环

#include <iostream>int main()
{int a = 5; //整形变量do{a += 10;} while (a < 10);{std::cout << "a is " << a << std::endl;a++;}
}

for循环

#include <iostream>int main()
{int a = 5; //整形变量for (size_t i = 0; i < a; i++){std::cout << "程序执行了 " << i + 1 << "次!" << std::endl;}
}

循环控制关键字

break;
continue

字符串类型变量

看一眼，然后遇到使用的情况直接查。

需要导入库

#include <string>

1. 创建与赋值

std::string s1;             // 空字符串
std::string s2 = "Hello";   // 直接初始化
std::string s3(5, 'a');     // "aaaaa"（重复字符）
s1 = "World";               // 赋值

2. 拼接与追加

s2 += " World";            // 追加 → "Hello World"
s2.append("!");            // 追加 → "Hello World!"
s2.push_back('!');         // 追加单个字符
std::string s4 = s2 + "123"; // 新建拼接字符串

3. 访问元素

char c1 = s2[0];          // 下标访问（不检查越界）
char c2 = s2.at(1);       // 安全访问（越界抛异常）
s2.front() = 'h';         // 首字符（C++11）
s2.back() = 'D';          // 末字符（C++11）

4. 长度与判空

int len = s2.size();      // 字符数量（等价length()）
if (s2.empty()) { ... }   // 是否为空

5. 查找与截取

size_t pos = s2.find("World"); // 首次出现位置（未找到返回npos）
std::string sub = s2.substr(6, 5); // 从位置6截取5字符 → "World"

6. 修改内容

s2.insert(5, " C++");    // 在位置5插入 → "Hello C++ World!!"
s2.replace(6, 3, "Hi");  // 替换位置6开始的3字符 → "Hello Hi World!!"
s2.erase(5, 4);          // 删除位置5开始的4字符 → "Hello World!!"
s2.clear();              // 清空字符串

7. 输入输出

std::cout << s2;              // 输出
std::getline(std::cin, s2);   // 读取整行（包括空格）

8. 遍历字符

for (char ch : s2) {        // 范围for循环（C++11）std::cout << ch;
}

9. 比较与判断

if (s2 == "Hello") { ... }   // 直接比较字符串
if (s2.starts_with("He")) { ... } // 是否以某前缀开头（C++20）

10. 大小写转换

#include <algorithm>
// 转大写
std::transform(s2.begin(), s2.end(), s2.begin(), ::toupper);
// 转小写
std::transform(s2.begin(), s2.end(), s2.begin(), ::tolower);

数组使用

1. 固定大小数组 → `std::array`

#include <array>
std::array<int, 3> arr = {1, 2, 3}; // 类型安全、可拷贝、自带大小// 访问元素
arr[0] = 10;          // 下标访问（无边界检查）
int val = arr.at(1);  // 安全访问（越界抛异常）// 遍历
for (int num : arr) { // 范围for循环（推荐）std::cout << num;
}// 常用操作
bool empty = arr.empty(); // 是否为空（固定数组总为false）
int size = arr.size();    // 元素数量（3）

2. 动态大小数组 → `std::vector`

#include <vector>
std::vector<int> vec = {1, 2, 3}; // 动态扩容、内存自动管理// 添加元素
vec.push_back(4);        // 尾部追加（拷贝）
vec.emplace_back(5);     // 尾部追加（直接构造，更高效）// 删除元素
vec.pop_back();          // 删除尾部元素
vec.erase(vec.begin());  // 删除指定位置元素// 预分配内存（减少扩容开销）
vec.reserve(100);        // 预留容量（不改变size）// 遍历（同std::array）
for (int num : vec) {std::cout << num;
}

3. 传统 C 风格数组（不推荐，仅了解）

int arr[3] = {1, 2, 3}; // 栈上分配，大小固定
int* arr_heap = new int[3]{4, 5, 6}; // 堆上分配（需手动delete[]）// 访问元素
arr[0] = 10; // 无越界检查（易崩溃）// 遍历
for (int i = 0; i < 3; ++i) {std::cout << arr[i];
}// 缺点：无法直接获取大小、易内存泄漏、不支持拷贝等

4. 关键对比与推荐

特性	`std::array`	`std::vector`	C 风格数组
大小固定	是	否（动态扩容）	是
内存管理	自动	自动	手动（堆分配）
越界检查	`.at()` 方法支持	`.at()` 方法支持	无
传递参数	可拷贝、引用传递	可拷贝、引用传递	退化为指针
适用场景	固定数量元素	动态增删元素	特殊需求

多用vector，固定数组大小的需求用array。

指针语法

考虑到指针是C类语言特点，可能别的语言没接触过看这个文章:

最通俗的指针类比解释-CSDN博客

一、基础声明与初始化

1.指针声明
推荐写法：数据类型* 指针名（*紧贴类型，增强可读性）

int* pInt;         // 推荐：强调int*是一个类型
double* pDouble;   // 明确指向double的指针

2.初始化规范

int* p = new int(10);  // 动态初始化（需配对delete）

必须初始化：int val = 5; int* p = &val;
未指向对象时置空：int* p = nullptr

二、核心操作

1.取地址(&)与解引用(*)

int num = 42;
int* p = &num;     // &取地址
cout << *p;        // *解引用 → 输出42
*p = 100;          // 通过指针修改原值

2.动态内存管理（优先用智能指针）

手动管理（需严格配对）

int* arr = new int[5]{1,2,3}; // 动态数组
delete[] arr;  // []必须与new[]配对

智能指针（推荐）

#include <memory>
std::unique_ptr<int> uPtr = std::make_unique<int>(10);  // 独占所有权
std::shared_ptr<int> sPtr = std::make_shared<int>(20); // 共享所有权

三、常用场景规范

数组操作

数组名即首地址：int arr[3] = {1,2,3}; int* p = arr;

传递数组到函数：

void printArray(int* arr, int size) {  // 必须传大小for(int i=0; i<size; ++i) cout << arr[i];  // 等价*(arr+i)
}

函数参数传递

修改原对象时使用指针参数：

void swap(int* a, int* b) {int tmp = *a;*a = *b;*b = tmp;
}

四、安全实践

const修饰

const int* p1;     // 指向常量（值不可改）
int* const p2;     // 指针常量（地址不可改）
const int* const p3; // 双常量

避免常见错误

int* p = new int(5);
delete p;     // 正确释放
p = nullptr;  // 避免野指针

禁止解引用空指针
数组越界访问
悬垂指针（释放后仍访问）

函数

函数定义:

写到主函数上面，或者声明函数。

要规定返回值。

常规写法

#include <iostream>
#include <string>//写到上边void student(){std::string name = "张三";int age = 18;std::cout << "姓名：" << name << std::endl;
}int main()
{student();
}

#include <iostream>
#include <string>//写到下面，但是声明
void student();int main()
{student();
}void student() {std::string name = "张三";int age = 18;std::cout << "姓名：" << name << std::endl;
}

#include <iostream>
#include <string>//默认=李四及设置默认值
void student(std::string username="李四");int main()
{student("张三");student();
}void student(std::string username) {std::string name = username;int age = 18;std::cout << "姓名：" << name << std::endl;
}

传址传参

函数内对变量的操作会直接影响到函数外的相应变量。

#include <iostream>
#include <string>//默认=李四及设置默认值
void student(std::string &username);int main()
{std::string name = "张三";student(name);std::cout << name << std::endl;
}void student(std::string &username) {username = "李四";
}

函数重载

相同函数名，不同返回值，不同参数类型，根据传参执行对应函数。

#include <iostream>
#include <string>//默认=李四及设置默认值
void student(std::string& username);
void student(int& name);int main()
{std::string name = "张三";student(name);std::cout << name << std::endl;int age = 1;student(age);std::cout << age << std::endl;
}void student(std::string &username) {username = "李四";
}void student(int &name) {name = 789;
}

数学计算

大体看一遍!都带好了目录，要用的时候直接点到对应位置查阅!!

使用需要导入cmath库

#include <cmath>

1. 基础计算

double a = std::abs(-3.5);  // 绝对值 → 3.5（兼容整型/浮点）
double b = std::fmod(7.5, 3); // 浮点取余 → 1.5（处理循环进度）

2. 幂与根

double p = std::pow(2, 3);  // 2的3次方 → 8（如计算缩放比例）
double s = std::sqrt(16);   // 平方根 → 4（如物理引擎计算距离）
double c = std::cbrt(27);   // 立方根 → 3（3D空间计算）

3. 取整处理

double up = std::ceil(3.2);   // 向上取整 → 4（如分页计算）
double down = std::floor(3.8); // 向下取整 → 3（网格对齐）
double rd = std::round(3.5);   // 四舍五入 → 4（UI显示）
double cut = std::trunc(3.8);  // 截断小数 → 3（取整数部分）

4. 浮点数检查

bool nan = std::isnan(0.0/0.0); // 是否为非数字（NaN检查）
bool inf = std::isinf(1e300);  // 是否为无穷大（溢出处理）
bool valid = std::isfinite(3.14); // 是否为有效数（安全校验）

5. 极值与运算

double max_v = std::fmax(3, 5);  // 最大值 → 5（限制范围）
double min_v = std::fmin(3, 5);  // 最小值 → 3（约束边界）
double dist = std::hypot(3, 4);  // 直角斜边 → 5（2D/3D距离计算）

6. 特殊值生成

double nan_val = NAN;        // 表示非数字（需C++11）
double inf_val = INFINITY;   // 正无穷大（如超阈值标记）

面向对象

基础创建与公有私有

创建类分为公共和私有，公共能在类外使用，私有仅能在类内使用。

#include <iostream>
#include <string>class MyClass
{
public:std::string name="张三";int age = 18;private:std::string address = "北京";int phone = 123456789;};int main()
{MyClass i;std::cout << i.name << std::endl;std::cout << i.age << std::endl;//std::cout << i.address << std::endl;
}

std::cout << i.address << std::endl;

使用了私有的属性，无法调用。

方法定义

#include <iostream>
#include <string>class MyClass
{
public:std::string name="张三";int age = 18;void print(){std::cout << "姓名：" << name << std::endl;std::cout << "年龄：" << age << std::endl;}private:std::string address = "北京";int phone = 123456789;};int main()
{MyClass i;i.print();
}

外部实现

内部定义函数，外部实现函数。

#include <iostream>
#include <string>class MyClass
{
public:std::string name="张三";int age = 18;void print();private:std::string address = "北京";int phone = 123456789;};void MyClass::print()
{std::cout << "姓名：" << name << std::endl;std::cout << "年龄：" << age << std::endl;
}int main()
{MyClass i;i.print();
}

构造函数

与类名相同的方法，当我们创建对象的时候就会执行方法。

实现的时候不要写返回值类型。

#include <iostream>
#include <string>class MyClass
{
public:std::string name;int age;MyClass(std::string name,int age);void printInfos();
private:std::string address = "北京";int phone = 123456789;
};MyClass::MyClass(std::string name, int age)
{this->name = name;this->age = age;
}void MyClass::printInfos()
{std::cout << "姓名：" << name << std::endl;std::cout << "年龄：" << age << std::endl;
}int main()
{MyClass i("张三",18);i.printInfos();
}

类继承

可以多继承

#include <iostream>
#include <string>class Animal
{
public:int age = 10;
private:};class Animal2
{
public:int age2 = 11;
private:};class Dog : public Animal, public Animal2
{
public:std::string name = "dog";
};void main()
{Dog dog;std::cout << dog.age << std::endl;std::cout << dog.name << std::endl;std::cout << dog.age2 << std::endl;
}

类多态

子类可以修改父类方法

#include <iostream>
#include <string>class Animal
{
public:void print(){std::cout << "i am Animal" << std::endl;}
private:};class Cat : public Animal
{
public:void print(){std::cout << "i am Cat" << std::endl;}
private:};class Dog : public Animal
{
public:void print(){std::cout << "i am Dog" << std::endl;}
};void main()
{Dog dog;Cat cat;dog.print();cat.print();
}

文件操作

文件的创建与写入。

1. 核心文件流类

#include <fstream>
ofstream: 写入文件（输出文件流）
ifstream: 读取文件（输入文件流）
fstream: 读写文件（需指定模式）

2. 基本文件操作

打开/关闭文件

// 写入文件
ofstream outFile("data.txt");      // 默认覆盖模式
outFile.close();// 读取文件
ifstream inFile("data.txt");
inFile.close();// 指定打开模式（如追加）
ofstream logFile("log.txt", ios::app);

常用打开模式

模式标志	说明
`ios::in`	读模式（默认ifstream）
`ios::out`	写模式（默认ofstream）
`ios::app`	追加写入（不覆盖原内容）
`ios::binary`	二进制模式

3. 文本文件操作

写入文本

ofstream out("data.txt");
if (out.is_open()) {out << "Line 1" << endl;       // 写入并换行out << "Value: " << 42 << "\n";// 混合数据类型
}

读取文本

ifstream in("data.txt");
string line;
int value;if (in) {while (getline(in, line)) {     // 逐行读取cout << line << endl;}in.seekg(0);                   // 重置文件指针到开头in >> value;                    // 读取单个值（空格分隔）
}

4. 二进制文件操作

写入二进制数据

struct Person {char name[20];int age;
};Person p = {"Alice", 30};ofstream out("data.bin", ios::binary);
if (out) {out.write((char*)&p, sizeof(Person));  // 直接写入内存数据
}

读取二进制数据

ifstream in("data.bin", ios::binary);
Person p;if (in) {in.read((char*)&p, sizeof(Person));    // 读取到内存cout << p.name << " " << p.age << endl;
}

5. 文件指针控制

fstream file("data.txt");// 获取当前读指针位置
streampos pos = file.tellg();// 移动读指针到第10字节
file.seekg(10, ios::beg);// 移动写指针到文件末尾
file.seekp(0, ios::end);