2025计算机二级C语言资料


 05、2025计算机二级C语言资料
   C++从入门到精通(项目案例版)
   小甲鱼C++视频教程
   侯捷C++面向对象高级开发与设计模式
   海量书籍PDF
   范磊-零起点学通C++
   编程软件
   VC++6.0.rar
   小黑课堂计算机二级C语言题库安装包1.3.exe
     039 命名空间和模块化编程.mp4
     038 避免内存泄漏.mp4
     02 第二讲 从一个小程序说起.mp4
     029 虚继承.mp4
     022 静态属性和静态方法2.mp4
     037 高级强制类型转换.mp4
     11 复杂的数据类型05_对象的基础:结构.mp4
     08 第七讲 复杂的数据类型(2)-指针.mp4
     036 副本构造器.mp4
     027 重载《操作符.mp4
     16this指针和类的继承.mp4
     14 (上)给大家介绍对象.mp4
     018 访问控制.mp4
     026 运算符重载2.mp4
     03 第三讲 从一个小程序说起(2)(输入输出方法).mp4
     15不是每一滴牛奶都叫特仑苏(构造器和析构器讲解).mp4
     06 第六讲 函数的重载.mp4
     033 动态内存管理.mp4
     046 内联模板.mp4
     14(下)闭门造车.mp4
     07 第七讲 复杂的数据类型.mp4
     047 容器和算法.mp4
     032 assert函数和捕获异常.mp4
     04 第四讲 从另一个小程序接着说.mp4
     034 动态数组.mp4
     035 从函数或方法返回内存.mp4
     042 链接和作用域.mp4
     020 一种特殊的友情.mp4
     01 第一讲 Cplusplus语言与OO思想介绍.mp4
     028 多继承.mp4
     10 复杂的数据类型04_指针和数组.mp4
     041 命名空间和模块化编程3.mp4
     05 输出输入小结.mp4
     048 容器和算法2.mp4
     023 虚方法.mp4
     045 类模板.mp4
     017 继承机制中的构造器和析构器.mp4
     021 静态属性和静态方法.mp4
     09 复杂的数据类型03_指针02.mp4
     024 抽象方法.mp4
     13 联合、枚举和类型别名.mp4
     044 函数模板.mp4
     040 命名空间和模块化编程2.mp4
     025 运算符重载.mp4
     031 错误处理和调试2.mp4
     030 错误处理和调试.mp4
     043 链接和作用域2.mp4
     019 覆盖方法和重载方法.mp4
     开发资源库.rar
     C++从入门到精通(源码文件和视频文件).rar
     C++设计模式
     C++面向对象高级开发
     C++面向对象高级开发(下)
     明解C语言
     C语言程序设计(第四版)谭浩强.pdf
     C语言之父《C程序设计语言(中文版)》(第2版).pdf
     [C陷阱与缺陷].(美)Andrew.Koenig.pdf
     C语言-从白痴到资深专家阶梯式教程.pdf
     C标准库-中文.pdf
     C经典算法大全.pdf
     C外挂编写深究4.3.pdf
     超级指针详解.pdf
     C语言精彩编程百例.pdf
     C语言常见问题集.pdf
     如何养成良好的编程习惯(C语言篇).pdf
     C大纲.pdf
     C语言各章节知识点总结.pdf
     C Primer Plus 第6版 中文版 高清完整PDF版.pdf
     郝斌C语言详细笔记(附源码).pdf
     C语言深度剖析.pdf
     轻松学C语言扩展阅读之Visual AssistX安装教程.pdf
     C语言算法大全_ziyuanw.com.pdf
     经典教材--C语言程序设计(第五版) 谭浩强.pdf
     明解C语言.pdf
     C语言开发从入门到精通.pdf
     C语言函数手册.PDF
     狂人C-程序员入门必备.pdf
     C语言解惑(中文版).pdf
     林锐-高质量C编程.pdf
     彻底搞定C指针.pdf
     华为C语言编程规范.pdf
     C和C++内存管理.pdf
     【迷你书】征服c指针.pdf
     C语言程序设计_现代方法(第2版).pdf
     C语言从初学到精通.pdf
     C语言趣味程序百例精解.pdf
     《C_C++程序设计教程(第4版)》_孙淑霞.pdf
     新概念C语言.pdf
     让你不再害怕指针.pdf
     [C程序设计(第四版)].谭浩强.扫描版.pdf
     495个C语言问题.pdf
     c语言游戏编程从入门到精通.pdf
     (中文版)C语言编程:一本全面的C语言入门教程  (第3版) - 副本.pdf
     《入门很简单丛书:C语言入门很简单》.pdf
     手写代码必备手册(C版).pdf
     写给大家看的C语言书.pdf
     C程序员面试100题.ppt
     C专家编程.pdf
     C语言高级编程.pdf
     C和指针.pdf
     大话数据结构.pdf
     C语言程序设计 李健 文字版.pdf
     你必须知道的495个C问题.pdf
     C语言范例开发大全(文字版).pdf
     C Primer Plus(第五版)中文版.pdf
     C语言程序设计教案.pdf
     C和指针(第二版).pdf
     vc6.0_cn_full(完整绿色版)(支持XP、Win7、Win8、Win10).exe
     Dev C++ 5.6.1
     MSDEV.EXE
     C++视频教程(零起点学通c++)
     零起点学通C++.iso
     零起点学通C++ 范磊.pdf
       10.扩展补充:类模板,函数模板,及其他.mp4
       5.操作符重载与临时对象.mp4
       6.复习Complex类的实现过程.mp4
       1.C++编程简介.mp4
       8.堆,栈与内存管理.mp4
       2.头文件与类的声明.mp4
       13.委托相关设计.mp4
       12.虚函数与多态.mp4
       7.三大函数:拷贝构造,拷贝复制,析构.mp4
       3.构造函数.mp4
       9.复习String类的实现过程.mp4
       4.参数传递与返回值.mp4
       11.组合与继承.mp4
       12.单件模式.mp4
       15.代理模式.mp4
       2.面向对象设计原则.mp4
       9.抽象工厂.mp4
       19.备忘录.mp4
       24.访问器.mp4
       22.职责链.mp4
       23.命令模式.mp4
       1.设计模式简介.mp4
       21.迭代器.mp4
       18.状态模式.mp4
       6.装饰模式.mp4
       14.门面模式.mp4
       17.中介者.mp4
       8.工厂方法 .mp4
       7.桥模式.mp4
       10.原型模式.mp4
       13.享元模式.mp4
       16.适配器.mp4
       3.模板方法.mp4
       26.设计模式总结.mp4
       4.策略模式.mp4
       25.解析器.mp4
       20.组合模式.mp4
       5.观察者模式.mp4
       11.构建器.mp4
       明解C语言:入门篇.pdf
       明解C语言:中级篇.pdf
       关于this 18.mp4
       模板偏特化 11.mp4
       function-like classes 5.mp4
       namespace经验谈 6.mp4
       关于C++标准库 13.mp4
       重载new(),delete()$示例  23.mp4
       复合&继承关系下的构造和析构 16.mp4
       关于vptr和vtbl 17.mp4
       三个主题 14.mp4
       conversion function2.mp4
       关于New,Delete 20.mp4
       导读1.mp4
       class template 7.mp4
       模板模板参数 12.mp4
       示例 22.mp4
       Reference 15.mp4
       non-explicit one argument constructor 3.mp4
       Funtion Template 8.mp4
       Basic_String使用new(extra)扩充申请量  24.mp4
       Operator new,operator delete.. 21.mp4
       pointer-like classes 4.mp4
       关于Dynamic Binding 19.mp4
       Member Template 9.mp4
       关于Dynamic Binding 19 (1).mp4
       specialization 10.mp4
       专用播放器
       初级篇代码
       VC6.0补丁
       高级篇代码
       高级篇视频
       初级篇视频
         专用播放器使用说明.swf
         专用播放器.exe
         VC6.0补丁安装.swf
         Vs6sp6.exe
         第24章
         第20章
         第21章
         第22章
         第19章
         第23章
         第25章
         第11章
         第16章
         第3章
         第15章
         第18章
         第6章
         第10章
         第13章
         第5章
         第14章
         第4章
         第9章
         第7章
         第2章
         第12章
         第17章
         第8章
         第19章
         第20章
           20—1 友元类
           20—2   嵌套类
           24.3 异常的派生
           24.8 智能指针的赋值和复制
           wab
           24.7 智能指针避免内存泄露
           24.8 智能指针不能用于STL容器
           24.6 异常类与模板的关系
           24.7 异常引起的内存溢出
           24.4 创建异常类的成员函数
           24.8 智能指针具有和指针一样的行为
           24.2 设置多条catch语句
           24.5 异常类的虚函数
           24.1 异常
         第2章
         第18章
         第7章
         第3章
         第12章
         第6章
         第13章
         第5章
         第4章
         第10章
         第16章
         第11章
         第17章
         第8章
         第1章
         第14章
         第9章
         第15章
           用VC6.0编译的代码
           用VS2005编译的程序
           用DEV编译的程序
           注意.txt
           19—12   私有继承
           19—9   私有继承
           19—3   为book类重载执行相加运算的成员函数
           19—5   按别名传递book对象
           19—12   保护继承
           19—6   包含指向另一个类的指针
           19—7—12  商品管理全部程序
           19—2   将String类作为包含类
           19—12   公有继承
           19—1   包含
           19—8   利用类的包含来实现代码重用
           19—4   包含对系统造成的消耗
           22—5   为你的命名空间取个别名
           22—6—2  未命名命名空间与static的区别
           22—2—1  扩充命名空间的内容
           22—1   什么是命名空间:解决命名冲突
           22—1   什么是命名空间:指定空间名
           22—7   标准命名空间std
           22—1 全局变量和局部变量的不同
           22—3   使用命名空间
           22—6—3  未命名命名空间、static与extern的区别
           22—2—2  尽量在命名空间之外定义函数
           22—1   什么是命名空间:命名冲突
           22—4   使用关键字using
           22—6—1  未命名命名空间与全局变量的区别
           22—6   未命名的命名空间
           22—2—3  命名空间中的成员都是公有的
           21—3—9  gcount函数
           21—3—11  putback函数
           21—2—9  setf函数原型
           21—9   命令行处理文件
           21—2—1  重载插入运算符
           21—6   检查文件是否打开
           21—2—6  设置浮点数的显示精度
           21—2—8  设置标志
           21—2—8 标志设置不当出现的错误
           21—3—3  get函数
           21—2—10  所有15个标志以及3个指示标志
           21—2—3  有关输出的相关函数
           21—3—5  带2个参数的get函数
           21—16   具有保存和读取功能的商品管理系统
           21—3—8  read函数
           21—4—1  输出数据到文件
           21—15—3  字符串输入输出流类stringstream
           21—2—11  unset函数
           21—2—5  设置填充字段
           21—2—12  标准控制符
           21—2—7  输出末尾的0
           21—3—1  字符串的输入
           21—3—4  带字符引用参数的get函数
           21—15—4  综合实例—十进制转十六进制
           21—7—2  以二进制形式输出到文件
           21—7—1  以文本形式输出到文件
           21—2—4  设置输出的字段宽度
           21—10   使用命令行处理文件例程
           21—11   指定读取文件中的数据
           21—14   临时文件
           21—7   二进制文件和文本文件
           21—13 seekp和seekg函数的结合使用
           21—4—2  读取文件中的数据
           21—12   输出数据到文件指定位置处
           21—3—10  peek函数
           21—5   多种打开文件的方式
           21—3—2  字符串的输入问题
           21—2—2  清理缓冲区
           21—15—1  字符串输入流类istringstream
           21—3—7  getline函数
           21—2—13  iomanip头文件与标准控制符
           21—15—2  字符串输出流类ostringstream
           用DEV编译的程序
           21—3—6  带3个参数的get函数
           21—4—3  读取空格及空格后面的字符
           3—1   一个简单的函数
           3—6   全局变量
           3—4   函数的声明与定义
           3—5   局部变量
           3—3   函数的返回值、参数与变量
           3—2   函数的传参
           16—8   空的虚函数
           16—1   为什么要使用多重继承
           16—10   纯虚函数与抽象类
           16—4   多重继承中初始化构造函数的参数
           16—5   多个子基类共享一个父基类
           16—2   在派生类中增加函数
           16—3   使用多重继承
           16—11  复杂的抽象结构
           16—9   模拟抽象类
           16—6   虚基类
           11—1   运算符重载
           11—10—3  通过operator关键字进行转换
           11—5   创建无名临时对象
           11—8   重载加法运算符函数
           11—9  重载赋值运算符函数
           11—7   重载后置自加运算符
           11—2   在成员函数中实现自加
           11—4   创建临时对象
           11—6   取消创建临时对象
           11—10—2  通过构造函数将变量转换为一个对象的成员变量
           11—10   转换类型运算符
           11—3   重载前置自加运算符
           25.16.5  左移运算符
           25.18.3 6.difftime()两时刻的间隔
           25.18.3 11.setlocale()用来配置地域的信息
           25.1.17  error指令
           25.18.6  区域表示locale与模板的搭配使用
           25.8.5  运行时类型信息
           25.16.9  位运算的实例
           25.8.1  向下类型转换指针
           25.1.10  ##运算符
           25.8.1  向下类型转换引用
           25.1.19  #pragma 指令message 参数
           25.1.7  宏
           25.14   匿名联合体
           25.11   关键字mutable
           25.1.8  宏与内联函数
           25.17   位字段
           25.18.3 8.mktime()返回指定时间的日历格式
           25.13   联合数据类型的内存占用
           25.1.4  用#define指令替换常量
           25.18.3 9.strftime()返回日期和时间的单个元素
           25.15.5  接受字符数组的函数
           vc6.0编译#pragma warning
           25.1.5 #ifndef
           25.15.2  指针读取二维数组
           25.4   assert()宏之打开调试
           25.1.19  #pragma warning
           25.15.2  指针操作多维数组
           25.16.3  异或“^”运算符
           25.18.3 4.clock()返回自程序开始运行所经过的时间
           25.3   assert()宏
           25.15.8  指向函数的指针的用途
           25.18.3 8.显示2007年11月1日是星期几
           25.1.19  #pragma once
           25.18.3 7.gmtime()返回指向当前格林威治时间的指针
           25.16.4  取反“~”运算符
           25.12   联合数据类型union
           25.18.3 11.货币符号的本国形式与国际形式
           25.18.3 2.localtime()返回指向当前时间的指针
           25.15.1  指针与数组的练习程序
           25.18.3 11.按简体中文输出“世界你好”
           25.1.7  带参数的#define
           25.15.10  指向指针的指针
           25.18.4 locale与time中时间函数的搭配使用
           25.15.6  指向字符串的指针与字符数组的区别
           25.15.7  指向函数的指针
           25.4   尝试编写一个简单的assert()宏
           25.18.5  区域表示locale与流的搭配使用
           25.16.1  按位与运算符
           25.1.5  用#define定义一个特定字符串并对其进行测试
           25.15.9  指针数组
           25.15.5  接受字符串地址的函数
           25.1.14  #if defined指令
           25.9   关键字volatile
           25.6   用宏函数来输出表达式的值
           25.16.6  右移运算符
           25.15.4  指向字符数组的指针
           25.1.16  #elif指令
           25.1.9  #运算符
           25.2   预定义的宏
           25.18.3 10.localeconv()返回当地的数字和货币格式信息
           25.18.3 5.ctime()转换参数time为本地时间格式
           25.18.4 美国货币中国日期
           25.18.3 1.time返回系统的当前日历时间
           25.1.3  #define指令
           25.18.3 3.asctime()时间文本格式
           25.18.3 8.显示N天后的日期
           25.16.2  按位或运算符
           25.8.4  常类型转换
           25.15.1  指针与数组
           25.15.3  指向多维数组的指针作为函数参数
           25.1.6  #ifdef、#define和#endif的用途
           25.8.3  重新解释类型转换
           25.7   调试的级别
           25.15.4  指向字符串的指针
           25.5   不能为0的变量
           25.15.5  间接访问字符串
           25.8.2  静态类型转换
           25.16.7  复合位运算符
           10—3—2  成员变量的初始化与构造函数
           10—6   深层复制构造函数
           10—4—1  默认析构函数
           10—1—1  普通函数的重载
           10—4—2  调用构造函数进行类型转换
           10—1—2  成员函数的重载
           10—3—5  再谈默认构造函数
           10—3—4  构造函数和new运算符
           10—3—2  const成员与引用成员不能赋值
           10—4   析构函数和delete运算符
           10—3—0   重载构造函数
           10—3—1  成员变量的初始化
           10—2   函数的默认参数
           10—3—3  复制构造函数
           10—5   浅层复制构造函数
           6—6   成员函数的声明和定义
           6—12   析构函数
           6—10   构造函数
           6—8   头文件与源文件
           6—9   const成员函数
           6—3—7  对象只能调用类中存在的方法
           6—4   公有
           6—7—1  普通内联函数
           6—11   默认构造函数
           6—7—2  内联成员函数
           6—3—2  命名习惯
           6—5   私有
           6—13   析构对象数组
           15—3—3  动态链表的显示
           15—5—10  用链表记录行走路线
           15—3—5  动态链表的插入
           15—3—4  动态链表的删除
           15—5—3  加载图片
           15—5—9  走迷宫
           15—4   完整的动态链表清单
           15—5—5  显示图片
           15—5—1  创建Windows应用程序项目
           15—5—8  迷宫墙壁
           15—5—7 键盘控制人物移动
           15—3—1  动态链表的建立
           15—3—6  链表统计
           15—3—2  解决输入字符造成死循环的问题
           15—2—1  图书链表
           15—3—7  使用链表
           15—3—0   动态链表
           15—1   声明链表结构
           15—5—5  CPaintDC与CClientDC
           15—5—2  创建窗口
           15—2—2  类的链表
           15—5—7 抹去人物残影
           15—5—6  动画
           18—2—4  string型字符串的替换
           18—2—1  string型字符串的赋值
           18—7—7  用重载输入运算符函数实现字符串的输入
           18—3—3  char型字符串与函数
           18—7—2  创建可自动调节大小的String类字符串对象
           18—4—2  结构体与函数
           18—2—7  string型字符串的删除
           18—7—6  用重载输出运算符函数实现字符串的输出
           18—7—3  限制数组越界
           18—6—1  重载输出运算符
           18—3—2  将string型字符串转为char型字符串
           18—2—5  string型字符串的复制
           18—7—9  为String类添加字符串的相加功能
           18—7—8  用重载比较运算符实现字符串的比较
           18—7—5  用重载赋值运算符函数实现字符串赋值功能
           18—2—6  string型字符串的插入
           18—7—1  创建String类
           18—4—1  结构体的赋值
           18—6—2  友元的方式重载输出运算符
           18—7—4  用复制构造函数实现字符串的初始化功能
           18—3—4  函数如何返回字符串
           18—7—10  为String类添加字符串的加等功能
           18—4   结构体
           18—2—3  string型字符串的部分合并
           18—2—2  string型字符串的合并
           18—1   char型字符串
           18—6—3  重载自加运算符的执行次序
           18—3—1  swap 交换两个字符串的内容
           18—4—3  结构体与string
           18—2—9  string型字符串的比较
           18—5   string数组与函数
           18—2—8  string型字符串的查找
           18—7—11  完成后的String类
           18—2   string型字符串
           18—6—4  重载输入运算符
           18—2—10  判断string型字符串是否为空
           7整型概述
           12
           4
           1
           5
           6
           2
           11
           9
           10
           13—8   在编译时的动态联编
           13—6   在运行时的静态联编
           13—2   虚函数
           13—12   在虚函数中使用成员名限定
           13—10   被继承的虚函数仍然是虚函数
           13—1   指向对象的指针
           13—9—1  在虚函数中调用成员函数
           13—4   继承是否可以实现多态性
           13—3  拳击游戏
           13—13   虚析构函数
           13—7   错误的动态联编
           13—7   在运行时的动态联编
           13—5   在编译时的静态联编
           13—9—2  三种调用虚函数的方式比较
           24复杂嵌套的if语句
           23三目运算符在字符型变量中的使用
           2什么是表达式?
           1什么是语句?
           8关系运算符
           7表达式的优先级
           22三目运算符的型别问题
           12 if语句的嵌套
           10 else语句
           15逻辑“或”
           9 if语句
           6什么是自加与自减
           20三目运算符的优先问题
           16逻辑“非”
           17逻辑运算符的优先级
           18运算式的真假关系
           21三目运算符的使用问题
           14逻辑“与”
           3什么是运算符?
           13带括号的嵌套语句
           4赋值运算符与数学运算符的联合
           11 else if语句
           19三目运算符
           14—15   字符数组 (4)strupr函数
           14—1   数组的基本用法
           14—7   数组与函数
           14—1—2  数组元素
           14—15   字符数组 (5)strlwr函数
           14—1—5  将数组的下标定义为常量
           14—13   多维数组
           14—4   输出数组名
           14—10   在对象数组中初始化成员变量
           14—2—3  数字排序问题
           14—15   字符数组 3字符数组的输出
           14—14   多维数组的初始化
           14—7—5  函数传参实例五 判断数组排列方式后执行不同的函数
           14—15   字符数组 5字符串的输入问题
           14—15   字符数组 (6)strlen函数
           14—1—3  数组下标越界
           14—2—2  兔子繁殖问题
           14—15   字符数组 4字符串数组的输出
           14—1—7  数组的初始化
           14—15   字符数组 (3)strcmp函数
           14—15   字符数组 (1)strcat函数
           14—7—4  函数传参实例四 判断数组是否按照顺序排列
           14—6   传递与接收
           14—15   字符数组 1定义字符数组
           14—8   数组在对象中的传参
           14—7—2  函数传参实例二 用递增法查找数据
           14—15   字符数组 (2)strcpy函数
           14—7—1  函数传参实例一求数组所有元素的和
           14—15   字符数组 2初始化字符数组
           14—1—6  手动操作数组元素
           14—3   数组在内存中的分布
           14—16   重载数组下标操作符
           14—1—4  倒序输出
           14—5   数组名与函数
           14—15   字符数组
           14—11   指针数组
           14—7—3  函数传参实例三 用二分法查找数据
           14—12  枚举常量与数组
           14—9   对象数组
           14—15   字符数组 (7)字符数组实例 打印杨辉三角形
           14—2—1  求平均考试成绩
           3
           2
           5
           6
           1
           7—5   for循环
           7—3—4  continue语句
           7—3—2  以字符为条件的while语句
           7—1 循环语句的前身—goto语句
           7—5—3  执行为空的for循环
           7—3—5  break语句
           7—6—2  switch的菜单功能
           7—3—1 带运算符的while语句
           7—5—1  灵活的for循环
           7—2 慎用goto语句
           7—3—3  限定while循环的次数
           7—3—6  永不休止的while循环
           7—4   do… while循环
           7—5—4  嵌套的for循环
           7—5—2  条件为空的for循环
           7—3   while语句
           7—6 switch语句
           7—6—1  switch语句常见错误
           9—3—2  使用指针来传递对象
           9—3—3  利用const指针来传递对象
           9—2—4 让函数返回多个值
           9—3—5  到底是使用引用还是指针
           9—3—6  引用和指针可以一块用
           9—2—1  按值传递
           9—3—1  按值来传递对象
           9—3—4  利用引用来传递对象
           9—2—3  按别名传递
           9—1—2  引用就是别名常量
           9—1—1  引用的地址
           9—2—2  按址传递
           9—1   什么是引用
           9—4—3  引用一个按别名返回的堆中对象
           9—4—1  引用容易犯的错误
           9—1—4  空引用
           9—1—3  引用对象
           9—4—2  引用一个按值返回的堆中对象
           9—4—4  在哪里创建,就在哪里释放
           12—7—4  减少两义性产生的混淆问题
           12—2   公有型、保护型和私有型
           12—4   多重继承
           12—7—3  两义性的归属问题
           12—3   访问权限
           12—5   继承的构造与析构
           12—7   继承和重载的两义性问题
           12—7—2  继承中的重载
           12—6   合理利用基类构造函数
           12—1—4  单一继承
           12—7—5  虚基类不会产生两义性
           2.3 嵌套类.swf
           2.5 嵌套类.swf
           2.1 嵌套类.swf
           1.5 友元类.swf
           2.4 嵌套类.swf
           1.3 友元类.swf
           1.6 友元类.swf
           1.1 友元类.swf
           2.2 嵌套类.swf
           2.6 嵌套类.swf
           1.4 友元类.swf
           2.7 嵌套类.swf
           3 一些发自肺腑的话.swf
           1.2 友元类.swf
           2.8 嵌套类.swf
           23 总结.swf
           10.3 头节点类、中间节点类和尾节点类.swf
           9 标签类Label.swf
           6 按别名传递book对象.swf
           3.2 图书类.swf
           10.1 头节点类、中间节点类和尾节点类.swf
           12 节点类Node.swf
           1 前言.swf
           3.3 图书类.swf
           8 链表类Node.swf
           13 操作节点类的list类.swf
           3.1 图书类.swf
           21 公有、私有和保护继承的不同.swf
           22 公有、私有和保护继承的不同.swf
           10.2 头节点类、中间节点类和尾节点类.swf
           2 包含.swf
           11 数据类Date.swf
           19 利用私有继承来实现代码重用.swf
           17 程序终结.swf
           16 程序界面.swf
           7 数据类Date.swf
           15 操作节点类List.swf
           14 操作节点类List.swf
           18 利用类的包含来实现代码重用.swf
           20 什么时候使用私有继承,什么时候使用包含.swf
           5 包含对系统造成的消耗.swf
           4 为图书类重载GetAuthor函数.swf
           17—6   函数指针数组
           17—7   函数指针也可以作为函数的参数
           17—3   静态成员函数
           17—2   私有静态成员变量
           17—4   静态成员的使用
           17—9   类的函数指针
           17—1   静态成员变量
           17—10   成员函数指针数组
           17—8   利用typedef简化函数指针
           17—5   函数指针
           8—8—3  指向常量的常指针
           8—1   什么是地址
           8—7—3 指针的相减运算
           8—5   this指针
           8—2—6  更换指针保存的地址
           8—4—1  内存泄漏
           8—8—2  指向常量的指针
           8—3—3  用指针删除堆中空间
           8—7—1  指针的加减运算
           8—2   用指针来保存地址
           8—6   指针的常见错误
           8—4—6  对象在栈与堆中的不同
           8—3—2  用指针创建堆中空间
           8—4—2  在堆中创建对象
           8—7—2  指针的赋值运算
           8—2—5  指针对数值的操作
           8—4—5  在构造函数中开辟内存空间
           8—2—1  空指针
           8—4—3  在堆中删除对象
           8—2—4  指针地址、指针保存的地址和该地址的值
           8—2—3  用指针来访问值
           8—2—2  指针与变量类型
           8—6 空指针引起的程序崩溃
           8—4—4  访问堆中的数据成员
           8—8—1  常量指针
           8—7—4  指针的比较运算
             20—1 友元类.cpp
             20—1 友元类.dsw
             20—1 友元类.dsp
             20—2   嵌套类.cpp
             20—2   嵌套类.dsp
             20—2   嵌套类.dsw
             24.8 智能指针的赋值和复制
             24.8 智能指针的赋值和复制.sln
             24.8 智能指针的赋值和复制.suo
             24.3   异常的派生
             24.3   异常的派生.sln
             24.3   异常的派生.suo
             24.7   智能指针避免内存泄露
             24.7   智能指针避免内存泄露.sln
             24.7   智能指针避免内存泄露.suo
             24.6   异常类与模板的关系
             24.6   异常类与模板的关系.sln
             24.6   异常类与模板的关系.suo
             Debug
             res
             wabDoc.cpp
             wab.clw
             wabView.cpp
             wab.exe
             MainFrm.cpp
             wab.rc
             wab.mdb
             wabSet.cpp
             wab.cpp
             MainFrm.h
             wab.plg
             StdAfx.cpp
             resource.h
             wab.h
             wabDoc.h
             wab.dsw
             StdAfx.h
             wab.dsp
             wabView.h
             wabSet.h
             RCa04024
             ReadMe.txt
             24.8 智能指针不能用于STL容器
             24.8 智能指针不能用于STL容器.suo
             24.8 智能指针不能用于STL容器.sln
             24.8 智能指针具有和指针一样的行为
             24.8 智能指针具有和指针一样的行为.sln
             24.8 智能指针具有和指针一样的行为.suo
             24.2   设置多条catch语句
             24.2   设置多条catch语句.suo
             24.2   设置多条catch语句.sln
             24.7 异常引起的内存溢出
             24.7 异常引起的内存溢出.sln
             24.7 异常引起的内存溢出.suo
             24.4   创建异常类的成员函数
             24.4   创建异常类的成员函数.suo
             24.4   创建异常类的成员函数.sln
           5重名问题.swf
           3 std是什么?.swf
           1简单的屏幕输出小程序.swf
           6注释.swf
           2输出语句的使用.swf
           4 iostream与iostream.h的区别.swf
             24.1   异常
             24.1   异常.suo
             24.1   异常.sln
             24.5   异常类的虚函数
             24.5   异常类的虚函数.sln
             24.5   异常类的虚函数.suo
           27 编写一个String类.swf
           23 重载输出运算符.swf
           12 判断string型字符串是否为空.swf
           11.2 string型字符串的比较.swf
           10.2 string型字符串的查找.swf
           14 将string型字符串转为char型字符串.swf
           26 重载输入运算符.swf
           10.3 string型字符串的查找.swf
           3.1 string型字符串的赋值.swf
           35 用重载比较运算符实现字符串的比较.swf
           17.2结构体与构造函数.swf
           19.2 结构体与函数.swf
           29 创建可自动调节大小的String类字符串对象.swf
           36.1 为String类添加字符串的相加功能.swf
           2.4 string型字符串.swf
           13 swap() 交换两个字符串的内容.swf
           31.3 const对象和const成员函数.swf
           22.2 流的简介.swf
           2.2 string型字符串.swf
           3.2 string型字符串的赋值.swf
           36.3 为String类添加字符串的相加功能.swf
           30 限制数组越界.swf
           25 重载自加运算符的执行次序.swf
           10.1 string型字符串的查找.swf
           1.2 char型字符串.swf
           11.3 string型字符串的比较.swf
           1.1 char型字符串.swf
           28 创建String类.swf
           1.3 char型字符串.swf
           1.4 char型字符串.swf
           4.2 string型字符串的合并.swf
           24 友元的方式重载输出运算符.swf
           37 为String类添加字符串的加等功能.swf
           4.1 string型字符串的合并.swf
           15.1 Char型字符串与函数.swf
           18 结构体的赋值.swf
           7.1 string型字符串的拷贝.swf
           11.1 string型字符串的比较.swf
           34 用重载输入运算符函数实现字符串的输入.swf
           17.1 结构体与类的区别.swf
           15.3 Char型字符串与函数.swf
           5 string型字符串的部分合并.swf
           6.1 string型字符串的替换.swf
           1.5 char型字符串.swf
           31.1 用复制构造函数实现字符串的初始化.swf
           2.1 string型字符串.swf
           2.5 string型字符串.swf
           22.1 流的简介.swf
           16.2 函数如何返回字符串.swf
           2.3 string型字符串.swf
           32 用重载赋值运算符函数实现字符串赋值功能.swf
           31.2 用复制构造函数实现字符串的初始化.swf
           6.2 string型字符串的替换.swf
           20 结构体与string.swf
           19.1 结构体与函数.swf
           38 总结.swf
           16.1 函数如何返回字符串.swf
           9 string型字符串的删除.swf
           8 string型字符串的插入.swf
           36.4 为String类添加字符串的相加功能.swf
           36.2 为String类添加字符串的相加功能.swf.swf
           7.2 string型字符串的拷贝.swf
           22.3 流的简介.swf
           15.2 Char型字符串与函数.swf
           21 string数组与函数.swf
           33 用重载输出运算符数实现字符串的输出.swf
           6全局变量.swf
           5局部变量.swf
           4函数的声明与定义.swf
           3函数的返回值、参数与变量.swf
           1函数演示.swf
           2函数的传参.swf
           2 while语句.swf
           10嵌套的for循环.swf
           12switch语句常见错误.swf
           4 continue和break语句.swf
           6 do… while循环.swf
           9条件为空的for循环.swf
           1  循环语句的老祖宗--Goto语句.swf
           11switch语句.swf
           7for循环.swf
           5永不休止的while循环.swf
           13switch的菜单功能.swf
           8灵活的for循环.swf
           3 while语句的其他用法.swf
           6定义一个对象.swf
           15析构函数.swf
           5命名习惯.swf
           14默认构造函数.swf
           9成员函数的声明和定义.swf
           16析构对象数组.swf
           7定义类或对象容易犯的错误.swf
           2面向对象程序语言的主要特征.swf
           1什么是面向对象程序语言.swf
           12const成员函数.swf
           8公有与私有.swf
           4声明一个类.swf
           11头文件与源文件.swf
           3什么是类、对象和成员.swf
           10内联函数.swf
           13构 造 函 数.swf
           16两义性的归属问题.swf
           15继承中的重载.swf
           5保护成员.swf
           17虚基类不会产生两义性.swf
           7公有派生的保护成员.swf
           11.1多重继承.swf
           3继承和派生如何在C++中实现.swf
           6公有派生的公有成员.swf
           1什么是继承和派生?.swf
           2复杂的继承和派生.swf
           13.2向基类构造函数传递参数.swf
           13.3向基类构造函数传递参数.swf
           11.2多重继承.swf
           12.2继承的构造与析构.swf
           12.1继承的构造与析构.swf
           8公有派生的私有成员.swf
           4.1单一继承.swf
           4.2单一继承.swf
           9继承的赋值.swf
           10私有派生.swf
           13.1向基类构造函数传递参数.swf
           14多重继承容易产生两义性.swf
           9整型变量的定义.swf
           11常量.swf
           2什么是变量.swf
           4布尔型.swf
           3变量及数据如何存储在内存上.swf
           7整型概述.swf
           8为什么使用补码.swf
           1 C++数据类型.swf
           6双字节型.swf
           10浮点型变量.swf
           5字符型.swf
           12枚举型常量.swf
           7构造函数和NEW运算符.swf
           10 默认析构函数.swf
           14本章答疑.swf
           8再谈默认构造函数.swf
           9析构函数和delete运算符.swf
           12.2浅层复制构造函数.swf
           1.2成员函数的重载.swf
           3 重载构造函数.swf
           5.3成员变量的初始化与构造函数.swf
           12.1浅层复制构造函数.swf
           13深层复制构造函数.swf
           1.1普通函数的重载.swf
           2函数的缺省参数.swf
           6复制构造函数.swf
           11调用构造函数进行类型转换.swf
           4成员变量的初始化.swf
           5.2成员变量的初始化与构造函数.swf
           5.1成员变量的初始化与构造函数.swf
           9 if语句.swf
           4什么是运算符?.swf
           7表达式的优先级.swf
           20三目运算符的优先问题.swf
           17逻辑运算符的优先级.swf
           14逻辑“与”运算符.swf
           5赋值运算符与数学运算符的联合.swf
           8关系运算符.swf
           1什么是语句?.swf
           16逻辑非.swf
           3什么是表达式?.swf
           21三目运算符的使用问题.swf
           12 if语句的嵌套.swf
           22三目运算符的型别问题.swf
           24复杂的嵌套if语句.swf
           11 else if语句.swf
           13带括号的嵌套语句.swf
           6什么是自加与自减.swf
           2什么是块?.swf
           15 逻辑或.swf
           10 else语句.swf
           18运算式的真假关系.swf
           23三目运算符在字符型变量中的使用.swf
           19三目运算符.swf
           3.3拳击游戏.swf
           6在运行时的静态联编.swf
           11在虚函数中使用成员名限定.swf
           12.2虚构造函数和析构函数.swf
           10系统是如何调用虚函数的.swf
           7在运行时的动态联编.swf
           9.3三种调用虚函数的方式比较.swf
           1.1指向对象的指针.swf
           3.4拳击游戏.swf
           3.2拳击游戏.swf
           8在编译时的动态联编.swf
           3.1拳击游戏.swf
           5在编译时的静态联编.swf
           4.1继承是否可以实现多态性.swf
           12.1虚构造函数和析构函数.swf
           3.5拳击游戏.swf
           4.2继承是否可以实现多态性.swf
           1.2指向对象的指针.swf
           2虚函数.swf
           9.1三种调用虚函数的方式比较.swf
           9.2三种调用虚函数的方式比较.swf
           9.1 为什么使用指针.swf
           5用指针来访问值.swf
           11在堆中创建对象.swf
           9.4指针与堆.swf
           18.4指针的比较运算.swf
           14在构造函数中开辟内存空间.swf
           12在堆中删除对象.swf
           10内存泄露.swf
           18.1指针的加减运算.swf
           15对象在栈与堆中的不同.swf
           19.1常量指针.swf
           2用指针来保存地址.swf
           13访问堆中的数据成员.swf
           8更换指针保存的地址.swf
           3空指针.swf
           18.3指针的相减运算.swf
           16 this指针.swf
           7指针对数值的操作.swf
           9.3 为什么使用指针.swf
           9.2 为什么使用指针.swf
           18.2指针的赋值运算.swf
           9.5用指针删除堆中空间.swf
           19.3指向常量的常指针.swf
           17指针的常见错误.swf
           1什么是地址.swf
           4指针与类型.swf
           6 容易混淆的概念.swf
           19.2指向常量的指针.swf
           3.1重载前置自加运算符.swf
           10.2转换类型运算符.swf
           1运算符重载.swf
           8.1重载加法运算函数operator+.swf
           2在成员函数中实现自加.swf
           6.2取消创建临时对象.swf
           10.3转换类型运算符.swf
           9.4重载赋值运算函数operator=.swf
           11重载限定.swf
           本章答疑.swf
           9.6重载赋值运算函数operator=.swf
           6.1取消创建临时对象.swf
           8.2重载加法运算函数operator+.swf

我用夸克网盘给你分享了「05、2025计算机二级C语言资料」,点击链接或复制整段内容,打开「夸克APP」即可获取。
/~b81039deOk~:/

本文隐藏内容 登录 后才可以浏览


生活不止苟且,还有我喜爱的海岸.