初学c++

---

前言

自己看了一下学校教学体系，不学c++,但大部分刷题以c++为主，因为主要是以刷题为目的，就找了学院其他学c++专业的复习题和一些网站来进行对c++一个初步学习，如有错误，欢迎评论交流

---

看代码

1.输出hello world

#include<iostream>//c++定义了一些头文件，这些文件包含了程序中必需的或有用的信息
using namespace std;//告诉编译器使用std命名空间
int main(){//程序开始执行的地方
cout << "Hello World";//在屏幕上显示消息Hello World
return 0;//终止main（）函数，并向调用进程返回值0；
}

2.分发饼干

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
    //vector是一个十分有用的容器，能够像容器一样存放各种类型的对象，
    //简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据
    //注意写法vector<int>&a中&不能少
        sort(g.begin(), g.end());
        sort(s.begin(), s.end());
     //sort函数用法：
     //1.对基本类型数组从小到大排序sort（数组名+n1,数组名+n2）;
     //将数组中下标从n1到n2原宿从小到大排序，不包括n2，
     //2.对元素类型为T的基本类型数组从大到小排序，
     //sort(数组名+n1,数组名+n2,greater<T>());
     //3.自定义排序规则
     //sort（数组名+n1,数组名+n2,排序规则结构名）
     //排序规则结构体定义
     //struct 结构名{
     //bool operator()(const T &a1,const T &a2){
     //return ;}
     //};
        int index = s.size() - 1; // 饼干数组的下标
        int result = 0;
        for (int i = g.size() - 1; i >= 0; i--) {
            if (index >= 0 && s[index] >= g[i]) {
                result++;
                index--;
            }
        }
        return result;
    }
};

//三字符组
??=//#
??/   \

1.c++中class是定义类的关键字，c++中也可以使用struct定义类，两者的区别，用class定义的类，如果数据成员或成员函数没有说明，则默认为private(私有的)，而用struct定义的，默认为public（公共的）
2.类是一组数据和对这些数据的操作的封装，类中还有访问权限的控制，其中private只能由本类中的成员函数访问，public可以由类外的成员函数访问

---

a.理论

1.c++基本组成部分

a.三类预处理命令
宏定义（define）
文件包含命令（include）
条件编译命令（if/else/endif）

b.I/O语句

c.函数
c++程序是由若干文件组成，文件是由函数组成

d.语句
函数由若干语句组成

e.变量
由说明语句来定义

f.其他
比如符号常量和注释语句

2.c++基本数据类型

类型名称	长度(字节)
char	1
signed char	1
unisnged char	1
bool	1
short	2
unsigned short	2
int	4
unisnged int	4
long	4
unisnged long	4
float	4
double	8

3. #define <标识常量名称> <常量名称>

4. 说明变量有四种存储类型
1）auto【堆栈型】
用auto存储的变量说明局部于某个程序范围内
2）register【寄存器】
将声明变量放入CPU寄存器空间，这样可以加快程序运行速度
3）static【静态存储类型】
static存储的变量在内存中以固定地址存放，下次调用函数时，不在重新说明，还保存用上次调用的数值
4）extern【外部参照引用型】
一般用于在函数之间传递数据

5.常量化变量，
将一个变量说明为一个常量，该变量在执行过程中值不能改变

6.左值，出现在赋值表达式左边的值
右值，出现在赋值表达式右边的值

7.指针
内存单元地址称为指针
存放地址的变量称为指针变量
指针指向的内存中的数据称为指针的目标
空指针：指针变量的内容为0的状态
指针运算的实质就是地址的运算
数组的指针是指数组在内存的起始地址
void型指针变量是指一种不确定数据类型的指针变量，它可以通过强制类型转换让该变量指向任意类型的数组或变量

8.const型指针
三种形式
1）常量化指针目标表达式
常量化指针目标是限制通过指针改变其目标的值
2）常量化指针变量
常量化指针，使指针变量的地址不能改变，但可以通过修改指针变量名称修改指针所指向变量的数值
3）常量化指针变量及其目标表达式，使其既不可以通过指针修改其目标的值，也不可以通过修改指针变量名称修改指针所指向变量的数值

9.函数指针
函数指针是一个函数执行代码的起始地址
指针函数指一个函数的返回值为地址量的函数

10函数
a)前面用inline修饰的函数为内联函数，它将简单的函数内嵌到调用它的程序代码中，这样做的目的是节省了调用函数的开销
b)函数重载指使用一个函数名称定义了多个完成不同功能的函数，这些函数的输入参数类型或个数不一样，相应的函数类型也有可能改变
c)在c++源代码中可以包括各种编译用的命令语句，这些语句都称为预编译语句
d)宏是指定义一个标识符来代替一个字符序列，内联函数和宏都是在程序出现的地方展开，是在调用该函数程序处或应用宏处将它展开，内联函数可以多行程序段，宏通常单行程序段
e)递归函数的执行
递推阶段：从原问题出发，按递推公式地推，最终到终止条件
回归阶段：按递归终止条件求出结果，逆向逐步带入公式，回归到原问题求解

11.自定义数据类型
a)结构体数据类型由若干个数据数据成员组成的构造类型，每个成员可以是一个基本类型，也可以是一个已经定义的构造类型，各个成员占据不同的空间
b)联合体数据类型是一种混合数据使用的数据类型，它的各个成员虽然是存储不同数据类型的数据，但使用时改变一个数据成员的值就会影响其他数据成员的值，各个成员共享占用空间最多的成员所分配的存储空间【某个成员赋值将影响其他成员的值】

12.类与对象
面向对象是指采用抽象，封装，继承，多态等程序设计方法
类实际上是一种抽象的数据类型，他将完成某特定功能所用到的数据和对数据的操作（即函数）封装在一起。对象是指具有某些属性和功能的单个个体。

13.派生与继承
在派生与继承的层次结构中，当说明一个派生类的对象时，系统先执行各个基类的构造函数，先对基类成员进行初始化，然后在执行派生类的构造函数。若某一个基类也是派生类，则这种执行基类的构造函数的过程需要递归进行下去。在继承链中，构造函数的执行原则是：先执行基类的构造函数，在执行派生类的构造函数。
当一个派生类的对象使用完毕撤销时，析构函数的执行顺序正好与构造函数的执行顺序相反，先执行派生类的析构函数，在执行基类的析构函数

14.友元与静态成员
1）友元是一种特性，通过这种特性可以利用某些特定的全局函数或类的成员函数对某类的私有成员进行存取，c++友元分为友元函数和友元类
2）友元函数的说明方法：friend <返回值类型> <类名>（<参数说明列表>）；
友元类的说明方法：friend class <类名>；
3）静态成员函数无法访问非静态数据数据成员

15.虚拟函数与多态性
1）使用重载，模板，虚函数来支持多态性
2）函数重载与虚拟函数的异同点
相同点：都是用来支持多态性
不同点：函数重载是用来实现编译时的多态性，虚函数是用来实现运行时的多态性
3）如果定义的某些类型只是为了表示抽象的概念，为了将他们作为基类被其它类所继承时就应当引入抽象类【水果就是一种抽象类】

16.重载与模板
a)c++通过函数重载与模板实现了编译时的多态性
b)隐式运算符重载：±*/！%&^+=……用户自定义类型的所有操作都需要显式重载运算符
c)函数模板与重载的异同点：
都使用了静态绑定实现了编译时的多态性
函数重载主要是用于功能相同而参数不同的多个函数的定义
而函数模板是对不同的类型的数据完成相同操作的一种简化形式
d)c++有宏为什么还要函数模板？
因为有时候使用宏会有副作用，并且使编译器不能进行类型检查，而函数模板和宏一样简洁而且还能让编译器进行全面类型检查
e)尽管函数模板和类模板只编写一次，但程序中仍然实例化多个副本，这些副本仍然会占用大量的内存
f)编译器通过匹配过程确定函数调用时调用哪种类型数据，什么情况下进行匹配会造成编译错误？用相同参数表生成重载函数将会产生语法错误
g)使用语句<类模板名>（<类型名称1>，<类型名称2>，……<类型名称n>）编译系统会自动根据需要生成相应的类定义

---

b.试题

选择题

1 、连接器所生成的文件的扩展名为（ D ）
A 、 .cpp B 、 .obj
C 、 .lib D 、 .exe

2 、下列符号中，（ A ）不是分隔符。
A 、； B 、 //
C 、（） D 、｛｝

3 、设 int a=3,b=4,c=5; 表达式（ a+b ） >c&&b== c 的值是（ C ）。
A 、 2 B 、 -1
C 、 0 D 、 1

4 、下列标识符中，不合法的用户标识符为（ A ）
A 、 a#b B 、 _int
C 、 a_10 D 、 PAd

5 、 while(!x) 中的 (!x) 与下面条件（ D ）等价。
A 、 x== 1 B 、 x!=1
C 、 x!=0 D 、 x==0

6 、定义析构函数时，应该注意（ C ）
A 、其名与类名完全相同 B 、返回类型是 void 类型
C 、无形参，也不可重载 D 、函数体中必须有 delete 语句

7 、每个类（ C ）构造函数。
A 、只能有一个 B 、只可有公有的
C 、可以有多个 D 、只可有缺省的

8 、在一个类中可以对一个操作符进行（ D ）重载。
A 、 1 种 B 、 2 种以下
C 、 3 种以下 D 、多种

9 、重载赋值操作符时，应声明为（ A ）函数。
A 、 友元 B 、 虚
C 、 成员 D 、 多态

10 、在公有继承的情况下，基类成员在派生类中的访问权限（ B ）
A 、 受限制 B 、 保持不变
C 、 受保护 D 、 不受保护

11 、通过（ A ）调用虚函数时，采用动态束定。
A 、 对象指针 B 、 对象名
C 、 成员名限定 D 、 派生类名

1 、在（ C ）（ E ）情况下适宜采用 inline 定义内联函数。
A 、 函数体含有循环语句 B 、 函数体含有递归语句
C 、 函数代码少、频繁调用 D 、 函数代码多、不常调用
E 、 需要加快程序执行速度

2 、在类中说明的成员可以使用关键字（ A ）（ D ）进行修饰。
A 、 private B 、 extern
C 、 auto D 、 public
E 、 register

3 、如果类 A 被说明成类 B 的友元，则（ D ）（ E ）。
A 、 类 A 的成员即类 B 的成员
B 、 类 B 的成员即类 A 的成员
C 、 类 A 的成员函数不得访问类 B 的成员
D 、 类 A 的成员函数可以访问类 B 的成员
E 、 类 B 不一定是类 A 的友元

4 、创建或删除堆对象，需要使用操作符（ B ）（ C ）
A 、－ > B 、 new
C 、 delete D 、 .
E 、 *

5 、在类中声明转换函数时不能指定（ A ）（ C ）
A 、 参数 B 、 访问权限
C 、 返回类型 D 、 操作
E 、 标识符

6 、在派生类中重新定义虚函数时必须在（ A ）（ B ）方面与基类保持一致。
A 、 参数个数 B 、 参数类型
C 、 参数名字 D 、 操作内容
E 、 赋值

7 、字符串之间的比较按（ C ）（ E ）进行。
A 、 字符串的长度 B 、 字符的大小写种类
C 、 字符串的内部代码 D 、 字符串的含意
E 、 从头至尾的顺序

8 、 C++ 类体系中，不能被派生类继承的有（ B ）（ E ）。
A 、 转换函数 B 、 构造函数
C 、 虚函数 D 、 静态成员函数
E 、 赋值操作函数

9 、下列虚基类的声明中正确的是（ B ）（ D ）
A 、 class virtual B: public A
B 、 class B: virtual public A
C 、 class B: public A virtual
D 、 class B: public virtual A
E 、 virtual class B: public A

填空题

1 、 输入操作由操作符　　 >> 　　　来表达。
2 、 以 /* 开始，以 / 结束，在 / 和 */ 之间的部分即为　　注释　　　。
3 、 若有运算符 > 、 *= 、 sizeof 、 % ，则它们按优先级由高至低的排列次序为 *sizeof 、 % 、 = 、 > 　。
4 、 描述命题 “A 小于 B 或小于 C” 的表达式为　　 A<B||A<C 　　　　。
5 、 对嵌套 if 语句的规定是： else 总是与　离它最近的还未配对的 if 　　　配对。
6 、 在 C++ 中有二种参数传递方式： 　　值传递 和　地址传递　　　　。
7 、 定义重载函数时，应在参数个数或参数类型上　　有所不同　　　　　。
8 、 类是用户定义的类型，具有类类型的变量称作　　对象　　　　　。
9 、 当建立一个新对象时，程序自动调用　　　它的构造函数　　　　。
10 、当一个成员函数被调用时，该成员函数的　　　 this 指针　　指向调用它的对象。
11 、拷贝初始化构造函数使用　　　引用　　来初始化创建中的对象。
12 、派生类可以定义其　　　　基类　　　中不具备的数据和操作。
13 、在一个继承结构中，当两个相同的名字之间没有　作用域分辨符限定　　时，对此名字的访问将出现二义性。
14 、一元操作符，作为友元函数重载时只能声明　对象　形参；作为类成员函数重载时　不需要　形参。

程序题

1 、 下面函数 chnum 将一个整数字符串转换为一个整数。请在 [1] 、 [2] 、 [3] 、 [4] 处填入正确内容。（ 8 分）

int chnum (char *str) 
{ int i, j, k, h, len, num=0; 
len=strlen(str); 
for(i=0; [1]; i++) // 填入 i<len 
{ k=1; 
j= len-1; 
while ([2])// 填入 j>0 
{ 
k=k*10; 
j--; 
} 
h=[3]-'0'; // 填入 str[i] 
num=num+h*[4]; // 填入 k 
} 
return num; 
} 

[1] 填入 i<len
[2] 填入 j>0
[3] 填入 str[i]
[4] 填入 k

2 、 下列程序定义了一实部为 real ，虚部为 imag 的复数类 complex ，并在类中将复数的加、减操作重载为友元函数。 　　请在 [1] ～ [12] 处填上适当内容。（ 9 分）

class complex{ 
private: float [1], [2]; // 填入 real imag 
public: complex (float r=[3], float i=[4])// 填入 0 0 
{ real=r; imag=i;} 
[5] operator+(complex,complex); // 填入 friend complex 
[6] operator-(complex,complex); // 填入 freind complex 
}; 
[7] operator+(complex c1,complex c2) // 填入 complex 
{ return complex([8], [9]);} // 填入 c1.real+c2.real c1.imag+c2.imag 
[10]operator-(complex c1,complex c2) // 填入 complex 
{ return complex([11], [12]);} // 填入 c1.real-c2.real c1.imag-c2.imag 

[1] real [2] imag
[3] 0 [4] 0
[5] freind complex [6] freind complex
[7] complex [8] c1.real+c2.real
[9] c1.imag+c2.imag [10]complex
[11]c1.real-c2.real [12] c1.imag-c2.imag

3 、 下列 shape 类是一个表示形状的抽象类， area( ) 为求图形面积的函数， total( ) 则是一个通用的用以求不同形状的图形面积总和的函数。请从 shape 类派生三角形类 (triangle)、矩形类（ rectangle ）、并给出具体的求面积函数。（ 9 分）

class shape{ 
public: 
virtual float area( )=0 
}; 
float total(shape *s[ ],int n) 
{ 
float sum=0.0; 
for(int i=0;i<n;i++) 
sum+=s[i]->area( ); 
return sum; 
} 

解：这两个类如下：

class triangle : public shape 
{ 
private : 
float a, b ,c ,s; 
public: 
triangle( float s1=0, float s2=0 , float s3=0 ) 
{ 
a=s1;b=s2;c=s3; 
} 
float area() 
{ 
s=(a+b+c)/2; 
return sqrt(s*(s-a)*(s-b)*(s-c)); 
} 
}; 
class rectangle : public shape 
{ 
private: 
float w,h; 
public: 
rectangle( float width=0, float height=0) 
{ 
w=width; 
h=height; 
} 
float area() 
{ 
return w*h; 
} 
};

简答题

1 ． 给出下面程序的运行结果。

# include “iostream.h” 
int main( ) 
{ int i=1; 
while (i<=15) 
if (++i%3!=2) continue; 
else cout <<”i=”<<i<<endl; 
} 

答：输出结果：
i=2
i=5
i=8
i=11
i=14
2. 给出下面程序的运行结果。

#include “iostream.h” 
class test{ 
private:int num 
float fl; 
public:test( ); 
int getint( ){return num;} 
float getfloat( ){return fl;} 
~test( ); 
}; 
test ∷ test( ) 
{ cout << "Initalizing default" << endl; 
num=0;fl=0.0; 
} 
test ∷ ～ test( ) 
{ cout << "Desdtructor is active" << endl;} 
int main( ) 
{test array[2]; 
cout << array[1].get int( )<< " " << array[1].getfloat( ) <<endl; } 

答：结果为：
Initalizing default
Initalizing default
0 0
Desdtructor is active
Desdtructor is active
3. 给出下面程序的运行结果。

#include "iostream.h" 
int main( ) 
{ int num=50; 
int& ref=num; 
ref=ref+10 
cout << "num=" << num << endl; 
num=num+40; 
cout << "ref=" << ref << endl; 
return 0; 
} 

答：输出结果：
num=60
ref=100
4 ． 若程序员没有为类定义拷贝初始化构造函数，则编译器将自动生成一缺省的拷贝初始化构造函数，它可能会产生什么问题？

答： 若没有为类定义复制初始化构造函数，则编译器将会生成一个形如 ClassName::ClassName(const ClassName &) 的缺省复制初始化构造函数，它的执行方式为用作为初始值的对象的成员初始化正在建立的对象的相应成员。这在有的情况下会产生问题，如果类的成员是一个指针时，缺省复制初始化构造函数构造出的新对象中的指针将与原来的对象指向同一个变量。结果在对象消失时，要进行析构，这时这个变量将会被删除两次，所以就会出错了。

5 ． C++ 没有提供字符串数据类型，如何简单地构造此种数据类型？

答：可以定义一个字符数组作为字符串类型，如下：
const int M=80;
char str[M];

6 ． 什么是多重继承中的支配原则？分析下面的类体系。

class A{ 
public: int i; 
void f(float); 
}; 
class B: public A{ 
public: int i; 
void f(int); 
}; 

则下面的访问是否具有二义性（ b 为类 B 的一个对象）？
b.i;
b.f(3.5);
答：类 X 中的名字 N 支配类 Y 中同名的名字 N ，是指类 X 以类 Y 为它的一个基类，这就称为多重继承的支配原则。在以上的访问中类 B 中的名字支配类 A 中的名字 i 和 f ，所以在访问时不存在二义性。

c.代码规范

1.关键字小写字符
2.语句结束结尾+“；”
3.每个程序只有一个主函数
4.变量使用之前需说明类型
5.函数体用{}
6.小驼峰变量命名，第一个单词首字母小写，后面其他字母单词首字母大写
如int ruanGong;
7.操作符左右有一定的空格
分隔符（，；）前一位无空格，后一位由空格
8.大括号和函数保持同一行，并有空格
9.控制语句前都有一个空格