没有合适的资源?快使用搜索试试~ 我知道了~
CPlusPlus编程语言基础1
试读
104页
需积分: 0 0 下载量 59 浏览量
更新于2022-08-08
收藏 107KB DOCX 举报
在C++编程语言中,基础是构建一切复杂程序的基石。本篇文章将深入探讨C++中的基本概念,包括变量、常量以及数据类型。
1. 变量
变量是存储数据的容器,它在程序中用于保存各种信息。在C++中,变量有以下几个关键组成部分:
1.1. 标识符:标识符是用来命名变量、函数、类等的符号。它们必须遵循一定的规则,如不能以数字开头,不能包含特殊字符(除了下划线 `_`),并且不能与关键字重名。良好的命名规范可以提高代码的可读性。
1.1.1. 声明与定义:声明告诉编译器变量的存在和它的类型,而定义则是实际为变量分配内存并初始化。在C++中,声明和定义通常一起进行,例如:
```cpp
int age; // 声明并定义一个整型变量age
```
1.1.2. 初始化:初始化是在声明变量时为其赋予初始值。例如:
```cpp
int age = 25; // 初始化age为25
```
1.1.3. 存储信息的基本属性:每个变量都有其存储类别,如自动(局部)、静态、extern(外部)或寄存器。这些类别影响变量的生命周期和作用域。
2. 常量
常量是不可更改的值,它们在程序执行过程中保持不变。
2.1. 字面值常量:如数字(如123)、字符(如'c')和字符串(如"Hello")等直接写在代码中的值。
2.2. 常量左值声明:C++中的常量左值不能被修改,如const int age = 25;尝试改变age的值会导致编译错误。
2.3. 枚举(enum):枚举是一种用户自定义的常量集合,方便表示一组相关的整数值。例如:
```cpp
enum Color { Red, Green, Blue };
```
2.4. 符号常量:使用const关键字定义的常量,如:
```cpp
const int MAX_SIZE = 100;
```
3. 数据类型
数据类型是C++中用来定义变量可以存储的数据种类的工具。
3.1. 类型:C++提供了多种内置数据类型,如int、char、float、double等,以及用户自定义类型(如类)。
3.1.1. 类型(程序开发语言):数据类型决定了变量能够存储的值的范围和操作方式。
3.2. 分类:数据类型主要分为两大类:
3.2.1. 基本类型:包括整型(int、short、long等)、浮点型(float、double)、字符型(char)和布尔型(bool)。
3.2.2. 复合类型:如数组、结构体、类、指针等,它们是由基本类型组合而成的更复杂的类型。
理解这些基本概念对于学习C++编程至关重要。掌握变量、常量和数据类型的使用,是编写有效、高效和可靠的C++代码的基础。在实际编程中,合理地运用这些知识,可以帮助我们更好地管理和控制程序中的数据,实现各种复杂的逻辑和算法。
CPlusPlus 编程语言基础
1. 变量与常量 ..................................................................................................................1
1.1. 变量.......................................................................................................................1
1.1.1. 标识符 ...........................................................................................................1
1.1.2. 声明与定义 ...................................................................................................1
1.1.3. 初始化 ...........................................................................................................1
1.1.4. 存储信息的基本属性 ...................................................................................3
1.2. 常量.......................................................................................................................3
1.2.1. 字面值常量 ...................................................................................................3
1.2.2. 常量左值声明 ...............................................................................................4
1.2.3. 枚举 ...............................................................................................................4
1.2.4. 符号常量 .......................................................................................................5
2. 数据类型 ......................................................................................................................5
2.1. 类型.......................................................................................................................5
2.1.1. 类型 (程序开发语言) .............................................................................5
2.2. 分类.......................................................................................................................5
2.2.1. 基本类型 .......................................................................................................5
2.2.2. 复合类型 .......................................................................................................6
2.2.3. 自定义类型 .................................................................................................12
2.3. 类型转换.............................................................................................................13
2.3.1. 按是否隐式分类 .........................................................................................13
2.3.2. 按转换前后的类型 .....................................................................................14
2.4. 处理类型.............................................................................................................14
2.4.1. 类型别名 .....................................................................................................14
2.4.2. auto 类型说明符.........................................................................................15
2.4.3. decltype 类型指示符 .................................................................................15
3. 表达式与语句 ............................................................................................................15
3.1. 表达式.................................................................................................................15
3.1.1. 值 .................................................................................................................15
3.1.2. 运算符 .........................................................................................................16
3.1.3. 表达式分类 .................................................................................................19
3.2. 语句.....................................................................................................................20
3.2.1. 控制流 .........................................................................................................20
3.2.2. 空语句 .........................................................................................................20
3.2.3. 复合语句(块) .........................................................................................20
3.2.4. 分类 .............................................................................................................20
3.2.5. 语句作用域 .................................................................................................22
4. 函数 ............................................................................................................................22
4.1. 函数基础.............................................................................................................22
4.1.1. 概念 .............................................................................................................22
4.1.2. 函数参数 .....................................................................................................23
4.1.3. 返回类型 .....................................................................................................25
4.2. 深入.....................................................................................................................25
4.2.1. 函数重载(函数多态) .............................................................................26
4.2.2. 函数匹配 .....................................................................................................26
4.2.3. 特殊用途语言特性 .....................................................................................26
4.2.4. 函数指针 .....................................................................................................27
4.2.5. 函数模板 .....................................................................................................27
4.2.6. 可变参数模板 .............................................................................................28
4.2.7. 函数调用的实现 .........................................................................................28
5. 类 ................................................................................................................................28
5.1. 抽象和类.............................................................................................................28
5.1.1. 抽象是什么 .................................................................................................29
5.1.2. 类是什么 .....................................................................................................29
5.1.3. 抽象数据类型(ADT) .............................................................................29
5.2. 定义类.................................................................................................................29
5.2.1. 目标:使得使用类与使用基本的内置类型(如 int)尽可能相同 ........29
5.2.2. 关键字 class ...............................................................................................29
5.2.3. 类规范 .........................................................................................................29
5.2.4. 类设计步骤 .................................................................................................30
5.2.5. 定义类相关的非成员函数 .........................................................................32
5.3. 使用简单的类.....................................................................................................32
5.3.1. 创建对象(类的实例) .............................................................................32
5.3.2. 使用类函数(公有接口) .........................................................................32
5.4. 类的构造函数和析构函数.................................................................................32
5.4.1. 构造函数 .....................................................................................................32
5.4.2. 析构函数 .....................................................................................................33
5.5. 类的其它特性.....................................................................................................33
5.5.1. 类成员再探 .................................................................................................33
5.5.2. 类类型 .........................................................................................................33
5.5.3. 友元再探 .....................................................................................................34
5.6. 类作用域.............................................................................................................34
5.6.1. 类作用域和成员函数 .................................................................................34
5.6.2. 作用域为类的常量 .....................................................................................34
5.6.3. 作用域内枚举 .............................................................................................34
5.6.4. 作用域和定义在类外部的成员 .................................................................34
5.6.5. 名字查找与类的作用域 .............................................................................35
5.7. 构造函数再探.....................................................................................................35
5.7.1. 构造函数初始值列表 .................................................................................35
5.7.2. 委托构造函数 .............................................................................................35
5.7.3. 默认构造函数的作用 .................................................................................35
5.7.4. 隐式的类类型转换 .....................................................................................35
5.7.5. 聚合类 .........................................................................................................36
5.7.6. 字面值常量类 .............................................................................................36
5.8. 类的静态成员.....................................................................................................36
5.8.1. 声明静态成员 .............................................................................................36
5.8.2. 使用类的静态成员 .....................................................................................36
5.8.3. 定义静态成员 .............................................................................................36
5.8.4. 静态函数的类内初始化 .............................................................................36
5.8.5. 静态成员能用于某些场景,而普通成员不能 .........................................36
5.9. 使用类.................................................................................................................36
5.9.1. 运算符重载 .................................................................................................36
5.9.2. 简单友元 .....................................................................................................36
5.9.3. 类的自动转换和强制类型转换 .................................................................36
6. C++标准库 ................................................................................................................37
6.1. 常用库概览.........................................................................................................37
6.1.1. 语言支持库 .................................................................................................37
6.1.2. 输入/输出库 ................................................................................................37
6.1.3. 字符串库 .....................................................................................................37
6.1.4. 容器库 .........................................................................................................37
6.1.5. 迭代器库 .....................................................................................................37
6.1.6. 算法库 .........................................................................................................37
6.1.7. 常结合使用 .................................................................................................37
6.1.8. 数值库 .........................................................................................................37
6.2. IO 库 ...................................................................................................................37
6.2.1. 输入输出和文件 .........................................................................................37
6.2.2. IO 类 ............................................................................................................42
6.2.3. 文件输入和输出 .........................................................................................44
6.2.4. string 流.......................................................................................................45
6.3. 动态内存.............................................................................................................46
6.3.1. 智能指针 .....................................................................................................46
6.3.2. 动态数组 .....................................................................................................48
6.3.3. 内存模型 .....................................................................................................48
7. 命名空间 ....................................................................................................................52
7.1. 传统 C++命名空间 ............................................................................................52
7.1.1. 声明区域 .....................................................................................................52
7.1.2. 潜在作用域 .................................................................................................52
7.1.3. 作用域 .........................................................................................................52
7.2. 新的命名空间特性.............................................................................................53
7.2.1. std ................................................................................................................53
7.2.2. 分类 .............................................................................................................53
7.2.3. 特性 .............................................................................................................53
7.2.4. 访问命名空间中名称的方法 .....................................................................54
7.3. 使用命名空间的指导原则.................................................................................54
8. string 类和 STL.........................................................................................................54
8.1. 标准模板库 STL 概述 .......................................................................................54
8.1.1. STL 术语 .....................................................................................................54
8.1.2. STL 组成:容器(containers)、迭代器(iterators)、空间配置器(allocator)、
适配器(adapters)、算法(algorithms)、函数符(functors)六个部分 ...................55
8.2. STL 泛型编程 ....................................................................................................55
8.2.1. 容器 .............................................................................................................55
8.2.2. 迭代器 .........................................................................................................60
8.2.3. 适配器 .........................................................................................................62
8.2.4. 泛型算法 .....................................................................................................62
8.3. string 类和 STL 库全面总结.............................................................................66
8.3.1. 附录 F 模板类 string .................................................................................66
8.3.2. 附录 G 标准模板库方法和函数 STL.......................................................66
9. 面相对象 ....................................................................................................................66
9.1. 对象和类.............................................................................................................66
9.1.1. 对象是什么 .................................................................................................66
9.1.2. 过程性编程和面向对象编程 .....................................................................66
9.2. 嵌套类.................................................................................................................66
9.2.1. 嵌套类和访问权限 .....................................................................................66
9.2.2. 模板中的嵌套 .............................................................................................66
9.3. 类和动态内存分配.............................................................................................66
9.3.1. 动态内存和类 .............................................................................................66
9.3.2. 改进后的新 String 类.................................................................................68
9.3.3. 在构造函数中使用 new 时的注意事项 ....................................................68
9.3.4. 有关返回对象的说明 .................................................................................69
9.3.5. 使用指向对象的指针 .................................................................................69
9.3.6. 模拟队列 .....................................................................................................69
9.4. 类继承.................................................................................................................69
9.4.1. 一个简单的基类 .........................................................................................70
9.4.2. 继承:is-a 关系..........................................................................................70
9.4.3. 多态公有继承 .............................................................................................71
9.4.4. 静态联编和动态联编 .................................................................................72
9.4.5. 访问控制:protected.................................................................................73
9.4.6. 抽象基类 .....................................................................................................74
9.4.7. 继承和动态内存分配 .................................................................................74
9.4.8. 类设计回顾 .................................................................................................74
10. C++中的代码重用 ....................................................................................................76
10.1. 包含对象成员的类.............................................................................................76
10.1.1. 包含(也称为:组合、层次化) .............................................................76
10.1.2. 对比 .............................................................................................................76
10.1.3. 接口:这里的接口是狭义上的接口,特指被 public 访问控制符包含
的类成员,包括公有的数据成员和公有的函数成员。 .......................................76
10.1.4. 初始化被包含的对象(成员对象) .........................................................76
10.1.5. 使用被包含对象的接口 .............................................................................76
10.2. 私有继承.............................................................................................................77
10.2.1. 建立 has-a 关系 .........................................................................................77
10.2.2. 初始化基类组件 .........................................................................................77
10.2.3. 访问基类的方法 .........................................................................................77
10.2.4. 访问基类的对象 .........................................................................................77
10.2.5. 访问基类的友元函数 .................................................................................77
10.2.6. 保护继承 .....................................................................................................77
10.2.7. 使用 using 重新定义访问权限..................................................................77
10.3. 多重继承.............................................................................................................77
10.4. 类模板.................................................................................................................77
10.4.1. 定义模板类 .................................................................................................77
10.4.2. 使用模板类 .................................................................................................78
10.4.3. 数组模板示例和非类型参数 .....................................................................78
10.4.4. 模板多功能性 .............................................................................................78
10.4.5. 模板具体化 .................................................................................................78
10.4.6. 成员模板 .....................................................................................................79
10.4.7. 将模板用作参数 .........................................................................................79
10.4.8. 模板和友元 .................................................................................................79
10.4.9. 模板别名 .....................................................................................................79
11. 异常 ............................................................................................................................79
11.1. 异常.....................................................................................................................79
11.1.1. 调用 abort( ) ...............................................................................................79
11.1.2. 返回错误码 .................................................................................................79
11.1.3. 异常机制 .....................................................................................................79
11.1.4. 将对象用作异常类型 .................................................................................79
11.1.5. 异常规范 .....................................................................................................79
11.1.6. 栈解退 .........................................................................................................79
11.1.7. 其它异常特性 .............................................................................................80
11.1.8. exception 类 ...............................................................................................80
11.1.9. 异常、类和继承 .........................................................................................81
11.1.10..........................................................................未捕获异常和意外异常 81
11.1.11. ..............................................................................................注意事项 81
11.2. 运行阶段类型识别(RTTI)............................................................................81
11.2.1. RTTI 的用途 ...............................................................................................81
11.2.2. RTTI 的工作原理 .......................................................................................81
11.3. 类型转换运算符.................................................................................................82
12. 补充专题 ....................................................................................................................82
12.1. C++语言补充基本概念 .....................................................................................82
12.1.1. C++基本概念..............................................................................................82
12.1.2. 源文件 .........................................................................................................82
12.1.3. 标准库 .........................................................................................................82
12.1.4. 字面值 .........................................................................................................82
12.1.5. 对象 .............................................................................................................82
12.1.6. POD 类型....................................................................................................82
12.1.7. 缓冲区溢出 .................................................................................................82
12.2. 关键字专题.........................................................................................................82
12.2.1. 关键字 const...............................................................................................82
12.3. 计算机相关概念.................................................................................................83
12.3.1. 统一建模语言(UML).............................................................................83
12.3.2. 接口 .............................................................................................................84
剩余103页未读,继续阅读
资源推荐
资源评论
162 浏览量
176 浏览量
174 浏览量
128 浏览量
5星 · 资源好评率100%
164 浏览量
150 浏览量
2020-07-22 上传
169 浏览量
141 浏览量
160 浏览量
2010-04-03 上传
2017-07-13 上传
资源评论
啊看看
- 粉丝: 37
- 资源: 323
上传资源 快速赚钱
- 我的内容管理 展开
- 我的资源 快来上传第一个资源
- 我的收益 登录查看自己的收益
- 我的积分 登录查看自己的积分
- 我的C币 登录后查看C币余额
- 我的收藏
- 我的下载
- 下载帮助
最新资源
- VB无纸化在线考试系统(源代码+系统)(20241j).7z
- VB文档管理信息系统设计(源代码+系统+答辩PPT)(2024sd).7z
- vb物流管理系统设计(论文+源代码)(20245p).7z
- vb小区物业管理系统(源代码+论文)(2024k0).7z
- vb小区物业管理系统设计(论文+源代码)(20246b).7z
- vb校园网交换机节点管理系统(源代码+论文+开题报告)(2024z4).7z
- vb小型企业工资管理系统设计(论文+源代码)(20241c).7z
- VB校园一卡通管理系统(源代码+系统)(20247u).7z
- VB新生报到注册系统设计(论文+源代码)(2024b9).7z
- vb试题库自动组卷系统(源代码+论文)(2024nc).7z
- VB试题库系统设计(源代码+系统+答辩PPT)(20243a).7z
- VB售楼管理系统设计(论文+源代码+开题报告)(2024ge).7z
- VB试题库自动组卷系统设计(论文+源代码)(2024mh).7z
- vb数控加工技术教学素材资源库的构建(源代码+论文)(202422).7z
- vb题库管理系统设计(源代码+论文)(2024it).7z
- VB停车场管理系统设计(源代码+系统+开题报告)(2024xr).7z
安全验证
文档复制为VIP权益,开通VIP直接复制
信息提交成功