【C++ Primer】第二章：变量和基本类型

最新推荐文章于 2026-06-22 23:20:37 发布
原创 最新推荐文章于 2026-06-22 23:20:37 发布 · 197 阅读 · 2 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#c++ #开发语言 #C++ Primer #算法

这一章是C++的基石，虽然内容比较基础，但极其重要，很多概念会贯穿整个C++学习过程。

2.1 基本内置类型

C++定义了一组基本算术类型：

整数类型

#include <iostream>

int main()
{
    bool flag = true;        // 布尔类型：true 或 false，1字节
    char ch = 'A';           // 字符类型，1字节
    wchar_t wch = L'中';     // 宽字符，用于扩展字符集
    short s = 100;           // 短整型，通常2字节
    int i = 1000;            // 整型，通常4字节
    long l = 100000L;        // 长整型，通常4或8字节
    long long ll = 1000000LL;// 长长长整型，通常8字节
    
    std::cout << "bool: " << flag << std::endl;
    std::cout << "char: " << ch << std::endl;
    std::cout << "int: " << i << std::endl;
    
    return 0;
}

浮点类型

#include <iostream>

int main()
{
    float f = 3.14f;         // 单精度浮点数，通常4字节
    double d = 3.1415926;    // 双精度浮点数，通常8字节
    long double ld = 3.141592653589793238L; // 扩展精度浮点数
    
    std::cout << "float: " << f << std::endl;
    std::cout << "double: " << d << std::endl;
    std::cout << "long double: " << ld << std::endl;
    
    return 0;
}

2.2 类型转换

隐式类型转换

#include <iostream>

int main()
{
    // 布尔转换：非零为true，零为false
    bool b = 3;          // b = true
    bool b2 = 0;         // b2 = false
    
    // 浮点转整数：截断小数部分
    int i = 3.14;        // i = 3
    
    // 整数转浮点：添加小数部分
    double d = 3;        // d = 3.0
    
    // 无符号整数溢出：取模
    unsigned char c = -1; // c = 255 (因为-1 mod 256 = 255)
    
    std::cout << "bool b: " << b << std::endl;
    std::cout << "int i from 3.14: " << i << std::endl;
    std::cout << "unsigned char c from -1: " << (int)c << std::endl;
    
    return 0;
}

显式类型转换

#include <iostream>

int main()
{
    int i = 10;
    double d = 3.14;
    
    // C风格强制转换
    int truncated = (int)d;           // truncated = 3
    
    // 函数风格强制转换
    int truncated2 = int(d);          // truncated2 = 3
    
    // static_cast（C++推荐方式）
    double result = static_cast<double>(i) / 4;  // result = 2.5
    
    std::cout << "truncated: " << truncated << std::endl;
    std::cout << "result: " << result << std::endl;
    
    return 0;
}

2.3 变量声明和定义

#include <iostream>

// 声明（在头文件中常见）
extern int global_var;    // 声明global_var，定义在其他文件

// 定义（分配存储空间）
int global_var = 100;     // 定义global_var

int main()
{
    // 定义并初始化变量
    int units_sold = 0;
    int units_sold2 = {0};    // 列表初始化（C++11）
    int units_sold3{0};       // 列表初始化（C++11）
    int units_sold4(0);       // 直接初始化
    
    // 默认初始化
    std::string empty_str;    // 空字符串
    int local_var;            // 未初始化！值不确定
    
    std::cout << "global_var: " << global_var << std::endl;
    std::cout << "empty_str: '" << empty_str << "'" << std::endl;
    
    // 注意：局部内置类型变量不会自动初始化！
    // std::cout << local_var << std::endl; // 危险！值不确定
    
    return 0;
}

2.4 复合类型

引用（Reference）

#include <iostream>

int main()
{
    int value = 42;
    int &ref = value;        // ref是value的引用（别名）
    
    std::cout << "value: " << value << std::endl;    // 42
    std::cout << "ref: " << ref << std::endl;        // 42
    
    ref = 100;               // 通过引用修改原变量
    std::cout << "value after change: " << value << std::endl;  // 100
    
    // 引用必须在定义时初始化
    // int &ref2;           // 错误！引用必须初始化
    
    // 引用一旦绑定就不能重新绑定到其他对象
    int another = 200;
    // &ref = another;      // 错误！不能重新绑定
    
    return 0;
}

指针（Pointer）

#include <iostream>

int main()
{
    int value = 42;
    int *ptr = &value;       // ptr指向value（存储value的地址）
    
    std::cout << "value: " << value << std::endl;        // 42
    std::cout << "ptr: " << ptr << std::endl;            // 地址值
    std::cout << "*ptr: " << *ptr << std::endl;          // 42（解引用）
    
    *ptr = 100;              // 通过指针修改原变量
    std::cout << "value after change: " << value << std::endl;  // 100
    
    // 指针可以重新指向其他对象
    int another = 200;
    ptr = &another;          // ptr现在指向another
    std::cout << "*ptr after reassign: " << *ptr << std::endl;  // 200
    
    // 空指针的几种表示方法
    int *p1 = nullptr;       // C++11推荐（最安全）
    int *p2 = 0;             // 传统方式
    int *p3 = NULL;          // C传统方式（在cstdlib中定义）
    
    return 0;
}

2.5 const限定符

基本const用法

#include <iostream>

int main()
{
    const int bufSize = 512;    // 定义常量
    // bufSize = 1024;          // 错误！不能修改const变量
    
    const int i = get_size();   // 运行时初始化
    const int j = 42;           // 编译时初始化
    const int k;                // 错误！const变量必须初始化
    
    // const对象默认只在文件内有效
    // 如果想在多个文件间共享const对象，需要在定义和声明前都加extern
    return 0;
}

const与引用（常量引用）

#include <iostream>

int main()
{
    int i = 42;
    const int &r1 = i;        // 正确：允许将const int&绑定到普通int上
    const int &r2 = 42;       // 正确：常量引用可以绑定到字面值
    const int &r3 = r1 * 2;   // 正确：常量引用可以绑定到表达式结果
    
    // int &r4 = 42;          // 错误：普通引用不能绑定到字面值
    
    std::cout << "r1: " << r1 << std::endl;
    std::cout << "r2: " << r2 << std::endl;
    std::cout << "r3: " << r3 << std::endl;
    
    return 0;
}

const与指针

#include <iostream>

int main()
{
    int value = 42;
    int another = 100;
    
    // 指向常量的指针（pointer to const）
    const int *ptr1 = &value;  // ptr1指向一个常量
    // *ptr1 = 50;             // 错误！不能通过ptr1修改value
    ptr1 = &another;           // 正确！ptr1可以指向其他对象
    
    // 常量指针（const pointer）
    int *const ptr2 = &value;  // ptr2本身是常量
    *ptr2 = 50;                // 正确！可以通过ptr2修改value
    // ptr2 = &another;        // 错误！ptr2不能指向其他对象
    
    // 指向常量的常量指针
    const int *const ptr3 = &value;  // ptr3本身是常量，指向的对象也是常量
    // *ptr3 = 50;             // 错误！
    // ptr3 = &another;        // 错误！
    
    std::cout << "value: " << value << std::endl;  // 50
    
    return 0;
}

2.6 类型别名与auto

类型别名

#include <iostream>

// 使用typedef创建类型别名
typedef double wages;         // wages是double的别名
typedef wages base, *p;       // base是double的别名，p是double*的别名

// 使用using创建类型别名（C++11）
using salary = double;        // salary是double的别名

int main()
{
    wages hourly = 25.5;      // 相当于 double hourly = 25.5;
    salary monthly = 5000.0;  // 相当于 double monthly = 5000.0;
    
    std::cout << "时薪: " << hourly << std::endl;
    std::cout << "月薪: " << monthly << std::endl;
    
    return 0;
}

auto类型说明符（C++11）

#include <iostream>
#include <typeinfo>

int main()
{
    int i = 42;
    const int ci = i;
    
    // auto让编译器自动推断类型
    auto a = i;               // a是int
    auto b = ci;              // b是int（顶层const被忽略）
    auto c = &i;              // c是int*
    auto d = &ci;             // d是const int*（底层const保留）
    
    // 引用和auto
    auto &e = ci;             // e是const int&
    // auto &f = 42;          // 错误！不能为非常量引用绑定字面值
    const auto &g = 42;       // 正确！可以为常量引用绑定字面值
    
    std::cout << "type of a: " << typeid(a).name() << std::endl;
    std::cout << "type of d: " << typeid(d).name() << std::endl;
    
    return 0;
}

📝 第二章关键要点总结

  1. 内置类型选择：

    • 算术运算：用int或double
    • 明确知道不可能为负：用unsigned
    • 字符：用char
    • 布尔：用bool

  2. 引用vs指针：

    • 引用：别名，必须初始化，不能重新绑定
    • 指针：存储地址，可以重新指向，可以为空

  3. const用法：

    • const int*：指向常量的指针（底层const）
    • int* const：常量指针（顶层const）
    • const int&：常量引用

  4. 初始化：

    • 局部内置类型变量不会自动初始化
    • 类类型变量有默认初始化
    • 推荐使用列表初始化{}

这一章的概念非常重要，特别是指针、引用和const，它们会在整个C++学习中反复出现。如果有任何不清楚的地方，建议多写代码实验！

C++Primer第二章：变量和基本类型
qq_46514141的博客
09-26 2123
C++11新标准规定，可以为类（或结构体）内的数据成员提供一个类内初始值。没有初始值的成员将被默认初始化。为了确保各个文件中的类的定义一致，类通常被定义在头文件中，而且类所在头文件的名字应与类的名字一样。确保头文件多次包含仍能安全工作的常用技术是预处理器，#include是一项预处理器功能，当预处理器看到#include标志时会用指定的头文件的内容代替#include。还有一项预处理器的功能是头文件保护符，头文件保护符依赖于预处理变量，预处理变量有两种状态：已定义和未定义。
C++ Primer 总结索引 | 第二章：变量和基本类型
AsherGu的博客
12-07 1196
基本内置类型：算术类型，类型转换，字面值常量；变量：变量的定义，变量声明和定义的关系，标识符，名字的作用域；复合类型：引用，指针，复合类型的声明；const限定符：const的引用，指针和const，顶层const，常量表达式和constexpr；处理类型：类型别名，auto类型说明符，decltype类型指示符
我的《C++ primer》笔记第二章：变量和基本类型
皮卡丘LIII的博客
05-12 587
文章目录写在前面2.1 基本内置类型2.1.1 算数类型带符号类型和无符号类型该如何在编程中选择我们要用的类型2.1.2 类型转换含无符号类型的表达式2.1.3 字面值常量转移序列2.2 变量2.2.1 变量定义初始化默认初始化2.2.2变量声明和定义的关系2.2.3 标识符变量命名规范2.2.4 名字的作用域嵌套作用域2.3 复合类型2.3.1 引用引用的定义 写在前面 今天给大家讲述的是C++内置类型，并让大家理解下C++是如何支持更复杂的数据类型的。 2.1 基本内置类型 2.1.1 算数类型 算数类
C++ Primer：第二章-变量和基本类型
dadaima_sama的博客
04-05 427
2.1 基本内置类型 2.1.1 基本数据类型：算术类型和空类型(void) 算术类型：整型和浮点型 表2.1 C++：算术类型 类型 含义 最小尺寸 bool bool类型 未定义 char 字符 8位 wchat_t 宽字符 16位 char16_t Unicode字符 32位 char32_t Un...
C++ Primer第二章：变量和基本类型
neetneves的博客
11-29 155
一、预处理器概览确保头文件多次包含仍能安全工作的常用技术是预处理器，它由C++语言从C语言继承而来。预处理器是在编译之前执行的一段程序，可以部分地改变程序。当预处理器看到#include标记时就会用指定的头文件的内容代替#include#define指令把一个名字设定为预处理变量#ifdef当且仅当变量已定义时为真，#ifndef反之在头文件保护符中，一旦#ifdef或#ifndef的检查结果为真，则执行后续操作直至遇到#endif为止。
c++primer第二章：变量和基本类型
qq_50271250的博客
08-30 231
类型转换 当赋给一个无符号类型是一个超出其类型范围的值时，结果是初始值对无符号类型表示数值总数取模后的余数
C++primer第二章学习及答案：变量和基本类型
weixin_44623330的博客
11-22 504
C++primer第二章总结与答案
[C++primer笔记]第二章：变量和基本类型
qq_42523037的博客
10-09 227
第二章 变量和基本类型 2.1基本内置类型 2.1.1算术类型 包括整型和浮点型，C++11规定char最小8位，int最小16位，long long最小64 位，允许编译器赋予它们更大的尺寸如float32位。其中，char对应一个机器字节。 可寻址的最小内存块：字节（byte),有8位. 一个字（word)通常有4个字节，32位。 signed char理论上表示-128-127的值。 当知晓数值不可能为负数的时候，用unsigned无符号类型。 2.1.2类型转换（convert) bool b =
【C++】《C++ Primer》第二章：变量和基本类型（ 知识点总结）
风的博客
10-25 1400
《C++ Primer》第二章的知识点总结，通过例子来讲解知识点。
c++Primer——第二章：变量和基本类型
judith的博客
07-19 253
1、带符号类型和无符号类型同时出现在表达式中时，带符号类型会自动转换为无符号类型。 int a = -1; unsigned b = 1; cout << a*b << endl; 我的环境里输出为：4294967295 2、字符和字符串字面值 'a' 字符字面值，"hello world" 字符串字面值。 字符串字面值的类型实际上是由常量字符构成的数组，编译器在每个字符串的结尾添加一个空字符('\0')，因此字符串字面值的长度要比实际内容多1。如：'A'表示单独的字符A
《c++ Primer中文版》第二章：变量和基本类型
qq_41543888的博客
10-13 800
目录 第2章 变量和基本类型 2.1基本内置类型 2.1.1算术类型arithmetic type 算术类型分为两类: 整型(integral type,包括字符和布尔类型在内)和浮点型。​ 2.1.2类型转换​ 2.1.3字面量值​ 2.2变量 2.2.1变量定义 2.2.2变量声明和定义的关系 2.2.3标识符 2.2.4名字的作用域 2.3复合类型 2.3.1引...
C++ primer第五版学习记录：第二章变量和基本类型
Zhongai0049的博客
07-05 418
C++primer第五版第二章知识总结
C++ Primer : 第二章：变量和基本类型(1)
Mccree的博客专栏
05-11 800
变量和基本类型之第一篇：基本内置类型和变量
C++ primer第二章：变量和基本类型
year_120的专栏
09-16 536
一、数据类型： 1：基本类型 整型（short int ,int, long int）、字符型（char）、浮点型（float, double, long double）、布尔型（bool）、空类型（void） 2：非基本类型 枚举类型（enum）、数组类型（type[ ]）
《C++primer》读书笔记---第二章：变量和基本类型
m0_74384466的博客
05-11 884
int a = 0;int a{0};int a(0);用花括号初始化是C++11的新标准，这种方式成为列表初始化。注意：初始化不是赋值，初始化的含义是创建变量时赋予一个初始值，而赋值的含义是把对象的当前值擦除，而以一个新值来替代。//声明i而非定义iint j;//声明并定义i谨记使用struct创建一个结构体时，务必在{}后加上分号。
菜狗的C++ primer读书笔记：第二章 变量和基本类型
Egoist1945的博客
02-19 504
基本内置类型和变量 1.可寻址的最小内存块称为“字节”，存储的基本单元称为“字（word）”，字通常由一个或多个字节组成，大多数机器字节由8比特构成，字则由32或64比特构成。 2.无符号类型仅能表示大于等于0的值。 3.与整型不同，字符型被分为了三种：char    signed char    unsigned char 尽管有三种但是表现形式只有两种，类型char会表现为上述两种形式中
【Primer C++】第二章：变量和基本类型
itaiit（https://itaiit.top）
11-23 263
使用列表初始化初始化内置类型时，若存在丢失信息的风险，编译器将会报错： long double ld = 3.1415926536; int b = { ld }; 默认初始化 变量的默认值与变量类型和变量所处的位置有关， 定义于任何函数之外的变量被初始化为0； 定义在函数体内部的内置类型变量将不被初始化； 变量的声明和定义 变量的声明： extern int i; 变量的声明则是：在变...
C++Primer 读书笔记——第二章：变量和基本类型（一）
m0_53316604的博客
07-03 340
C++Primer 读书笔记，一个小白的自留地，欢迎大佬批评指正~ 含有无符号类型的表达式 2.1.3 字面值常量 转义序列指定字面值的类型 2.2 变量2.2.1 变量定义 默认初始化2.2.2 变量声明和定义的关系2.2.3 标识符 2.2.4 名字的作用域嵌套的作用域​​​​​​​ 2.3.1 引用引用本身不是对象，所以不能定义引用的引用 2.3.2 指针 获取对象的地址 访问无效指针的后果无法预...............
《C++primer(第五版)》学习之路-第二章：变量和基本类型
月下的寂寞肖邦
09-01 1204
2.1 基本内置类型 1.算术类型分为两类：整型（integral type，包括字符和布尔类型在内）和浮点型。 布尔类型（bool）的取值是真（true）或者假（false）。 2.除去布尔型和扩展的字符型之外，其他整型可以划分为带符号的（signed）和无符号的（unsigned）两种。带符号类型可以表示正数、负数或0，无符号类型则仅能表示大于等于0的值。 类型
C语言箭头操作符(-＞)完全教程：用法与实例
最新发布
2601_95164578的博客
06-22 198
大家好！在这篇文章中，我们将着重介绍C语言中的箭头运算符。C语言包含各种运算符来处理和操作数据记录，其中之一就是箭头运算符。那么，让我们开始吧！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值