填空题
在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)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)什么叫消息？什么叫对象？什么叫类？
消息：是对象之间相互请求和相互协作的途径，是要求某个对象执行某个功能操作的规格说明
类：是一种抽象的数据类型，它将完成某特定功能的数据和对数据的操作封装在一起
对象：是指具有某些属性和功能的单一个体
改错题
//函数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;
}编程题
#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;
}
基础知识
命名空间：可作为附加信息区分不同库中的相同名称的函数、类、变量等，本质上命名空间就是定义了一个范围。
备注：有不连续的命名空间和嵌套命名空间。
逻辑运算符：与或非
杂项运算符：逗号运算符（整个逗号表达式的值以逗号分隔的列表中最后一个表达式的值）
成员运算符（.和->）：运用引用类、成员和共用体的成员；指针运算符（&，*）：返回变量的地址和指向一个变量。
fstream:该类数据类型通常表示文件流，且同时具有ofstream和ifstream两种功能，意味着可以创建文件，向文件写入信息，从文件读取信息，
文件位置指针：用于重新定位文件位置指针的成员函数，
异常是在程序执行期间产生的问题，try catch throw;通过继承和重载exception类来定义新的异常
C++的动态内存：（栈）在函数内部声明的所有变量都将占用栈内存（堆）这是程序未使用的内存，在程序运行时可用于动态分配内存
函数调用运算符重载：函数调用运算符（）也可以重载；由于重载后使用的方式非常像函数的调用，因此称为仿函数；仿函数没有固定写法，非常灵活。
C++变量必须用唯一名称标识，这些唯一的名称称为标识符
规则：名称可以包含数字、字母、下划线；
名称必须以字母和下划线开头
名称不能包含空格或特殊字符，如！，#，%
名称区分大小写
保留字不能做名称
类型兼容原则：
在需要基类对象的地方，可以使用公有派生类的对象来替代
派生类对象可以作为基类对象来使用，但只能使用从基类继承来的成员
派生类的对象可以赋值给基类对象，派生类的对象可以初始化基类的引用
构造对象的规则需要扩展以控制多重继承，构造函数按下列顺序被调用：
(1)任何虚拟基类的构造函数按照它们被继承的顺序构造
(2)任何非虚拟基类的构造函数按照它们被继承的顺序构造
(3)任何成员对象的构造函数按照它们声明的顺序调用
(4)类自己的构造函数
单例模式是最简单的设计模式之一，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。
单例类只能有一个实例；
单例类必须自己创建自己的唯一实例；
单例类必须给所有其他对象提供这一实例。
在程序编译之前由预处理器来执行宏命令
8361
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
