第一章:从 C 到 C++

本章建立 C++ 编程的基础:类型和表达式、声明与定义、作用域、命名空间、标准库容器与输入输出,以及指针、引用和 const。示例采用 C++17;各代码块用于独立说明知识点,不要求全部拼成一个程序。

1. 编程范式与代码组织

编程范式是组织程序、分解问题的方法。C++ 支持多种范式,同一个程序可以结合使用。

方式组织重点例子
过程式编程将任务拆成职责清楚的函数读取数据、计算平均值、输出结果
基于对象的编程用类封装状态和操作栈对象提供 push、pop
面向对象编程通过继承和多态组织相关类型用统一接口操作不同图形
泛型编程将算法和类型等具体细节分离一个查找模板用于多种元素类型

C++ 与 C 有大量共同语法,但并不是所有 C 程序都能原样作为 C++ 编译。标准库、类型检查及语言规则存在差异。也不能把高级语言简单分成过程式与面向对象两类,或将 HTML 当作过程式编程语言。

代码风格服务于可读性:变量名称表达含义,函数职责单一,重复逻辑提取为函数,缩进和括号风格保持一致。行数限制等属于项目约定,不是语言语法。注释优先解释意图、限制和不明显的原因。

命名方式

  • 驼峰:studentCount。
  • 蛇形:student_count。
  • 匈牙利命名:在名称中加入范围或类型信息,如 m_iCount、g_pszFileName。

常见前缀 m_ 表示成员,g_ 表示全局,s_ 表示静态;p 常表示指针,i 表示 int,sz 常表示零结尾字符串。这些都是约定,不会改变变量类型,也不是所有项目必须遵守的规则。一个项目应选择一致、容易理解的方案。

2. 基本类型、字面量与初始化

整数类型包括 char、short、int、long、long long;浮点类型包括 float、double、long double;bool 表示真假。

类型大小不能直接按“几个机器字”记忆。 sizeof(char) 恒为 1,但一个字节包含的位数以及其他类型的大小与实现有关。普通 char 是否有符号也与实现有关。需要检查时使用 sizeof、<limits> 中的 numeric_limits;需要特定位宽时可查看 <cstdint> 提供的类型是否可用。

1
2
3
4
5
6
7
8
9
int decimal = 15;
int octal = 015;       // 八进制,十进制值为 13
int hex = 0x15;        // 十六进制,十进制值为 21
unsigned int n = 15U;
long long large = 100LL;
float ratio = 3.14F;   // 无后缀的 3.14 通常是 double
bool ready = true;
char letter = 'A';
const char* text = "A";

‘A’ 是字符,“A” 是包含字符 A 和结尾零字符的字符串字面量。字符串字面量不能修改;需要可修改的字符串内容时使用 std::string。

1
2
3
int count{};          // 明确初始化为 0
int limit = 10;       // 定义并初始化,不是对已有变量赋值
// int local;         // 普通局部 int 未初始化,不能直接读取

有符号整数运算超出可表示范围会产生未定义行为,不能默认依赖“自动绕回”。浮点数通常是近似表示,不能认为每个十进制小数都能精确存储。

3. 结构体、指针与成员访问

结构体将相关数据组织为一个类型:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
#include <string>
struct Student {
    std::string name;
    int id = 0;
    int age = 0;
    double grade = 0;
};

// 在函数体中使用
// Student s{"Alice", 101, 20, 90.5};
// s.grade = 95;
// Student* p = &s;
// p->age = 21;

对象用点号访问成员,指针用箭头访问,p->age 可理解为 (*p).age。标识符区分大小写,name 与 Name 是不同名称。

1
2
3
4
int value = 10;
int* p = &value;  // & 取地址
*p = 20;         // * 解引用,修改 value
p = nullptr;     // 不指向对象

指针必须先具有有效值才能使用。判断 p 非空并不能保证它仍指向存活对象,已经失效的地址也可能不是空指针。int* a, b; 只声明 a 为指针,b 是 int,基础学习时宜分行声明。

4. 声明、定义与分离编译

声明告诉编译器名称及其类型;定义进一步提供对象或函数的实体。

1
2
3
4
5
6
int add(int a, int b);          // 函数声明
int add(int a, int b) {         // 函数定义,也是声明
    return a + b;
}
extern int total;              // 变量声明
int total = 0;                 // 变量定义

a、b 是形参;调用 add(3, 5) 时,3、5 是实参。非 void 函数必须按规则提供返回值,不能用空函数体充当有效计算实现。

extern 不是“后面绝对不能有定义”的标志:extern int total = 0; 是定义,带函数体的 extern 函数也是定义。通常把接口声明写在头文件,在一个源文件中提供普通非 inline 定义。声明可以在规则允许时重复;定义还要遵守单一定义规则,不能把“所有定义在整个程序中只能出现一次”机械推广到类、模板和 inline 定义。

5. 作用域、static 与生命周期

作用域表示名称在哪里可见;生命周期表示对象什么时候存在。二者不能混为一谈。

1
2
3
4
int nextId() {
    static int id = 0;
    return ++id;
}

id 的名字只在函数体内可见,但对象在调用之间持续存在,连续调用得到 1、2、3。普通局部变量则通常每次进入声明处创建,离开作用域销毁。

在命名空间作用域写 static int counter = 0;,会赋予名称内部链接,使其他翻译单元不能通过外部链接访问它。这与函数内 static 的“跨调用保留状态”侧重点不同。相关生命周期与资源管理见 第二章。

6. 表达式与控制语句

1
2
3
4
int x = 5;
int a = ++x;  // x 先变成 6,a 得到 6
int b = x++;  // b 得到 6,之后 x 变成 7
int larger = (a > b) ? a : b;

= 是赋值,== 是相等比较。if (x = 0) 会修改 x,并以赋值结果判断真假,通常是把 == 写错。&& 和 || 会短路求值,例如 p != nullptr && *p > 0 先检查指针非空。

  • if/else 根据条件选择分支。
  • switch 根据整数或枚举等支持的条件值选择 case;缺少 break 可能继续执行后续分支。
  • for 适合明确的迭代过程,while 适合按条件反复执行。
  • break 离开最近的循环或 switch;continue 进入下一轮循环。

用括号明确表达复杂条件,避免依赖不熟悉的运算符优先级;不要在一个表达式中堆叠对同一变量的多次修改。

1
2
3
4
5
int main(int argc, char* argv[]) {
    // argc 表示参数数量,存在的参数位于 argv[0] 到 argv[argc-1]
    // argc > 0 时 argv[0] 表示程序调用名称,用户参数通常从 argv[1] 开始
    return 0;
}

命令行参数如何切分还受终端、引号和运行环境影响,不能简单认为只按空格机械切开。

7. 命名空间 namespace

命名空间将相关名称放进独立作用域,减少不同模块中的名称冲突。

1
2
3
4
5
6
7
8
namespace school {
    int count = 0;
    int getCount() { return count; }
}

// school::getCount();          // 显式限定
// using school::getCount;      // 引入一个名称
// using namespace school;     // 允许不加限定查找整个命名空间中的名称

标准库中的 string、vector、cout 等位于 std 中。笔记示例优先使用 std:: 前缀,便于确认名称来源。头文件中尤其应避免全局的 using namespace std;,否则会影响所有包含者的名称查找。

8. vector:自动管理存储的顺序容器

1
2
3
4
5
6
7
#include <vector>
std::vector<int> values{1, 2, 3};
// values.push_back(4);  // 尾部追加
// values.pop_back();   // 删除尾元素,不返回被删除的值
// values.size();       // 当前元素数
// values.empty();      // 是否为空
// values.clear();      // 删除所有元素

vector 保存连续排列的元素,可以随需要增长,并自动管理存储。

  • std::vector<int> a(3); 创建 3 个值为 0 的整数。
  • std::vector<int> b{3}; 创建 1 个元素,其值为 3。
  • 有效下标是 0 到 size()-1;[] 不检查越界,at() 会检查。
  • 空容器不能 pop_back(),也不能读取 front()/back()。
  • 扩容可能使原来的指针、引用和迭代器失效。
  • size() 是元素数量,capacity() 是当前存储容量。clear() 不保证释放容量。

每次追加都重新申请“旧长度加一”的简化实现,会令连续追加 N 次的总复制量达到 O(N²),不能把它当作标准 vector 的典型增长策略。标准 vector 尾部追加具有均摊 O(1) 的复杂度。

9. string:字符串对象

1
2
3
4
5
6
#include <string>
std::string text = "Hello";
// text += " C++";
// text.append("!");
// auto pos = text.find("C++");
// if (pos != std::string::npos) { /* 找到 */ }

string 支持赋值、拼接、下标、at()、empty()、size()、find()、swap() 等操作。find() 未找到时返回 npos,而不是 -1 的普通 int 约定。有效字符下标使用小于 size() 的范围。

c_str() 返回零结尾的只读字符序列指针,适合交给需要 const char* 的接口。不要释放它,也不要让它在字符串销毁后继续使用;修改字符串的某些操作还可能使原指针失效。

10. 标准输入输出与文件流

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
#include <iostream>
#include <string>
int main() {
    int age = 0;
    if (!(std::cin >> age)) {
        std::cerr << "Invalid age\n";
        return 1;
    }
    std::string name;
    std::getline(std::cin >> std::ws, name);
    std::cout << name << ": " << age << '\n';
}

cin 读取标准输入,cout 写标准输出,cerr 用于错误信息。流操作会根据类型选择输入输出方式,但仍必须检查输入是否成功。>> 读取字符串时通常遇到空白停止,getline 读取整行;std::ws 会跳过空白,若前导空白或空行有意义,应采用其他衔接方式。

'\n' 输出换行;endl 还会刷新输出缓冲,普通换行通常不需要每次刷新。

1
2
3
4
5
6
7
8
#include <fstream>
int main() {
    std::ofstream out("out.txt");  // 默认会截断已有文件
    if (!out) return 1;
    out << 42 << '\n';
    if (!out) return 1;            // 写入也可能失败
    return 0;
}

ifstream 用于输入,ofstream 用于输出,fstream 可用于双向访问。追加使用 std::ios::app。流对象析构会自动关闭文件;打开成功不代表后续读写必然成功。读取数据时可写 while (in >> value),不要先用 eof() 预测下一次读取是否成功。

11. 引用、传参和 const

引用是已有对象的别名,定义时必须绑定对象,之后不能改绑。

1
2
3
int x = 10, y = 20;
int& ref = x;
ref = y;    // 将 y 的值赋给 x,不是让 ref 改绑 y
1
2
3
void swapValue(int a, int b) { int t = a; a = b; b = t; }
void swapPointer(int* a, int* b) { int t = *a; *a = *b; *b = t; }
void swapReference(int& a, int& b) { int t = a; a = b; b = t; }

第一种只改变副本;第二种按值复制指针,但可通过指针修改所指对象,要求传入有效指针;第三种用引用直接操作原对象。

参数形式常见用途
T value接收独立副本,小型值类型常用
const T& value只读借用较大对象,避免复制
T& value修改对象或通过参数输出结果
T* value可能缺省、需要表示空值等情况

引用不是自动防悬空机制,也不能返回指向已销毁局部对象的引用。

声明能修改所指值能改变指针地址
const int* p / int const* p否是
int* const p是否
const int* const p否否

const 对象必须完成适当初始化。具名常量可以使用 const;要求编译期常量时可考虑 constexpr。普通常量优先于无类型、纯文本替换的宏,避免宏中的分号、作用域和重复求值问题。

成员函数后的 const 与上述指针声明不同,它约束通过当前对象的成员访问,详见 const 成员函数与 mutable。

复习重点

能区分声明与定义、初始化与赋值、作用域与生命周期;能正确使用命名空间、vector、string 和文件流;能根据是否修改、是否允许空值、是否需要避免复制选择参数形式;能检查边界、输入失败与指针有效性。

下一章:第二章。容器和泛型算法的进一步使用见 第三章。

使用 Hugo 构建
主题 Stack 由 Jimmy 设计