C++习题题型汇总（学习笔记）

于 2023-03-26 11:13:34 发布
阅读量1k 收藏 19
点赞数 4
文章标签： c++ 开发语言 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50218610/article/details/129477400
版权
本文详细介绍了C++中的基本概念，包括函数、类、面向对象特性、内存管理和数据类型。讨论了函数重载、虚函数、构造函数、析构函数以及动态内存分配。还提到了C++中的模板、静态成员、友元、异常处理等高级特性，并举例展示了错误和修正后的代码示例。
摘要由CSDN通过智能技术生成
  1. 填空题

在C++语言结构化程序中，函数是程序的基本组成单元；

在C++语言的面向对象设计框架中，类是程序的基本组成单元。

文件按照数据存放格式区分，一类是文本文件，另一类是二进制文件

三种基本控制结构：顺序，条件分支，循环结构

不能说明为内联函数：循环，switch

多条继承路径有一个公共的基类，如果想使这个公共的基类只产生一个拷贝，则可以使这个基类说明为：虚基类

else总是与最接近的还未配对的if配对

C++两种用户自定义的数据类型：结构体，枚举类型

四大特征：抽象，继承，封装，多态

\0表示空字符，作为字符串结束符使用

假定p是一个指向整数对象的指针，则用*p表示该整数对象，&p表示指针变量p的地址

一个指针类型的对象占用内存4个字节存储空间

关键字case后面的表达式必须是整型：常量

枚举类型中的每一个枚举值都是一个枚举常量，它的值为一个整数

一个函数由函数头和函数体组成

程序的编译是以文件为单位进行的

C++提供的预处理命令有宏定义命令，条件编译命令和文件包含命令。

定义外部变量时，不能存储类说明符extern，而声明外部变量时用它

调用系统函数时，要先使用#include命令包含该系统函数的原型语句所在的头文件

如果一个函数定义使用了static修饰，则该函数不允许被其他条件中的函数调用

对象由一组数据和一组操作构成

include的意义是：包含头文件

函数的声明、定义和调用称为函数三部曲

const关键字可以修饰对象和成员函数，const对象不能被更新；const成员函数不能更新对象的数据成员

友元：提高程序的运行效率

C++源程序：类说明文件、类实现文件和类使用文件

类的私有成员只能被成员函数和友元函数访问

抽象类的派生类可以实例化的必要条件：实现了所有的纯虚函数

C++中的ostream类的直接基类是ios类

类模板的两种形式参数：类型参数、普通参数

一个函数的函数体就是一条复合语句

使用#include命令可以包含一个头文件，也可以包含一个程序文件

  1. 简答题

(1)c++语言和C语言的区别与联系

C语言是面向过程的，C++是面向对象的

C++是从C语言发展过来的

C语言结构体中只有成员变量，没有成员方法，而在C++中结构体中，可以有成员变量，又可以有成员方法

(2)判断一段程序是否C编译程序还是C++编译程序编译的（cplusplus）

(3)引用和指针的区别：

指针：通过某个指针变量指向一个对象后，对它所指向的变量进行间接操作。

引用：目标变量的别名，对引用的操作就是对目标变量的操作。

引用必须被初始化，指针不必；

不存在指向空值的引用，但存在指向空值的指针

(4)C和C++中的struct的区别

C中无保护行为，且不能定义函数，但可以有函数指针

C++中，有保护行为，默认为public，能够定义函数

备注：类的访问权限默认和默认继承权限是private，只能间接初始化

(5)对于一个频繁使用的短小函数，C语言中用宏定义，在C++中用内联函数

(6)virtual和inline的含义分别是？

inline是一种用于实现的关键字，而不是用于声明的关键字

虚函数：如果希望派生类能够重新定义基类的方法，则在基类中将该方法定义为虚方法，这样就可以启用动态联编，

内联函数的特点：为了提高函数的运行效率

(7)编译工具条内的Debug和Release选项含义？

Debug调试版本，包含调试信息，并且不做任何优化，运行时需要相应的运行库

Release发布版本，往往进行了各种优化，不含调试代码和信息，直接可以运行

(8)有了malloc/free为什么还要new/delete？

malloc与free是标准库函数，new/delete是c++的运算符，它们都可以用于申请动态内存和释放内存（malloc和free不在编译器控制权限之内,所以需要new来动态分配内存和初始化工作，delete来清理和释放内存）

(9)const和#define的比较，const有什么优点？

const常量有数据类型，而宏常量没有数据类型

有些集成化调试工具可对const常量进行调试，但不能对宏常量进行调试。

(10)函数assert的用法？

断言assert是仅在debug版本起作用的宏，用于检查“不应该”发生的情况，程序员可以把assert看成一个在任何系统状态下都可以安全使用的无害测试手段

(11)C++不是类型安全的，可以进行强制转换

(12)关键字：已被C++语言本身使用，不能作为其他用途使用的单词

标识符：为程序中各种需要命名的元素所起的名称

(13)C++语言程序主要由哪些基本组成部分构成？

预处理命令（宏定义命令--define,文件包含命令include，条件编译命令）

输入/输出

函数

语句

变量

其他

(14)如果在申请动态内存时找不到足够的内存块，malloc和new，将返回NULL指针，宣告内存申请失败，如何处理内存耗尽？

判断指针为是否为NULL，如果是，马上用return终止本函数

判断指针是否为NULL，如果是，马上用exit终止程序运行，

为new和malloc设置异常处理函数

(15)使用堆空间的原因？

直到运行时才知道一个对象需要多少内存空间

(16）堆和栈的区别

栈的空间由操作系统自动分配/释放，空间有限

堆上的空间手动分配/释放，是很大的自由存储区

(17)全局变量和局部变量

全局变量：定义在所有函数之外，并且在其作用域内的所有函数都可以访问（全局数据区）

局部变量：局部函数内部，甚至局部循环体等内部存在（栈区）

通过内存分配的位置来知道的

(18)explicit和protected

explicit关键字用来修饰类的构造函数，表明该构造函数是显式的

protected 成员只有该类的成员函数及其派生类的成员函数可以访问

(19)const关键字，有哪些作用？

欲阻止一个变量被改变；

类的成员函数，指定为const，表明是一个常函数

对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const,或二者同时为const

在一个函数声明中，const可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值

(20)面向对象的三个基本特性

封装：将客观事物抽象成类，每个类对自身的数据和行为实行protection

继承：实现继承，可视继承，借口继承

多态：允许将子类类型的指针赋值给父类类型的指针

(21)重载、重写、重定义

重载：多个同名函数，参数表不同

重定义：继承，派生类与基类的函数同名，屏蔽基类的函数

重写：子类重新定义父类虚函数的方法

(22)多态的作用

隐藏实现细节，代码重用

接口重用

(23)inline可以是虚函数，构造函数不能是虚的，只能有虚的析构函数

(24)C++中的模板

快速建立具有类型安全的类库集合和函数集合，它的实现，方便了大规模的软件开发

可移植性，与平台无关；

可用于基本数据类型；

编译时而不是运行时检查数据类型，类型安全

类型无关，具有高复用性

用来创建动态增长和减小的数据结构

(25)只有当建立了对象后系统才会对其分配内存，类不是一个实体，而是一种抽象的类型

(26)友元关系有何性质？

友元关系是不能传递的，不能被继承

友元关系是单向的，不具有交换性

备注：union联合是一种特殊的类，一个union可以有多个数据成员，这些数据成员共同使用同一片存储空间，分配给一个union对象的存储空间至少要容纳它的最大数据成员；

和struct相同，union的成员都是公有的；

union中不能含有虚函数，不能继承其他的类，也不能作为基类使用

为union的一个数据成员赋值，会令其他数据成员变成一个未定义的状态

(27)静态成员和静态成员函数

类的静态成员变量是生命周期与类的绑定，静态成员变量的作用域也是类

类的静态成员函数只能访问类的静态成员

(28)构造函数：函数名和类名相同，可以重载，公有访问属性，无函数返回类型，对象被创建后自动调用，可以在类外和类内定义

拷贝构造函数：与类同名，没有返回类型，只有一个该类对象的引用作为参数

析构函数：名字加~，没有参数，不能重载，在生存期结束后自动执行清理工作

(29)this指针，成员函数在访问成员时有一个隐含的指针变量this,指的是调用成员函数的对象

(30)深浅拷贝

浅拷贝是简单的赋值操作

深拷贝是在堆区重新申请空间，进行拷贝操作

(31)类和数据类型有何关系？

类相当于一种包含函数的自定义数据类型；

类和对象的关系就像数据类型和变量的关系一样

(32)函数重载和虚函数在概念和使用方式上的区别

重载：用于普通函数和成员函数；虚函数：成员函数

重载能用于构造，虚函数不能用于构造

重载时编译期间，属于静态关联；虚函数是运行阶段，属动态关联

重载不能分属于两个不同继承层次的类；虚函数是派生类对基类的成员函数重新定义

重载的函数必须具有相同函数名，参数类型和参数个数至少有一个不一样

(33)函数模板和类模板的区别

函数模板的实例化：编译程序在处理函数调用时自动完成的

类模板的实例化：程序员在程序中显式的指定

备注：所有指针变量占用内存单元的数量都是相同的

赋值兼容原则：凡是基类能够解决的问题，公有派生类都能够解决

析构函数总是要求虚函数，以此实现撤销对象时的多态性，如果基类的析构函数不是虚函数，派生类的析构函数用不上，会造成资源的泄露。

(34)函数参数中，引用与地址传递的异同点

相同点：引用和地址传递都能对实参进行改变

不同点：地址传递是通过地址间接访问某个变量，而引用是直接通过某个别名直接访问某个变量，另外引用必须初始化

(35)构造函数有什么特征

类的成员函数，可以写在类定义体内，也可以写在类定义体外

程序中不能直接调用构造函数，创建对象时系统将自动调用构造函数

特殊的函数，函数名和类名相同

构造函数可以重载

(36)class类类型和struct结构体

相同点：都可以封装数据和操作，具有派生性，隐藏性和多态性

不同点：访问权限（class数据和函数访问权限私有，struct数据和函数访问公有）

初始化方式：class只能间接初始化，struct可以直接初始化

(37)请说出函数参数中，结构体和联合体两者类型之间的异同点

相同点：结构体和联合体的声明、定义和使用都是一样的

不同点：结构体的每个成员都有独立的存储空间，联合体的每个成员公用一个存储空间

(38)什么是友元？

友元是能够使得普通函数直接访问类的隐藏的数据，避免了类成员函数的频繁调用，可以节约处理器的开销，提高了程序的效率

(39)auto,register,static三个关键字在程序中的用途

auto自动型或堆栈型，采用堆栈方式存储空间，声明的变量只能在某个程序范围内使用

register寄存器型，将所声明的变量放入CPU的寄存器存储空间中，加快程序运行速度，只能用于声明int和char

static静态存储类型：static存储类型的变量在内存中以固定地址存放，静态数据成员在声明时必须在前面加关键字static

(40)什么叫消息？什么叫对象？什么叫类？

消息：是对象之间相互请求和相互协作的途径，是要求某个对象执行某个功能操作的规格说明

类：是一种抽象的数据类型，它将完成某特定功能的数据和对数据的操作封装在一起

对象：是指具有某些属性和功能的单一个体

  1. 改错题
//函数fun用以求某正整数的阶乘值
void fun(n) {
    int i;
    double f = 0;
    if (n < 0) {
        cout << "Data Error";
        return -1;
    }
    for (i = 1; i < n; i++) {
        f = f * i;
        return f;
    }
}
int main() {    
    int n;
    cout << "Input n;";
    cin >> n;
    cout<<n<<"!="<<fun(n)<<endl;
    system("pause");
    return 0;
}
//返回类型 参数类型 数据类型
double fun(int n) {
    int i;
    double f = 1.0;
    if (n < 0) {
        cout << "Data Error";
        return -1;
    }
    for (i = 1; i < n; i++) {
        f = f * i;
        return f;
    }
}
//将一维数组按升序排列
void sort(int p, int n) {
    int i, j, temp;
    for (i = 1; i < n - 1; i++) {
        for (j = 1; j < n; j++) {
            if (p[i] < p[j]) {
                temp = p[i];
                p[i] = p[j];
                p[j] = temp;
            }
        }
    }
}
void main(void) {    
    int a[6] = { 1,3,2,5,4,6 }, * pi, i;
    pi=a[0];
    sort(pi, 6);
    for (i = 0; i < 6; i++) {
        cout << a[i] << "\t";
        cout << endl;
    }
    system("pause");
    return 0;
}
//改正版本
//将一维数组按升序排列
void sort(int p[], int n) {
    int i, j, temp;
    for (i = 1; i < n - 1; i++) {
        for (j = 1; j < n; j++) {
            if (p[i] < p[j]) {
                temp = p[i];
                p[i] = p[j];
                p[j] = temp;
            }
        }
    }
}
int main() {    
    int a[6] ={ 1,3,2,5,4,6 }, *pi, i;
    pi=a;
    sort(pi, 6);
    for (i = 0; i < 6; i++) {
        cout << a[i] << "\t";
        cout << endl;
    }
    system("pause");
}
class one {
    int a1, a2;
public:
    void initial(int x1, int x2) {
        a1 = x1;
        a2 = x2;
    }
};
int main() {    
    one data(2,3);
    cout << data.a1 << endl;
    cout << data.a2 << endl;
    system("pause");
    return 0;
}
//改错版本
class one {
public:
    int a1, a2;
public:
    one(int x1, int x2) {
        a1 = x1;
        a2 = x2;
    }
};
int main() {    
    one data(2,3);
    cout << data.a1 << endl;
    cout << data.a2 << endl;
    system("pause");
    return 0;
}
#include<iostream>
using namespace std;
#include<conio.h>
class Tpoint {
    double x, y;
    Tpoint(double a, double b) {
        x = a;
        x = b;
    }
    friend double distance(Tpoint a, Tpoint b);
};
double Tpoint::distance(Tpoint a, Tpoint b) {
    double dist;
    dist = sqrt((a.x - b.x) * (a.x - b.x) * (a.y - b.y) * (a.y - b.y));
    return dist;
}
int main() {    
    Tpoint p1(2,2),p2(5,5);
    cout << "上述两点之间的距离：" <<p1. distance(p1, p2) << endl;
    getch();
    system("pause");
    return 0;
}
//改错
#include<iostream>
using namespace std;
#include<conio.h>
class Tpoint {
public:
    double x, y;
    Tpoint(double a, double b) {
        x = a;
        y = b;
    }
    friend double distance(Tpoint a, Tpoint b);
};
double distance(Tpoint a, Tpoint b) {
    double dist;
    dist = sqrt((a.x - b.x) * (a.x - b.x) * (a.y - b.y) * (a.y - b.y));
    return dist;
}
int main() {    
    Tpoint p1(2,2),p2(5,5);
    cout << "上述两点之间的距离：" <<distance(p1, p2) << endl;
    system("pause");
}

c++ 中getch()的用法

所在头文件：conio.h

　　函数特点：从控制台读取一个字符，但不显示在屏幕上

　　函数原型：int getch(void)

　　返回值：读取的字符

//下列程序求字符串长度
int fun(char s) {
    int i = 0;
    while (s[i] != '\n') {
        i++;
    }
    return i;
}
int main() {    
    char s[80];
    cin.getline(s, 80);
    cout << "length:" << fun(s) << endl;
    system("pause");
    return 0;
}
//改错版本
//下列程序求字符串长度
int fun(char s[]) {
    int i=0;
    while (s[i]!= '\0') {    
        i++;
    }
    return i;
}
int main() {    
    char s[80];
    cin.getline(s, 80);//读一行字符
    cout << "length:" << fun(s) << endl;
    system("pause");
    return 0;
}
//下列程序功能是求x的y次方(缺省是x的2次方)
double fun(double x, double y) {
    int i;
    double s = 1;
    for (i = 1; i < y; i++) {
        s = s * x;
        return s;
    }
}
int main() {    
    double x = 2.5, y = 3;
    cout << "pow(2.5,2):" << fun(x) << endl;
    cout << "pow(2.5,3):" << fun(x, y) << endl;
    system("pause");
    return 0;
}
//改错后
//下列程序功能是求x的y次方(缺省是x的2次方)
double fun(double x, double y=2) {
    int i;
    double s = 1;
    for (i = 1; i <= y; i++) {
        s = s * x;
    }
    return s;
}
int main() {    
    double x = 2.5, y = 3;
    cout << "pow(2.5,2):" << fun(x) << endl;
    cout << "pow(2.5,3):" << fun(x, y) << endl;
    system("pause");
    return 0;
}
class Point {
private:
    int x, y;
    void init(int a, int b) {
        x = a;
        y = b;
    }
    void show() {
        cout << "x= " << x << "y= " << y << endl;
    }
};
int main() {    
    Point a(24, 50);
    a.show();
    system("pause");
    return 0;
}
class Point {
private:
    int x, y;
    void init(int a, int b) {
        x = a;
        y = b;
    }
    void show() {
        cout << "x= " << x << "y= " << y << endl;
    }
};
int main() {    
    Point a(24, 50);
    a.show();
    system("pause");
    return 0;
}
class Point {
private:
    int x, y;
public:
    Point(int a, int b) {
        x = a;
        y = b;
    }
    void show() {
        cout << "x= " << x << "y= " << y << endl;
    }
};
int main() {    
    Point a(24,50);
    a.show();
    system("pause");
    return 0;
}
class Amplifier {
    float invol, outvol;
public:
    Amplifier(float vin, float vout) {
        invol = vin;
        outvol = vout;
    }
    float gain() {
    }
};
Amplifier::float gain() {
    return outvol / invol;
}
int main() {    
    Amplifier amp(5.0, 10.0);
    cout << "\n\n The gain is=>" << gain() << endl;
    system("pause");
    return 0;
}
//改正版
class Amplifier {
    float invol, outvol;
public:
    Amplifier(float vin, float vout) {
        invol = vin;
        outvol = vout;
    }
    float gain() {
    }
};
float Amplifier::gain() {
    return outvol / invol;
}
int main() {    
    Amplifier amp(5.0, 10.0);
    cout << "\n\n The gain is=>" << amp.gain() << endl;
    system("pause");
    return 0;
}

备注：①在类内部不能对数据成员直接赋值

②int i,int j调用时，既有一个参数，也有两个参数，且没有重载，所以参数需要带默认值，

所以int i,int j=0;

③基类时抽象类，不能被实例化，所以在派生类中不能调用初始化基类对象

④cout<<this->x=x<<endl要加括号

⑤静态成员变量：静态成员变量只被初始化一次，下一次初始化将会跳过

经过static修饰的成员变量属于这个类，而不再仅仅属于某个对象

静态成员函数：不可以调用类的非静态成员；静态成员函数不含this指针

⑥private:因为name如果是私有的，在派生类中无法访问，而基类没有提供成员函数来访问

⑦指针即地址没有被赋值，如*p=i,改为p=&i；

int a=5,b=10,c;
int &pa=a,&pb=b;
pa=pb;

若用数组名作为调用函数的实际参数，则传递给形式参数的是：数组首地址

#include<iostream>
using namespace std;
#include<string.h>
const double PI;
PI = 3.1415;
class Shape {
public:
    virtual double area() == 0;
};
class Circle :public Shape {
public:
    Circle(double rr) { this->radius = rr; }
    double area(double radius) { return PI * radius * radius;}
    ~Circle();
protected:
    double radius = 0;
};
int main() {    
    Shape s;
    Shape* p = new Circle;
    cout << p->radius << endl;
    cout << p.area() << endl;
    system("pause");
    return 0;
}
//该正版本
#include<iostream>
using namespace std;
#include<string.h>
const double PI=3.1415;
//常量必须初始化，且不能修改
class Shape {
public:
    virtual double area() = 0;
};
class Circle :public Shape {
public:
    Circle(double rr) { this->radius = rr; }
    double area() { return PI * radius * radius;}//该函数不应有参数
    ~Circle() {};//析构函数应该为
protected:
    double radius ;//应更正为这
};
int main() {    
    //抽象类不能定义对象  Shape s;
    Shape* p = new Circle(3.0);
    //radius不是Shape的成员，不能访问  cout << p->radius << endl;
    cout << p->area() << endl;
    delete p;//应该增加语句
    system("pause");
    return 0;
}
  1. 编程题
#include<iostream>
using namespace std;
#include<string.h>
//定义一个Matrix（矩阵）类，在该类定义中包括数据成员：k，为一个3*3的整数矩阵；成员函数：构造函数
//用一个矩阵对k进行初始化；display()显示矩阵k的内容，k_mul(int *x,int *y)将矩阵k与向量x相乘，结果
//存放在向量y中，在main函数中，要求创建matrix类对象，并对该对象进行简单的测试。
class Matrix {
private:
    int k[3][3];
public:
    Matrix(int p[3][3]);
    void display();
    void k_mul(int* x, int* y);
};
Matrix::Matrix(int p[3][3]) {
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            k[i][j] = p[i][j];
        }
    }
}
void Matrix::display() {
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            cout<<k[i][j]<<endl;
        }
    }
}
void Matrix::k_mul(int* x, int* y) {
    for (int i = 0; i < 3; i++) {
        y[i] = 0;
        for (int j = 0; j < 3; j++) {
            y[i] += k[i][j] * x[j];
        }
    }
}
int main() {    
    int key[3][3] = { {1,2,3},{4,5,6},{7,8,9} };
    int xx[] = {1,2,3 };
    int yy[3];

    Matrix m(key);
    m.display();
    m.k_mul(xx, yy);
    for (int i = 0; i < 3; i++) {
        cout << xx[i] << endl;
    }
    system("pause");
    return 0;
}
#include<iostream>
using namespace std;
#include<string.h>
/*编写程序声明类Number,实现60进制数的加减运算。数据成员：整数value,代表该数的十进制数值。
成员函数：构造函数；get_value():返回value的数值；请采用成员函数的方式对类Number重载+和-运算符，
用于实现两个数按60进制进行的加、减运算；在main函数中进行测试*/
class Number {
private:
    int value;
public:
    Number(int v=0):value(v%60){}
    int get_value() {
        return value;
    }
    Number operator+(const Number&);
    Number operator-(const Number&);
};
Number Number::operator+(const Number& n2) {
    int result;
    result = value + n2.value;
    result %= 60;
    return Number(result);
}
Number Number::operator-(const Number& n2) {
    int result;
    result = value - n2.value;
    if (result < 0)
        result += 60;
    return Number(result);      
}
int main() {    
    Number n1(30), n2(50), n3;
    cout << "n1=" << n1.get_value() << "n2=" << n2.get_value() << endl;
    n3 = n1 + n2;
    cout << "n3=n1+n2" << n3.get_value() << endl;
    n3 = n1 - n2;
    cout << "n3=n1-n2" << n3.get_value() << endl;
    system("pause");
    return 0;
}
#include<iostream>
using namespace std;
#include<string.h>
class B {
public:
    B(int i) {
        cout << "constructing B:" << i << endl; 
    }
};
class C {
public:
    C(int j) {
        cout << "constructing C:" << j << endl;
    }
};
class A :public C {
public:
    A(int a, int b, int c) :C(c), c1(a), b1(b) {
        counter++;
        p = new C(c);
        cout << "constructing A:" << a + b << endl;
    }
        static int getCounter(){
            return counter;
        }
    ~A() { delete p;}
private:
    B b1;
    C c1;
    C* p;
    static int counter;
};
int A::counter = 0;
int main() {    
    A obj(3, 4, 5);
    cout << "The number of class A object is:" << A::getCounter();
    system("pause");
    return 0;
}
//输出
constructing C:5
constructing B:4
constructing C:3
constructing C:5
constructing A:7
The number of class A object is:1

定义一个整形数集合类Set，请通过创建动态分配的整数数组（使用new运算符）存放整数值，且数组的

大小要能够根据包含元素的个数动态的变化。集合中，元素的顺序无关紧要，每个元素至多出现一次。实现如下函数：(1)构造函数创建一个空集(2)复制构造函数实现深拷贝(3)add函数向集合中插入一个整数

(4)析构函数，在main函数中对上述函数进行测试

#include<iostream>
using namespace std;
#include<string.h>
/*定义一个整形数集合类Set，请通过创建动态分配的整数数组（使用new运算符）存放整数值，且数组的
大小要能够根据包含元素的个数动态的变化。集合中，元素的顺序无关紧要，每个元素至多出现一次。实现
如下函数：(1)构造函数创建一个空集(2)复制构造函数实现深拷贝(3)add函数向集合中插入一个整数
(4)析构函数，在main函数中对上述函数进行测试*/
class Set {
public:
    Set();
    Set(const Set& s);
    ~Set();
    void add(int i);
    int getSize() { return size; }
private:
    int* p;
    int size;
};
Set::Set() {
    p = NULL;
    size = 0;
}
Set::Set(const Set& s) {
    if (s.size == 0) {
        p = NULL;
        size = 0;
    }
    else {
        size = s.size;
        p = new int[size];
        for (int i = 0; i < size; i++) {
            p[i] = s.p[i];
        }
    }
}
void Set::add(int i) {
    int flag = 0;
    if (size == 0) {
        p = new int[1];
        p[0] = i;
        size = 1;
    }
    else {
        for (int j = 0; j < size; j++) {
            if (p[j] = i) {
                flag = 1;
                break;
            }
        }
        if (flag == 0) {
            int* p1 = new int[size];
            for (int j = 0; j < size; j++) {
                p1[j] = p[j];
            }
            p1[size] = i;
            size++;
            delete[]p;
            p = p1;
        }
    }
}
Set::~Set() {
    if (size != 0) {
        delete[] p;
        size = 0;
    }
}
int main() {    
    Set s1;
    s1.add(1);
    s1.add(1);
    s1.add(3);
    Set s2 = s1;
    cout << "the size of s1:" << s1.getSize() << endl;
    cout << "the size of s2:" << s2.getSize() << endl;
    system("pause");
    return 0;
}
设计类A，私有整型变量m,公有构造函数和printN函数，后者输出m的值，设计类B,公有继承类A，私有整型
变量n,类B具有构造函数，printN函数，printAll 函数，printN 输出 n，printAll 输出 m 和 n，
主函数中创立 B 的对象，调用 printAll
#include<iostream>
using namespace std;
#include<string.h>
class A {
public:
    A() {};
    A(int ma) {    
        this->m = m;
    }
    void printN() {
        cout << m << endl;
    }
    void init();
private:
    int m;
};
void A::init() {
    cout << this->m <<endl;
}
class B :public A
{
private:
    int n;
public:
    using A::A;
    B(){};
    B(int n) {
        this->n = n;
    }
    
    void printN() {
        cout << n << endl;
    }
    void printAll() {
        init();
        cout << n << endl;
    }
};
int main() {    
    B b;
    b.printAll();
    system("pause");
    return 0;
}
公司 200 名员工，编写程序，将各位员工的工资从键盘输入到数组 salary 中，然后计算所
有员工的平均工资 avgSalary 输出
int main() {    
    int a[200];
    double avgSalary;
    double avg=0.0;
    for (int i = 0; i < 200; i++) {
        cin >> a[i];
        avgSalary += a[i];
    }
    avgSalary = avg /200;
    cout << avg << endl;
    system("pause");
    return 0;
}
/*编写函数prime(int i),判断一个正整数是否是质数，在主程序中实现输入输出*/
bool prime(int i);
int main() {
    int i;
    cout << "请输入一个数" << endl;
    cin >> i;
    if (prime(i)) {
        cout << i << "是质数" << endl;
    }
    else {
        cout << i << "不是质数" << endl;
    }
    system("pause");
    return 0;
}
bool prime(int i) {
    int j,k;
    bool flag = true;
    k = sqrt(i);
    for (int j = 2; j <= k; j++) {
        if (i % j == 0) {
            flag = false;
            break;
        }
    }
    return flag;
}
#include<iostream>
using namespace std;
#include<string.h>
/*编写递归函数GetPower（int x,int y），计算x的y次幂，在主程序中实现输入输出*/
long GetPower(int x, int y);
int main() {
    int number, power;
    long answer;
    cout << "请输入一个整数：" << endl;
    cin >> number;
    cout << "请输入指数：" << endl;
    cin >> power;
    answer = GetPower(number, power);
    cout << number << "的" << power << "次幂是" << answer << endl;
    system("pause");
    return 0;
}
long GetPower(int x, int y) {
    if (y ==1) {
        return x;
    }
    else {
        return (x * GetPower(x, y - 1));
    }
}
#include<iostream>
using namespace std;
#include<string.h>
/*编写递归函数GetPower（int x,int y），计算x的y次幂，在主程序中实现输入输出*/
long GetPower(int x, int y);
int main() {
    int number, power;
    long answer;
    cout << "请输入一个整数：" << endl;
    cin >> number;
    cout << "请输入指数：" << endl;
    cin >> power;
    answer = GetPower(number, power);
    cout << number << "的" << power << "次幂是" << answer << endl;
    system("pause");
    return 0;
}
long GetPower(int x, int y) {
    if (y ==1) {
        return x;
    }
    else {
        return (x * GetPower(x, y - 1));
    }
}
#include<iostream>
using namespace std;
#include<string.h>
/*编写一个函数，统计一个英文句子中字母的个数，在主程序中实现输入输出*/
int count(char* str) {
    int i, num = 0;
    for (i = 0; str[i]; i++) {
        if ((str[i] >= 'a' && str[i] <= 'z') || (str[i] >= 'A' && str[i] <= 'Z'))
            num++;
    }
    return num;
}
int main() {
    char text[100];
    cout << "输入一个英语句子：" << endl;
    cin.getline(text,100);
    cout << "这个句子里有：" << count(text) << "个字母" << endl;
    system("pause");
    return 0;
}
  1. 基础知识

命名空间：可作为附加信息区分不同库中的相同名称的函数、类、变量等，本质上命名空间就是定义了一个范围。

备注：有不连续的命名空间和嵌套命名空间。

逻辑运算符：与或非

杂项运算符：逗号运算符（整个逗号表达式的值以逗号分隔的列表中最后一个表达式的值）

成员运算符（.和->）：运用引用类、成员和共用体的成员；指针运算符（&，*）：返回变量的地址和指向一个变量。

fstream:该类数据类型通常表示文件流，且同时具有ofstream和ifstream两种功能，意味着可以创建文件，向文件写入信息，从文件读取信息，

文件位置指针：用于重新定位文件位置指针的成员函数，

异常是在程序执行期间产生的问题，try catch throw;通过继承和重载exception类来定义新的异常

C++的动态内存：（栈）在函数内部声明的所有变量都将占用栈内存（堆）这是程序未使用的内存，在程序运行时可用于动态分配内存

函数调用运算符重载：函数调用运算符（）也可以重载；由于重载后使用的方式非常像函数的调用，因此称为仿函数；仿函数没有固定写法，非常灵活。

C++变量必须用唯一名称标识，这些唯一的名称称为标识符

规则：名称可以包含数字、字母、下划线；

名称必须以字母和下划线开头

名称不能包含空格或特殊字符，如！，#，%

名称区分大小写

保留字不能做名称

类型兼容原则：

在需要基类对象的地方，可以使用公有派生类的对象来替代

派生类对象可以作为基类对象来使用，但只能使用从基类继承来的成员

派生类的对象可以赋值给基类对象，派生类的对象可以初始化基类的引用

构造对象的规则需要扩展以控制多重继承，构造函数按下列顺序被调用：

(1)任何虚拟基类的构造函数按照它们被继承的顺序构造

(2)任何非虚拟基类的构造函数按照它们被继承的顺序构造

(3)任何成员对象的构造函数按照它们声明的顺序调用

(4)类自己的构造函数

单例模式是最简单的设计模式之一，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。

单例类只能有一个实例；

单例类必须自己创建自己的唯一实例；

单例类必须给所有其他对象提供这一实例。

在程序编译之前由预处理器来执行宏命令

ones~
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值