C++期末复习-创新互联

文章目录

• 题型
• • 1、三个阅读程序
  • 2、三个问答
  • • c++语言的特点
    • c++访问控制符特点
    • • public
      • protected
      • private
    • 内存区
    • 动态内存：
  • 3、两题程序填空
  • 4、一道程序大题
• 考点
• • 1.c++相对于c的改进
  • • 联系
    • 区别
  • 2.面向对象程序设计主要特征
  • • 抽象
    • 封装
    • 继承
    • 多态
  • 3.值传递
  • • 值传递
    • 指针传递
  • 4.类的析构函数、成员函数、构造函数区别
  • • 成员函数
    • 构造函数
    • 析构函数
  • 5.类的定义
  • 6.继承的概念和性质
  • • 父类类型的子类对象
  • 7.抽象类的概念
  • 8.派生类的概念
  • 9.虚函数和多态
  • • 虚函数
    • 纯虚函数
    • 静态多态
    • 动态多态
  • 10.虚继承和多重继承
  • • 多重继承
    • 虚继承
    • 虚继承的构造函数
  • 11.数组定义以及在内存中的分配
  • • 静态数组
    • 动态数组
  • 12.类的静态成员
  • 13.动态链接库
  • 14.封装体
  • 15.指针以及使用
  • 其他
  • • 1、头文件
    • 2、链接属性
    • 3、实参和形参
    • 4、转换构造函数
    • 5、双冒号"::"的作用
    • • 1、作用域符
      • 2、域操作符
      • 3、作用域分解运算符

10余年的湘东网站建设经验，针对设计、前端、开发、售后、文案、推广等六对一服务，响应快，48小时及时工作处理。网络营销推广的优势是能够根据用户设备显示端的尺寸不同，自动调整湘东建站的显示方式，使网站能够适用不同显示终端，在浏览器中调整网站的宽度，无论在任何一种浏览器上浏览网站，都能展现优雅布局与设计，从而大程度地提升浏览体验。成都创新互联从事“湘东网站设计”,“湘东网站推广”以来，每个客户项目都认真落实执行。题型 1、三个阅读程序 2、三个问答 c++语言的特点

四个主要特点：抽象、封装、继承、多态
C++ 接口（抽象类） 描述了类的行为和功能，而不需要完成类的特定实现。封装是面向对象编程中的把数据和操作数据的函数绑定在一起的一个概念，这样能避免受到外界的干扰和误用。类和对象体现了抽象和封装。

继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行效率的效果。从一个父类派生出多个子类，可以使子类之间有不同的行为，这种行为称之为多态。没有继承就没有多态，继承是多态的前提。

c++访问控制符特点

访问控制符： public、private 和 protected

public

能被本类的成员函数、友元函数、本类的对象、其派生类的成员函数调用。

protected

能被本类的成员函数、友元函数、其派生类的成员函数调用。

private

能被本类的成员函数、友元函数调用。

内存区

一个由C/C++编译的程序占用的内存分为以下五个部分：

栈区(Stack) ： 存放函数的参数值，局部变量等。由编译器自动分配和释放。
堆区(Heap) ：动态内存分配得到的内存空间就是位于堆区。由程序员主动分配和释放，若程序员未主动释放，则程序结束后自动释放。
全局/静态存储区：存放全局变量和静态变量，程序结束后自动释放
常量和代码区：存放字符串常量，程序结束后自动释放
代码区：存放函数体的二进制代码

动态内存：

c++新增了new 和 delete字段，new 用来动态分配内存，delete 用来释放内存。
它们可以使用C++的一些新特性，最明显的是可以自动调用构造函数和析构函数。
最好不要和C语言中 malloc()、free() 一起混用。

在这里，我们使用指针为变量动态分配内存。

int* pointVar;
pointVar = new int;
*pointVar = 45;

cout<< *pointVar; 

delete pointVar;

3、两题程序填空 4、一道程序大题 考点 1.c++相对于c的改进 联系

C++是C的超集，兼容大部分C的语法的结构。

区别

	C	C++
思想	面向过程	面向对象
动态管理内存	malloc/free函数	new/delete关键字
数据类型	struct	class
默认访问修饰符	public	private
变量的默认链接属性	外链接	内链接
数组	静态数组	动态数组
其他		重载、引用

2.面向对象程序设计主要特征

四个主要特点：抽象、封装、继承、多态

抽象

C++ 接口（抽象类） 接口描述了类的行为和功能，而不需要完成类的特定实现。
类体现了抽象。

封装

封装是面向对象编程中的把数据和操作数据的函数绑定在一起的一个概念，这样能避免受到外界的干扰和误用。
对象体现了封装。

继承

继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行效率的效果。

多态

从一个父类派生出多个子类，可以使子类之间有不同的行为，这种行为称之为多态。
没有继承就没有多态，继承是多态的前提。

3.值传递 值传递

形参是实参的拷贝，改变形参的值并不会影响外部实参的值。从被调用函数的角度来说，值传递是单向的（实参->形参），参数的值只能传入，不能传出。当函数内部需要修改参数，并且不希望这个改变影响调用者时，采用值传递。

指针传递

形参为指向实参地址的指针，当对形参的指向操作时，就相当于对实参本身进行的操作

4.类的析构函数、成员函数、构造函数区别 成员函数

类的成员函数是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。类成员函数是类的一个成员，它可以操作类的任意对象，可以访问对象中的所有成员。

class Line
{
   public:
      double length; 
      double getVolume(void)
      {
         return length;
      }
};

构造函数

类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。
不会返回任何类型，也不会返回 void。
先基类调用，再到派生类。

// 成员函数定义，包括构造函数
Line::Line(void)
{
    cout<< "Object is being created"<< endl;
}

析构函数

类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。
析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀。

调用构造函数的顺序和调用析构函数的顺序相反，先派生类调用，再基类调用。

Line::~Line(void)
{
    cout<< "Object is being deleted"<< endl;
}

5.类的定义

类（Class）是面向对象程序设计实现信息封装的基础。类是一种用户定义的引用数据类型，也称类类型。每个类包含数据说明和一组操作数据或传递消息的函数。类的实例称为对象。

class  类名{
访问范围说明符：
    成员变量

访问范围说明符：
    成员函数声明
    ...
};

成员函数的实现可以位于类的定义之外，格式如下：

返回值类型  类名:函数名()
{
    函数体
}

定义类之后，就可以定义对象了。定义对象的基本方法如下：

类名  对象名;

例子:

#includeusing namespace std;
class CRectangle
{
public:
    int w, h; //成员变量，宽和高
    void init( int w_,int h_ ); //成员函数，设置宽和高
    int area(); //成员函数， 求面积
}; //必须有分号
void CRectangle::init( int w_,int h_ )
{
    w = w_;  h = h_;
}
int CRectangle::area()
{
    return w * h;
}

int main( )
{
     int w,h;
     cin >>w >>h;
     r.init( w,h);
     cout<< "It's area is "<< r.area()<< endl;
     return 0;
}

6.继承的概念和性质

概念：如果一个类别B“继承自”另一个类别A，就把这个B称为“A的子类”。
性质：继承可以使得子类具有父类别的各种属性和方法，而不需要再次编写相同的代码。

在类的继承中，基类成员的访问特性在派生类中可以改变。

父类类型的子类对象

把子类对象直接赋值给父类对象（即父类对象＝子类对象），子类对象赋值给父类对象，仅仅把继承自父类部分成员函数赋值给父类对象，赋值完成后等号左边依然是一个父类对象，不能使用子类扩展的成员函数。

7.抽象类的概念

C++ 使用抽象类来实现接口，接口描述了类的行为和功能，而不需要完成类的特定实现。

#includeusing namespace std;
// 基类
class Shape 
{
public:
   // 提供接口框架的纯虚函数
   virtual int getArea() = 0;
protected:
   int width;
   int height;
};
 
// 派生类
class Rectangle: public Shape
{
public:
   int getArea()
   { 
      return (width * height); 
   }
};

8.派生类的概念

超类/父类/基类=>子类/派生类
在构建新类的过程中，新建立的类被称为“子类”或者“派生类”；而被继承的包含相同特征的类称为“父类”或者“基类”。 派生类继承了基类的全部成员，并且可以增加基类所没有的数据成员和成员函数，以满足描述新对象的需求。

9.虚函数和多态 虚函数

虚函数，是指被virtual关键字修饰的成员函数。
该函数可以被实现，同时允许用基类的指针来调用子类的该函数。

纯虚函数

纯虚函数是一种特殊的虚函数，代表该函数没有被实现，它的实现留给派生类去做。
定义纯虚函数是为了实现一个接口，起到一个规范的作用。

class Shape {
   public:
      // pure virtual function
      virtual int area() = 0;
};

= 0告诉编译器，函数没有主体，上面的虚函数是纯虚函数。

静态多态

静态多态就是在系统编译期间就可以确定程序执行到这里将要执行哪个函数。
例如：函数的重载，对象名.操作符，执行成员函数等。

动态多态

动态多态利用虚函数实现了运行时的多态。
基类定义虚函数，在子类中重写基类函数，再定义一个指向基类对象的指针，然后使该指针指向由该基类派生的子类对象，再然后用这个指针来调用改虚函数，就能实现动态多态。

10.虚继承和多重继承 多重继承

多重继承指的是一个类可以同时继承多个类

class BaseC: public BaseA, public BaseB{
	...
};

虚继承

为了解决多继承时的命名冲突和冗余数据问题，C++ 提出了虚继承，使得在派生类中只保留一份间接基类的成员。
在继承方式前面加上 virtual 关键字就是虚继承。
最常见的场景就是菱形继承：

//间接基类A
class A{};
//直接基类B
class B: virtual public A{};
//直接基类C
class C: virtual public A{};
//派生类D
class D: public B, public C{};

虚继承的构造函数

在普通继承中，派生类构造函数中只能调用直接基类的构造函数，不能调用间接基类的。

在虚继承中，对最终的派生类来说，虚基类是间接基类，最终派生类的构造函数必须要调用虚基类的构造函数。

11.数组定义以及在内存中的分配

数组是在内存中连续存储的具有相同类型的一组数据的集合。元素可通过数组索引访问, 最低地址对应于第一个元素，最高地址对应于最后一个元素。
静态数组名用sizeof可以知道数组实际所占的内存大小，而指向数组的指针占用空间即为普通指针的大小。当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。

静态数组

静态初始化：给出初始化值，由系统决定长度。

char ch[]="hello";

动态数组

动态初始化：只指定长度，由系统给出初始化值；

int* Dynamic_Arr3 = new int[size]();     //默认的初始化；

分配一个动态数组，返回一个T类型的指针，指针指向的是数组的第一个元素。
指针导致了动态数组中size可以取0，即返回一个空指针。分配一个空动态数组是合法的。

12.类的静态成员

我们可以使用 static 关键字来把类成员定义为静态的。当我们声明类的成员为静态时，这意味着无论创建多少个类的对象，静态成员都只有一个副本。

13.动态链接库

库是写好的现有的，成熟的，可以复用的代码。

静态库与汇编生成的目标文件一起链接为可执行文件。

静态库的两个问题：空间浪费，更新麻烦。

动态库在程序编译时并不会被连接到目标代码中，而是在程序运行是才被载入。不同的应用程序如果调用相同的库，那么在内存里只需要有一份该共享库的实例，规避了空间浪费问题。
动态库在程序运行时才被载入，也解决了静态库对程序的更新、部署和发布页会带来麻烦。用户只需要更新动态库即可，增量更新。

14.封装体

所有的 C++ 程序都有以下两个基本要素：

• 程序语句(函数)：程序中执行动作的部分。
• 程序数据(成员对象)：数据是程序的信息，会受到函数影响。

封装是面向对象编程中的把数据和操作数据的函数绑定在一起的一个概念，这样能避免受到外界的干扰和误用，从而确保了安全。
数据封装是一种把数据和操作数据的函数捆绑在一起的机制，数据抽象是一种仅向用户暴露接口而把具体的实现细节隐藏起来的机制。

15.指针以及使用

指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。
使用指针时会频繁进行以下几个操作：定义一个指针变量、把变量地址赋值给指针、访问指针变量中可用地址的值。

其他 1、头文件

c

#include

c++

#includeusing namespace std;

iostream负责输入/输出流

后缀为.h的头文件c++标准已经明确提出不支持了，早些的实现将标准库功能定义在全局空间里，声明在带.h后缀的头文件里，c++标准为了和C区别开，也为了正确使用命名空间，规定头文件不使用后缀.h。
因此，当使用时，相当于在c中调用库函数，使用的是全局命名空间，也就是早期的c++实现.

所谓namespace，是指标识符的各种可见范围。C＋＋标准程序库中的所有标识符都被定义于一个名为std的namespace中。
当使用< iostream >的时候，该头文件没有定义全局命名空间，必须使用namespace std；这样才能正确使用cout。

2、链接属性

链接属性（linkage）分为三种——外部（external）、内部（internal）、无（none）

C语言:
对于external属性的标识符，不同文件中出现的多个同名称标识符指向同一个实体。
用extern关键字在声明中指定以引用其他文件中定义的相同标识符。

对于internal属性的标识符，仅在当前文件内该标识符指向同一个实体。
对默认属性为external的标识符，用static关键字在声明中指定让标识符变为internal。

对于none属性的标识符，在每个声明位置都是一个新的实体。C语言中，没有对应的关键字。

默认的链接属性
标识符的默认的链接属性与其出现的位置有关：

• 程序的全局变量、所有函数默认的链接属性为external。
• 其余标识符的默认链接属性为none。

//文件A
int x=0; //默认external
void print(void) {
	printf("Hello World!\n");                   
	return 0;                                              
}   
//文件B
int main(){
	extern int x;
	print();
	return 0;
}

C++：
const变量隐含的具有internal属性

3、实参和形参

实参和形参在数量上、类型上、顺序上必须严格一致。

4、转换构造函数

转换构造函数的作用是将一个其他类型的数据转换成一个类的对象｡
当一个构造函数只有一个参数，而且该参数又不是本类的const引用时，这种构造函数称为转换构造函数。
转换构造函数是对构造函数的重载。
例如：

Complex(double r)   
{  
    real=r;  
    imag=0;  
} 

5、双冒号"::"的作用 1、作用域符

:作用域符分为三种:
1)global scope(全局作用域符），用法（::name)
2)class scope(类作用域符），用法(class::name)
3)namespace scope(命名空间作用域符），用法(namespace::name)

2、域操作符

当全局变量在局部函数中与其中某个变量重名，那么就可以用::来区分

aaa; //全局变量
voidsleep()
{
    aaa; //局部变量
    aaa(局部变量) = aaa(局部变量) *aaa(局部变量) ;
    ::aaa(全局变量) =::aaa(全局变量) *aaa(局部变量);
}

3、作用域分解运算符

比如声明了一个类A，类A里声明了一个成员函数voidf()，但没有在类的声明里给出f的定义，那么在类外定义f时，就要写成voidA::f()，表示这个f()函数是类A的成员函数。例如

classA {};
 
classA::add()  
{}
  

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧

当前名称：C++期末复习-创新互联
本文来源：http://cqcxhl.com/article/dsjoig.html