思维导图备注

零基础学C++ 第2版-杨彦强 & 刘袁红 & 王浩
首页 收藏书籍 阅读记录
  • 书签 我的书签
  • 添加书签 添加书签 移除书签 移除书签

8.5.2　构造函数可以有参数

浏览 1 扫码
  • 小字体
  • 中字体
  • 大字体
2022-02-19 20:54:54
请 登录 再阅读
上一篇:
下一篇:
  • 书签
  • 添加书签 移除书签
  • 前言
  • 第一篇　C++基础
    • 1.1.2　计算机软件
    • 1.2　程序设计语言
      • 1.2.2　汇编语言
      • 1.2.3　高级语言
      • 1.2.4　数据结构和算法
      • 1.2.5　面向过程的程序设计（POP）
      • 1.2.6　面向对象的程序设计（OOP）
    • 第2章　开始C++之旅
      • 2.1.2　编译预处理与新旧标准
      • 2.2　变量与基本类型
        • 2.2.2　整型
        • 2.2.3　浮点型
        • 2.2.4　基本字符型
        • 2.2.5　宽字符型
        • 2.2.6　布尔型
      • 2.1.3　主函数
      • 2.3　常量
        • 2.3.2　字符型常量
        • 2.3.3　字符串常量
        • 2.3.4　符号常量
        • 2.3.5　枚举常量
      • 2.1.4　名称空间
      • 2.4　运算符与表达式
        • 2.4.2　逻辑运算
        • 2.4.3　短路表达式
        • 2.4.4　关系运算
        • 2.4.5　大有文章：变量是否为“0”
        • 2.4.6　条件运算
        • 2.4.7　位运算
        • 2.4.8　赋值运算
        • 2.4.9　++和--
        • 2.4.10　逗号表达式
        • 2.4.11　sizeof运算符与sizeof表达式
        • 2.4.12　运算符的优先级和结合性
      • 2.1.5　C++语素
      • 2.5　类型转换
        • 2.5.2　表达式中的转换
        • 2.5.3　强制类型转换
        • 2.5.4　函数调用和传递参数时的类型转换
      • 2.6　流程控制语句
        • 2.6.2　switch结构
        • 2.6.3　if……else……结构和switch结构的比较
        • 2.6.4　for循环结构
        • 2.6.5　for循环结构嵌套
        • 2.6.6　while循环结构
        • 2.6.7　do……while循环结构
        • 2.6.8　循环语句的效率
        • 2.6.9　流程转向控制语句之break
        • 2.6.10　流程转向控制语句之continue
        • 2.6.11　自由转向语句goto
        • 2.6.12　程序中止函数exit（）
      • 2.7　小结
      • 2.8　上机实践习题
    • 1.3　C++简介
      • 1.3.2　C++语言特点
      • 1.3.3　C++程序开发基本过程
    • 1.4　C++开发环境的搭建
      • 1.4.2　开发步骤
    • 1.5　第一个C++程序
    • 1.6　小结
    • 1.7　上机实践习题
  • 第二篇　C++过程开发
    • 3.2　一维数组
      • 3.2.2　初始化一维数组
      • 3.2.3　一维数组应用举例
      • 3.2.4　数组操作注意事项
    • 第4章　指针和引用
      • 4.1.2　初始化指针变量
      • 4.2　指针的运算
        • 4.2.2　同类型指针间的比较
        • 4.2.3　同类型指针相减
      • 4.1.3　指向指针的指针
      • 4.3　动态内存分配
        • 4.3.2　使用delete动态释放及动态申请的内存
        • 4.3.3　使用new申请动态数组
        • 4.3.4　不要使用或释放已经释放的内存块
        • 4.3.5　使用malloc和free动态申请内存
        • 4.3.6　动态内存申请并不一定能成功
      • 4.1.4　指针赋值
      • 4.4　指针和const
        • 4.4.2　禁止改写间接引用
        • 4.4.3　既禁止改写指针，又禁止改写间接引用
      • 4.5　指针与数组
        • 4.5.2　数组元素的指针形式
        • 4.5.3　指向数组的指针
        • 4.5.4　指针数组
      • 4.6　引用
        • 4.6.2　引用的特点
        • 4.6.3　引用的使用限制
        • 4.6.4　其他要说明的问题
      • 4.7　小结
      • 4.8　上机实践习题
    • 3.3　C风格字符串
      • 3.3.2　字符数组的cin和cout
      • 3.3.3　get（）函数和getline（）函数
      • 3.3.4　cin与get（）/getline（）函数的搭配问题
      • 3.3.5　访问C风格字符串中的某个元素
      • 3.3.6　C风格字符串处理函数
    • 第5章　结构、共用体和链表
      • 5.1.2　结构变量的声明和使用
      • 5.2　共用体
        • 5.2.2　共用体和结构的区别
        • 5.2.3　共用体变量的声明和初始化
        • 5.2.4　共用体使用举例
        • 5.2.5　共用体的sizeof
      • 5.1.3　结构变量的初始化
      • 5.3　结构数组和共用体数组
        • 5.3.2　共用体数组的声明和初始化
      • 5.1.4　结构变量间是否可以相互赋值
      • 5.4　指向结构的指针
        • 5.4.2　结构指针的初始化
        • 5.4.3　使用指针访问结构成员
      • 5.1.5　结构体变量的sizeof
      • 5.5　链表
        • 5.5.2　创建链表
        • 5.5.3　链表与数组的区别
        • 5.5.4　链表的遍历和查找
        • 5.5.5　链表的插入和删除
      • 5.6　小结
      • 5.7　上机实践习题
    • 3.4　多维数组
      • 3.4.2　初始化多维数组
      • 3.4.3　多维数组应用举例
      • 3.4.4　多维数组在内存中是如何排列元素的
    • 第6章　用函数合理组织程序
      • 6.1.2　抽象和封装
      • 6.2　函数定义
        • 6.2.2　函数体
        • 6.2.3　函数定义补充说明
      • 6.1.3　实现一个函数
      • 6.3　函数声明
        • 6.3.2　如何声明一个函数
        • 6.3.3　分割程序文件
      • 6.4　函数调用
        • 6.4.2　参数类型转换
        • 6.4.3　值传递
        • 6.4.4　指针传递
        • 6.4.5　引用传递
        • 6.4.6　对3种传递的补充
        • 6.4.7　默认参数调用
        • 6.4.8　inline函数
      • 6.5　递归
      • 6.6　函数的重载
        • 6.6.2　如何实现函数重载
        • 6.6.3　陷阱：隐式转换导致重载函数出现二义性
      • 6.7　C++如何使用内存
        • 6.7.2　静态存储（编译器预分配）
      • 6.8　作用域与可见域
        • 6.8.2　可见域
        • 6.8.3　函数的作用域和可见域
      • 6.9　小结
      • 6.10　上机实践习题
    • 3.5　小结
    • 第7章　关于函数的高级专题
      • 7.1.2　野指针
      • 7.2　重申：函数参数传递和返回机制
        • 7.2.2　函数返回时的“副本”
      • 7.1.3　试图修改常量
      • 7.3　函数与指针
        • 7.3.2　typedef
        • 7.3.3　通过函数指针将函数作为另一个函数的参数
        • 7.3.4　函数指针数组
        • 7.3.5　返回函数指针的函数
        • 7.3.6　带参主函数
      • 7.1.4　用错sizeof
      • 7.4　函数与数组
        • 7.4.2　通过指针得到多于1个的回传值
      • 7.1.5　内存越界访问
      • 7.5　函数与结构体、共用体及类对象
        • 7.5.2　3种返回机制
      • 7.1.6　变量的初始化
      • 7.6　函数编写的建议
        • 7.6.2　检查输入参数的有效性
        • 7.6.3　函数返回类型的判断
      • 7.7　小结
      • 7.8　上机实践习题
    • 3.6　上机实践习题
  • 第三篇　面向对象的C++
    • 8.1.2　类是分层的
    • 8.2　C++类的定义
      • 8.2.2　类定义示例
      • 8.2.3　class和struct
    • 第9章　关于对象的高级专题
      • 9.2　类定义的作用域与可见域
      • 9.3　对象的生存期、作用域和可见域
        • 9.3.2　对象内存的释放与堆内存
      • 9.4　友元
        • 9.4.2　友元的成员函数
        • 9.4.3　友元函数的重载
        • 9.4.4　友元类
        • 9.4.5　友元是否破坏了封装性
      • 9.5　运算符重载
        • 9.5.2　以成员函数形式重载运算符
        • 9.5.3　以友元函数形式重载运算符
        • 9.5.4　友元函数形式和成员函数形式的比较
        • 9.5.5　对运算符重载的补充说明
      • 9.6　运算符重载范例
        • 9.6.2　函数调用运算符
        • 9.6.3　下标运算符
      • 9.7　类型转换
        • 9.7.2　由自定义类向其他类型的转换
        • 9.7.3　隐式转换带来的二义性
      • 9.8　重载函数选择规则
        • 9.8.2　什么是完全匹配
      • 9.9　小结
      • 9.10　上机实践习题
    • 8.1.3　类和对象的关系
    • 8.3　C++类的实现
      • 8.3.2　在类定义的外部定义成员函数
    • 第10章　继承
      • 10.1.2　继承的层次性
      • 10.2　派生类
        • 10.2.2　protected成员与protected派生
      • 10.3　多基派生
        • 10.3.2　二义性问题
        • 10.3.3　解决方案
      • 10.4　虚基类
        • 10.4.2　解决方案
        • 10.4.3　虚基派生二义性与多基派生二义性不同
      • 10.5　派生类的构造函数和析构函数
        • 10.5.2　派生类的析构函数
        • 10.5.3　多基派生类的构造函数和析构函数
        • 10.5.4　虚基派生类的构造函数和析构函数
      • 10.6　分清继承还是组合
        • 10.6.2　组合
      • 10.7　基类与派生类对象间的相互转换
        • 10.7.2　多基继承时的情况
        • 10.7.3　公共基类
        • 10.7.4　虚基类的情况
      • 10.8　小结
      • 10.9　上机实践习题
    • 8.4　C++类的使用
      • 8.4.2　对象的作用域、可见域和生存期
    • 第11章　多态
      • 11.1.2　动态联编
      • 11.2　虚函数的访问
        • 11.2.2　指针访问
        • 11.2.3　引用访问
        • 11.2.4　类内访问
        • 11.2.5　在构造函数或析构函数中进行访问
      • 11.1.3　为什么需要虚函数
      • 11.3　纯虚函数与抽象类
        • 11.3.2　抽象类
        • 11.3.3　另一种抽象类：类中只定义了protected型的构造函数
        • 11.3.4　延伸：构造函数能否为private型
        • 11.3.5　虚析构函数
      • 11.1.4　虚函数的声明和定义
      • 11.4　虚函数引入的二义性
        • 11.4.2　共同基类和虚继承
      • 11.5　重载、覆盖与隐藏
        • 11.5.2　覆盖
        • 11.5.3　隐藏
      • 11.6　小结
      • 11.7　上机实践习题
    • 8.5　对象的创建和撤销
      • 8.5.2　构造函数可以有参数
      • 8.5.3　构造函数支持重载
      • 8.5.4　构造函数允许按参数默认方式调用
      • 8.5.5　初始化表达式
      • 8.5.6　析构函数
      • 8.5.7　显式调用析构函数
    • 8.6　复制构造函数
      • 8.6.2　默认复制构造函数带来的问题
      • 8.6.3　解决方案—显式定义复制构造函数
      • 8.6.4　关于构造函数和复制构造函数
    • 8.7　特殊数据成员
      • 8.7.2　引用成员
      • 8.7.3　类对象成员
      • 8.7.4　特别说明
      • 8.7.5　static数据成员
    • 8.8　特殊函数成员
      • 8.8.2　const与成员函数
    • 8.9　对象的组织
      • 8.9.2　指向对象的指针
      • 8.9.3　对象的大小
      • 8.9.4　this指针
      • 8.9.5　对象数组
      • 8.9.6　对象链表
    • 8.10　为对象动态分配内存
      • 8.10.2　使用new和delete为对象数组分配/释放动态空间
      • 8.10.3　malloc和free能否为对象动态申请内存
    • 8.11　小结
    • 8.12　上机实践习题
  • 第四篇　泛型编程
    • 12.1.2　模板的定义
    • 12.2　函数模板
      • 12.2.2　隐式实例化
      • 12.2.3　显式实例化
      • 12.2.4　特化
      • 12.2.5　重载
      • 12.2.6　优先级与执行顺序
    • 第13章　标准模板库
      • 13.1.2　适配器
      • 13.2　使用序列式容器
        • 13.2.2　所有容器都支持的特征
        • 13.2.3　序列式容器中元素的插入和删除
        • 13.2.4　vector容器
        • 13.2.5　deque容器
        • 13.2.6　list容器
      • 13.1.3　迭代器
      • 13.3　使用关联式容器
        • 13.3.2　multiset容器
        • 13.3.3　map容器
        • 13.3.4　multimap容器
      • 13.1.4　算法
      • 13.4　关联式容器支持的成员函数操作
        • 13.4.2　元素的删除
        • 13.4.3　元素的查找与访问
      • 13.5　迭代器
        • 13.5.2　迭代器类型
        • 13.5.3　为什么要定义这么多迭代器
        • 13.5.4　容器中定义的迭代器类型与5种类型的对应
        • 13.5.5　流迭代器
        • 13.5.6　迭代器失效
      • 13.6　泛型算法
        • 13.6.2　算法分类
      • 13.7　适配器
        • 13.7.2　迭代器适配器
        • 13.7.3　函数适配器
      • 13.8　小结
      • 13.9　上机实践习题
    • 12.3　类模板
      • 12.3.2　隐式实例化
      • 12.3.3　显式实例化
      • 12.3.4　显式特化
      • 12.3.5　部分特化
      • 12.3.6　重载和优先级
    • 12.4　模板的嵌套
      • 12.4.2　对象成员模板
    • 12.5　模板参数
    • 12.6　小结
    • 12.7　上机实践习题
  • 第五篇　输入输出处理和编程规范
    • 14.1.2　流
    • 14.2　高层I/O
      • 14.2.2　标准输入函数scanf
      • 14.2.3　扫描集
      • 14.2.4　sprintf函数和sscanf函数
      • 14.2.5　fprintf函数和fscanf函数
      • 14.2.6　文件访问机制
    • 第15章　名称空间
      • 15.1.2　定义名称空间
      • 15.2　实体的作用域与可见域
        • 15.2.2　可见域的扩展
        • 15.2.3　using声明机制
        • 15.2.4　using声明带来的多重声明问题（二义性）
        • 15.2.5　空间内的屏蔽
        • 15.2.6　先声明，后使用
      • 15.3　名称空间的作用域与可见性
        • 15.3.2　推荐用法
        • 15.3.3　名称空间嵌套
        • 15.3.4　using编译指令
        • 15.3.5　未命名的名称空间
      • 15.4　对名称空间的思考
      • 15.5　小结
      • 15.6　上机实践习题
    • 14.1.3　缓冲区
    • 14.3　流类库
      • 14.3.2　流类库层次
    • 第16章　异常和错误
      • 16.1.2　返回错误标志
      • 16.2　异常机制
        • 16.2.2　异常处理程序
        • 16.2.3　自定义异常对象
        • 16.2.4　有继承关系的类异常
        • 16.2.5　terminate函数和set_terminate函数
        • 16.2.6　unexpected函数与set_unexpected函数
        • 16.2.7　标准异常
        • 16.2.8　对unexpected函数的补充
      • 16.3　异常发生时的内存管理
        • 16.3.2　异常处理机制与函数的不同
        • 16.3.3　构造函数中抛出异常
        • 16.3.4　内存泄露
        • 16.3.5　析构函数中可否抛出异常
      • 16.4　auto_ptr类
        • 16.4.2　关于auto_ptr的若干问题
      • 16.5　小结
      • 16.6　上机实践习题
    • 14.1.4　重定向
    • 14.4　输出流
      • 14.4.2　其他ostream方法
      • 14.4.3　格式状态字
      • 14.4.4　格式控制值的默认值
      • 14.4.5　flag函数读取和设定格式状态字
      • 14.4.6　使用setf函数和unsetf函数设定格式关键字
      • 14.4.7　设置域宽
      • 14.4.8　填充字符
      • 14.4.9　浮点数输出和显示精度
      • 14.4.10　控制符
    • 第17章　RTTI和类型转换操作符
      • 17.1.2　typeinfo类和typeid操作符
      • 17.2　类型转换操作符
        • 17.2.2　static_cast操作符
        • 17.2.3　reinterpret_cast操作符
      • 17.1.3　补充说明
      • 17.3　小结
      • 17.4　上机实践习题
    • 14.1.5　3种输入输出机制
    • 14.5　输入流
      • 14.5.2　输入流与格式状态字
      • 14.5.3　输入流与域宽
      • 14.5.4　使用get函数读取单个字符
      • 14.5.5　使用get函数和getline函数读取C风格字符串
      • 14.5.6　其他istream方法
    • 第18章　string字符串类
      • 18.2　声明一个字符串
      • 18.3　字符串的输入输出
      • 18.4　string类功能
        • 18.4.2　赋值和清空
        • 18.4.3　元素删除
        • 18.4.4　元素追加与相加
        • 18.4.5　元素插入
        • 18.4.6　大小和容量
        • 18.4.7　元素存取
        • 18.4.8　字符串比较
        • 18.4.9　提取子串
        • 18.4.10　搜索与查找
      • 18.5　小结
      • 18.6　上机实践习题
    • 14.6　流状态
      • 14.6.2　读取流状态
      • 14.6.3　管理流状态
    • 第19章　编码风格
      • 19.1.2　空行的用法
      • 19.2　命名规则
        • 19.2.2　如何对程序实体命名
      • 19.1.3　代码行
      • 19.3　项目文件的组织
        • 19.3.2　头文件
        • 19.3.3　定义文件
        • 19.3.4　目录结构
      • 19.1.4　空格
      • 19.4　小结
      • 19.1.5　缩进与对齐
      • 19.5　上机实践习题
      • 19.1.6　＆和*的位置
    • 14.7　重载＞＞和＜＜
      • 14.7.2　抽取符的重载
    • 第20章　程序编译
      • 20.2　预处理
        • 20.2.2　宏
        • 20.2.3　条件编译
        • 20.2.4　#ifdef、#ifndef与重复包含
        • 20.2.5　使用const代替#define定义常量
        • 20.2.6　inline与#define的比较
      • 20.3　VC6调试入门
        • 20.3.2　条件断点
        • 20.3.3　数据断点
        • 20.3.4　消息断点
        • 20.3.5　观察视图（Watch）
        • 20.3.6　内存视图（Memory）
        • 20.3.7　变量视图（Variables）
        • 20.3.8　寄存器视图（Registers）
        • 20.3.9　调用堆栈视图（Call Stack）
        • 20.3.10　反汇编视图（Disassembly）
        • 20.3.11　进程控制
      • 20.4　其他调试手段
        • 20.4.2　assert宏
        • 20.4.3　输出字符串
      • 20.5　小结
      • 20.6　上机实践习题
    • 14.8　文件操作
      • 14.8.2　文件的打开
      • 14.8.3　取消文件和流的关联
      • 14.8.4　文件的读写
      • 14.8.5　文本文件的读写
      • 14.8.6　二进制文件的读写
      • 14.8.7　文件定位指针和随机读取
    • 14.9　字符串流
      • 14.9.2　sstream类族
    • 14.10　小结
    • 14.11　上机实践习题
  • 第六篇　面试题精选
    • 面试题2：局部变量能否和全局变量重名
    • 21.2　世界500强公司的智力问答题
      • 面试题20：分蛋糕
      • 面试题21：过桥问题
      • 面试题22：黑白帽子
      • 面试题23：电梯与钻石
      • 面试题24：手电筒传递
      • 面试题25：烧绳问题
      • 面试题26：圆的下水道盖子
      • 面试题27：选建筑师
      • 面试题28：天平分盐
      • 面试题29：分不开的钱
      • 面试题30：小鸟追火车
      • 面试题31：给红色最大的机会
      • 面试题32：镜子中的影像
      • 面试题33：污染的药丸
      • 面试题34：称出不是标准重量的水
      • 面试题35：多彩的果冻
      • 面试题36：电子游戏机
      • 面试题37：监狱里的囚犯
      • 面试题38：灯的状态
      • 面试题39：时针和分针
      • 面试题40：3个奇数
      • 面试题41：屋内的灯
      • 面试题42：找出最重的球
      • 面试题43：盲人分袜子
      • 面试题44：烧香计时
      • 面试题45：平分蜂蜜
      • 面试题46：猜经理女儿的年龄
      • 面试题47：两个圆环
      • 面试题48：喝啤酒
      • 面试题49：算24点
      • 面试题50：聪明人
      • 面试题51：海盗分金币
      • 面试题52：到底是什么牌
      • 面试题53：聪明的老板娘
      • 面试题54：找出不同重量的球
    • 面试题3：类成员函数的重载、覆盖和隐藏的区别是什么
    • 21.3　分析题
      • 面试题56：分析程序最后的输出结果
      • 面试题57：分析最后输出的结果
      • 面试题58：求下面函数的返回值
      • 面试题59：分析最后输出的结果
      • 面试题60：分析最后输出的结果
    • 面试题4：用变量a给出下面的定义
    • 21.4　编程题
      • 面试题62：String类的具体实现
      • 面试题63：链表题，一个链表的节点结构
      • 面试题64：写一个函数并找出在一个整数数组中第二大的数
      • 面试题65：字符串的逆序输出
      • 面试题66：判断操作系统的位数
      • 面试题67：实现对数组的降序排序
      • 面试题68：斐波那契数列1、1、2、3、5等，编写程序求第10项
    • 面试题5：在C++中，下面的结构是合法的吗？如果是，其作用是什么
    • 面试题6：在非C++中建类A和B，在哪几种情况下B能隐式转化为A
    • 面试题7：C++中的空类，默认产生哪些类成员函数
    • 面试题8：C++有哪些性质（面向对象特点）
    • 面试题9：子类析构时要调用父类的析构函数吗
    • 面试题10：什么是引用？声明和使用“引用”要注意哪些问题
    • 面试题11：将引用作为函数返回值类型的格式及优点有哪些
    • 面试题12：引用与指针的区别是什么
    • 面试题13：重载和重写（覆盖）的区别
    • 面试题14：多态的作用是什么
    • 面试题15：请指出const与#define相比有何优点
    • 面试题16：C语言中static关键字的具体作用有哪些
    • 面试题17：如何判断程序是由C编译程序还是由C++编译程序编译的
    • 面试题18：关键字const的含义是什么
暂无相关搜索结果！
    展开/收起文章目录

    二维码

    手机扫一扫，轻松掌上学

    《零基础学C++ 第2版-杨彦强 & 刘袁红 & 王浩》电子书下载

    请下载您需要的格式的电子书，随时随地，享受学习的乐趣！
    EPUB 电子书

    书签列表

      阅读记录

      阅读进度: 0.00% ( 0/0 ) 重置阅读进度