Skip to content

第 1 章:变量与数据类型 ​

本章能学到什么 ​

  • 变量是什么,为什么要用变量
  • 变量的声明、赋值与改名规则
  • C++ 的五种基本数据类型:int、double、char、string、bool
  • 静态类型与动态类型的区别(与 Python 对照)

本章承接第 0 章"启程"——程序已经能跑起来,现在开始往程序里放"数据"。本章讲的数据类型,是第 2 章"运算符与表达式"的基础:不同类型的数据,能做的运算不一样。

1.1 从改分数说起 ​

班主任要登记小明的期中成绩。成绩单上写着:语文 92 分。后来复核发现加错了,应该是 95 分。如果成绩被抄进了十张表格,就得改十个地方;漏改一处,两处数据就对不上。

游戏里也有同样的事。角色血量显示在屏幕左上角,战斗时扣血,吃道具时加血。血量这个数字会被很多处用到,它不能写死在屏幕上,必须存在一个统一的地方,哪里要看血量,就去那里取。

程序里这个"统一存放数据的地方"就是变量。变量是一个带名字的格子,格子里放数据;程序通过名字找到格子,看里面的数,或者换一个新的数。

再细化一下游戏的例子。角色被怪物打一下,程序做的事是:找到名叫"血量"的格子,把里面的数减去 10,放回去,屏幕左上角的显示跟着刷新。如果血量不是一个变量,而是直接画在屏幕上的数字 100,被打一下就得把整张图重画一遍——每改一次数字重画一次,游戏根本做不出来。变量把"数据"和"显示"分开了:数据在格子里变,显示随时去读格子。

数学里其实早就在用字母代表数。交换律 a+b=b+a 里的 a 和 b 可以代入任何数;长方形面积 S=a×b 里的 a、b、S 各有各的角色。程序里的变量和它们是同一种思维,只是格子里的值可以随时换。

这个思路在数学里早就见过。方程 x+5=12 里的 x 就是一个"带名字的格子":它代表一个数,这个数可以待定、可以求解、可以代入。程序里的变量比方程里的未知数更灵活一点——x 在方程里通常只有一个答案,而变量的值在程序运行过程中可以多次改变,像记分牌上的分数一样可以翻动。

1.2 声明与赋值 ​

在 C++ 里,使用一个变量之前要先"声明"它:告诉计算机,格子的名字是什么,格子里打算放哪种数据。

cpp
#include <iostream>

int main() {
    int score;      // 声明:一个叫 score 的格子,放整数
    score = 92;     // 赋值:把 92 放进格子
    score = 95;     // 再赋值:复核后改成 95,旧值被覆盖

    std::cout << "复核后的成绩:" << score << std::endl;
    return 0;
}

预期输出:

text
复核后的成绩:95

三个要点:

操作写法含义
声明int score;造一个名为 score、只能放整数的格子
赋值score = 92;把 92 放进格子
再赋值score = 95;旧值被新值覆盖,格子里只剩 95

声明和赋值可以合并成一行:int score = 92;。这是最常见的写法。

也可以先声明、后赋值,比如数据要等程序运行到一半才知道的时候。但初学阶段尽量合并写——格子一造出来就有确定的值,出错的机会就少一分。读别人的代码时两种写法都会见到,认出它们是同一件事的两步即可。

这里的 = 不是数学里的"等于"。数学里 x=5 是陈述"x 等于 5"这个事实;程序里 score = 92 是一个动作:"把 92 放进 score"。方向从右往左,右边的值进左边的格子。判断"等不等于"用的是另一个符号 ==,第 2 章会讲。

变量的命名规则 ​

规则合法的例子不合法的例子
只能用字母、数字、下划线score、hp2、player_1my score(含空格)
不能用数字开头score22score
不能用 C++ 的关键字myIntint、return
区分大小写score 和 Score 是两个变量—

名字要有意义。score 一看就懂,a1b2 过几天自己也看不懂。这是个好习惯,不强制,但强烈建议。

1.3 数据类型 ​

声明变量时写的 int 是"数据类型"。类型规定了格子里能放什么、格子占多大地方。为什么需要类型?因为不同数据的处理办法不一样:整数可以做除法求余数,文字不能;小数要保留小数点,整数不需要。格子造多大、放什么,都要提前说清楚。

C++ 最常用的五种基本类型:

类型放什么例子说明
int整数95、-3、0大约能放正负 20 亿以内的整数
double小数(双精度浮点数)1.42、95.5带小数点的数
char单个字符'A'、'好' 不行,只能放英文等单字节字符用单引号
string一串文字"小明"、"Hello"用双引号;需要 #include <string>
bool真假true、false只有两个值,第 4 章大显身手

用五种类型各造一个变量,并显示出来:

cpp
#include <iostream>
#include <string>   // 用 string 必须引入这个库

int main() {
    int score = 95;            // 整数:分数
    double height = 1.42;      // 小数:身高(米)
    char grade = 'A';          // 单字符:等级
    std::string name = "小明"; // 字符串:姓名
    bool passed = true;        // 真假:是否及格

    std::cout << "姓名:" << name << std::endl;
    std::cout << "分数:" << score << std::endl;
    std::cout << "身高:" << height << std::endl;
    std::cout << "等级:" << grade << std::endl;
    std::cout << "及格:" << passed << std::endl;
    return 0;
}

预期输出:

text
姓名:小明
分数:95
身高:1.42
等级:A
及格:1

最后一行的 1 不是写错了。bool 类型的 true 在输出时显示为 1,false 显示为 0。怎么让它显示成"及格/不及格"这样的文字,要等第 4 章学会判断之后。

类型写错会怎样?把整数写进 double 没问题(double x = 5; 会自动变成 5.0),但把小数塞进 int,小数部分会被丢掉;把文字塞进 int,编译直接报错。类型是格子的"形状",形状不对就放不进去。

1.4 【跨语言对照】静态类型 vs 动态类型 ​

这件事本质上解决什么问题 ​

两种语言都要回答同一个问题:一个变量能放哪种数据、什么时候检查放对了没有。答案都是"要检查",分歧只在什么时候检查。

各自怎么做 ​

对比项C++(静态类型)Python(动态类型)
类型何时确定声明时写明,编译时检查赋值时自动确定,运行时才知道
声明写法int score = 95;score = 95
换个类型再赋值不允许,编译报错允许,直接赋新值
错误暴露时机编译期,程序还没运行就报错运行到那一行时才报错

下面是两段等价代码,做同样的事,输出完全一致。

C++:

cpp
#include <iostream>
#include <string>

int main() {
    std::string name = "小明";  // 类型写死在声明里
    int score = 95;
    double height = 1.42;

    std::cout << name << " 考了 " << score << " 分" << std::endl;
    std::cout << "身高是 " << height << " 米" << std::endl;
    return 0;
}

Python(详见《Python 从入门到精通》第 1 章):

python
name = "小明"   # 不用写类型,赋值时自动确定
score = 95
height = 1.42

print(name + " 考了 " + str(score) + " 分")
print("身高是 " + str(height) + " 米")

两段代码的预期输出都是:

text
小明 考了 95 分
身高是 1.42 米

C++ 版里每个变量都标了类型,编译器逐行核对;Python 版里一个类型名都没有,解释器看赋的值自己判断。

为什么设计得不一样 ​

C++ 在编译期查错。程序还没运行,类型错误就被编译器拦下来,错误不会溜进正在运行的程序。同时,编译器提前知道了每个变量的类型,就能生成恰到好处的机器指令,运行时不必再花时间检查类型——这叫"零开销",是 C++ 快的原因之一。

Python 选择灵活。变量不用声明类型,少写很多字;想临时换个用途,直接赋新值就行。写代码快、改代码快,适合快速试验和短脚本。

两种设计各解决一类问题:要极限速度和尽早发现错误,静态类型顺手;要开发效率和灵活,动态类型顺手。本书不评判优劣,后面的章节里两种写法会一直对照出现。

1.5 x = x + 1:数学里不成立的等式 ​

数学课上,方程 x=x+1 是无解的——一个数不可能等于自己加一。程序里这一行不仅成立,而且极其常用:

cpp
#include <iostream>

int main() {
    int x = 5;
    x = x + 1;   // 数学上无解,程序里是动作
    x = x + 1;   // 再来一次

    std::cout << "x 现在是 " << x << std::endl;
    return 0;
}

预期输出:

text
x 现在是 7

原因在于 1.2 节说过的:= 是动作,不是陈述。x = x + 1 读作"先算出右边 x + 1 得 6,再把 6 放进 x"。等号两边地位不同:右边是"算",左边是"装"。计数器、得分、血量,全都靠这个写法一点点变化。第 2 章还会给它一个更短的写法 x++。

1.6 变量与内存:格子占多大地方 ​

声明变量时写的类型,还决定了格子在内存里占多大。内存可以想成一排带编号的小房间,每个房间叫一个字节:

类型大约占用能装的范围(直观理解)
char1 字节一个英文字符
bool1 字节只有 true 和 false
int4 字节约正负 21 亿
double8 字节带小数点,约 15 位有效数字

如果 21 亿还不够用(比如统计全国人口变迁的逐人记录),C++ 准备了更大的 long long,占 8 字节,范围约正负 900 亿亿。写法一样:long long big = 3000000000;。

格子是有边界的。int 装到最大值 2147483647 再加一,会绕回最小负数,这叫溢出。溢出不会报错,只会得到一个荒唐的结果——这是静态类型"快"的代价之一:编译器相信你知道自己在做什么。日常练习的数据远到不了这个边界,知道有这回事即可。

想亲眼看看格子多大,可以用 sizeof 问编译器:sizeof(int) 的结果是 4,意思是 int 占 4 个字节。把第 1 章的程序里加上一行 std::cout << sizeof(int) << std::endl; 就能验证。

1.7 常量:不许动的格子 ​

圆的面积公式是 S=πr2。π 的值是固定的,程序里不希望任何一行不小心改掉它。C++ 用 const 把格子锁上:

cpp
#include <iostream>

int main() {
    const double PI = 3.14159;  // 常量:声明后不许再赋值
    double r = 2.0;

    std::cout << "半径 " << r << " 的圆,面积是 " << PI * r * r << std::endl;
    return 0;
}

预期输出:

text
半径 2 的圆,面积是 12.5664

如果后面写 PI = 3.14;,编译器直接报错——锁住格子的目的正是让错误在编译期暴露。常量名习惯全部大写,一眼能认出"这是不许动的"。Python 没有锁格子的语法,只用全大写约定来表示常量,姊妹册第 1 章有对照说明。

1.8 类型选择小指南 ​

遇到一个新数据,选什么类型?按这张表对号入座:

数据长什么样选什么类型例子
整的数,没有小数点int年龄、分数、血量
带小数点的数double身高、体重、价格
一个字符char等级 'A'、性别代号
一个词、一句话string姓名、地址
只有两个状态bool是否及格、是否在线

两个好习惯,从第一个程序就养成:

一是声明时就赋初值。int score; 声明了一个空格子,里面的值是"垃圾"——上次别的程序用剩下的随机数据。如果忘了赋值就直接使用,结果不可预料。养成 int score = 0; 的习惯,格子从一开始就是干净的。

二是同类型变量可以一行声明:int chinese = 92, math = 98, english = 95;。行数少了,但每个变量依然有自己的类型和初值。

动手实验 ​

实验 1:给游戏角色建档。 声明四个变量:角色名(string)、等级(int)、血量(int)、是否在线(bool),赋上你设计的值,逐行显示出来。先预测 bool 会显示成什么,再运行验证。

💡 查看答案
cpp
#include <iostream>
#include <string>

int main() {
    std::string hero = "小勇士";
    int level = 12;
    int hp = 350;
    bool online = true;

    std::cout << "角色:" << hero << std::endl;
    std::cout << "等级:" << level << std::endl;
    std::cout << "血量:" << hp << std::endl;
    std::cout << "在线:" << online << std::endl;
    return 0;
}

预期输出:

text
角色:小勇士
等级:12
血量:350
在线:1

true 显示为 1,与 1.3 节的观察一致。

实验 2:见证覆盖。 声明 int hp = 100;,然后连续写 hp = 80;、hp = 120;,最后输出。先预测屏幕上出现的是哪个数,再运行。

💡 查看答案
cpp
#include <iostream>

int main() {
    int hp = 100;
    hp = 80;    // 覆盖 100
    hp = 120;   // 覆盖 80

    std::cout << "当前血量:" << hp << std::endl;
    return 0;
}

预期输出:

text
当前血量:120

格子里永远只留最后一次放进去的值。

实验 3:制造类型错误。 写 int score = "九十五";,编译。观察报错信息,然后改成合法的写法。

💡 查看答案

编译报错,信息大致是 error: invalid conversion,意思是文字放不进整数格子。这正是静态类型在编译期拦下错误的例子。两种改法都行:改成整数 int score = 95;,或者改成字符串 std::string score = "九十五";(后者要记得 #include <string>)。