纠正一些知识性偏见、欠缺：

1. 变量占用内存大小，是用sizeof（）计算出来那个，定义字符型数据时后面不添加’\0‘的，但是在字符串数组后面是添加的；例如char a[]={'a','b','c'};``char b[]={"abc"};两个数组的长度是不一样的。
2. 按位与是转化为二进制，按照规则：1&1=1 1&0=0 0&0=0进行计算；
3. feof()函数从输入流进行读数据，如果文件未达到文末，则返回非0值，否则为0值
4. 对于一个频繁使用的短小函数，C中是用宏定义的，C++中是用内联函数实现

牛客网

一、选择判断

1.分析下面代码有什么问题？

void test2() 
{ char string[10], str1[10]; int i; for(i=0; i<10; i++) { str1  = 'a'; } 
strcpy( string, str1 ); 
} 

知识点：

• strcpy从源地址开始拷贝，直到遇到\0才结束。如果一直没有遇到\0，就会导致越界访问非法内存。
• 数组名为指向第一个元素的指针，为char *const类型的右值类型，右值类型是不可以被赋值的

正解如下：

void test2()
{char string[10], str1[10];int i;for(i=0; i<9; i++){str1[i]  = 'a';}str1[9] = '\0';strcpy( string, str1 );
}

2.可以参加位运算的数据类型可以是：int、char、long int

不可以是：double、float是不可以的

3.**判断题：**静态内部类不可以直接访问外围类的非静态数据，而非静态内部类可以直接访问外围类的数据，包括私有数据。（ ）

4.字符串“a+b=20\n”的长度是（7）？

知识点：长度使用函数strlen()，内存大小用sizeof()

本题长度为：a、+、b、=、2、0、\n共计7个

**string定义的变量占用内存大小：**28字节（C++中定义的这个变量就是28字节）

5.编译器

如果定义如下类：class Empty{}请选择编译器为之生成的函数有哪些？ （  ）Empty() { … }Empty(const Empty& rhs){ … }Empty& operator=(const Empty& rhs) { … }~Empty() { … }答案：1234

解析：

class Empty  
{  public:  Empty();                            //缺省构造函数  Empty(const Empty &rhs);            //拷贝构造函数  ~Empty();                           //析构函数   Empty& operator=(const Empty &rhs); //赋值运算符  Empty* operator&();                 //取址运算符  const Empty* operator&() const;     //取址运算符(const版本)  
};  

以上函数将会被编译器生成！

6.在重载某运算符时，若运算符函数的形参表中没有参数，则可能的情况有（ABC）

A.该运算符是一个单目运算符。
B.该运算符函数有一个隐含的参数this。
C.该运算符函数是类的成员函数。
D.该运算符函数是类的友元函数。

知识点：

运算符操作数至少为1个，

首先友元函数重载运算符，必须至少有1个参数，因为没有隐含的this指针。

对于成员函数重载运算符，参数可以为0个，因为有隐含的this指针。（成员运算符重载函数不能用static修饰）。

因而对于无参数的运算符重载函数，必然为单目运算符的成员函数，当然有this指针。

7、已知函数 int fun( int i )。以下声明函数指针pfunc的语句正确的是（C）

A.int*pfunc( int );
B.int *pfunc( int )();
C.int(*pfunc)(int);
D.int(*pfunc)(int)();

根据右左法则

int （*P）( ) 是函数指针，指向函数的指针， p 是一个指向函数入口的指针 变量， 该函数没有形参 函数的返回值是int 型

int *p() 是指针函数，返回值为指针的函数 p 是函数的入口地址， 该函数没有形参， 返回值为 int * 型

定义一个函数指针p，只能指向返回值为int，形参为1个int的函数

8.正则表达式语法中 \d 匹配的是？（A）

A.数字

B.非数字

C.字母

D.空白字符

\d 匹配一个数字字符。等价于 [0-9]。
\D 匹配一个非数字字符。等价于 [^0-9]。
\f 匹配一个换页符。等价于 \x0c 和 \cL。
\n 匹配一个换行符。等价于 \x0a 和 \cJ。
\r 匹配一个回车符。等价于 \x0d 和 \cM。
\s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\t 匹配一个制表符。等价于 \x09 和 \cI。
\v 匹配一个垂直制表符。等价于 \x0b 和 \cK。
\w 匹配字母、数字、下划线。等价于’[A-Za-z0-9_]’。
\W 匹配非字母、数字、下划线。等价于 ‘[^A-Za-z0-9_]’。

9.已知表达式int m[]={0，1，2，3，4，5，6}；下面哪个表达式的值与数组下标量最大值相等？（B）

• m. length()
• m. length-1
• m. length()+1
• m. length+1

数组是有length属性，String是有.length（）方法，本题是数组，那么A、C就是错的表示方式，m. length = 7

10.在下列表示引用的方法中，（ A）是正确的。已知：int m=10;

A.int &x=m

B.int &y=10

C.int &z;

D.float &t=&m;

引用就是某一变量（目标）的一个别名，对引用的操作与对变量直接操作完全一样。

引用的声明方法：类型标识符 &引用名=目标变量名；

举个例子：

int a;

int &ra=a; //定义引用ra,它是变量a的引用，即别名

说明：

（1）&在此不是求地址运算，而是起标识作用。

（2）类型标识符是指目标变量的类型。

（3）声明引用时，必须同时对其进行初始化。

（4）引用声明完毕后，相当于目标变量名有两个名称，即该目标原名称和引用名，且不能再把该引用名作为其他变量名的别名。

ra=1; 等价于 a=1;

（5）声明一个引用，不是新定义了一个变量，它只表示该引用名是目标变量名的一个别名，它本身不是一种数据类型，因此引用本身不占存储单元，系统也不给引用分配存储单元。故：对引用求地址，就是对目标变量求地址。&ra与&a相等。

（6）不能建立数组的引用。因为数组是一个由若干个元素所组成的集合，所以无法建立一个数组的别名。

引用的主要作用：

（1）在引用的使用中，单纯给某个变量取个别名是毫无意义的，引用的目的主要用于在函数参数传递中，解决大块数据或对象的传递效率和空间不如意的问题。

（2）用引用传递函数的参数，能保证参数传递中不产生副本，提高传递的效率，且通过const的使用，保证了引用传递的安全性。

（3）引用与指针的区别是，指针通过某个指针变量指向一个对象后，对它所指向的变量间接操作。程序中使用指针，程序的可读性差；而引用本身就是目标变量的别名，对引用的操作就是对目标变量的操作。

（4）使用引用的时机。流操作符<<和>>、赋值操作符=的返回值、拷贝构造函数的参数、赋值操作符=的参数、其它情况都推荐使用引用。

11.若言int a[10],*p=a;则以下表示中不能代表a[6]的是（D）。

A.p[6]

B.*(a+6)

C.*(p+6)

D.p+6

p表示a的首地址，D表示a[6]的地址，但是不是表示a[6]

12.下面程序结果输出为？

#include <iostream>
using namespace std;
class A
{
public:A(){cout << "1";}A(A &a){cout << "2";}virtual ~A(){cout << "3";}
};class B: public A
{
public:B(){cout << "4";}B(B &b){cout << "5";}~B(){cout << "6";}
};int main()
{A *pa = new B();delete pa;return 0;
}

答案：1463

考察的是对继承体系中的构造和析构函数调用顺序的理解。

在调用new B()的时候，因为B继承A，所以会首先调用其父类的构造函数，输出1

然后调用自己的构造函数，输出4

在析构的时候顺序是反过来的，先调用自己的析构函数，输出6

然后调用父类的析构函数，输出3

而这里没有用到拷贝构造函数，所以不用管它。

13.找出以下关于float的不正确的声明

A.float foo=-1;

B.float foo=1.0;

C.float foo=2.02f;

D.float foo=0x0123;

答案：B

浮点型默认是double型的，所以B有问题，整型是可以转换到单精度型的。

14.用Struct代替class的时候以下哪些描述是对的?

知识点：

C++中的类（class），结构（struct）的区别：class的成员默认为private，但是可以声明成为public、private和protected，结构中的成员默认都是public

15.以下选项如果可以初始化正确,那么就会初始化正确,那么以下哪种语法在C++中初始化以后编译会错误？其中X为一C++类

A.const X * x

B.X const * x

C.const X const * x

D.X * const x

答案：CD

const在*前面 都表示*x不可修改

C中*前出现两个const，g++编译器提示duplicate’const’，语法错误
D中const在*后面，表示指针不可修改，需要初始化。const类型的指针声明时必须初始化
p.s X* const x放在类中当一个成员，是没有错误的。

const知识点：

const 限定一个对象为只读属性。
先从一级指针说起吧：
（1）const char p 限定变量p为只读。这样如p=2这样的赋值操作就是错误的。
（2）const char *p p为一个指向char类型的指针，const只限定p指向的对象为只读。这样，p=&a或 p++等操作都是合法的，但如*p=4这样的操作就错了，因为企图改写这个已经被限定为只读属性的对象。
（3）char *const p 限定此指针为只读，这样p=&a或 p++等操作都是不合法的。而p=3这样的操作合法，因为并没有限定其最终对象为只读。
（4）const char *const p 两者皆限定为只读，不能改写。
有了以上的对比，再来看二级指针问题：
（1）const char **p p为一个指向指针的指针，const限定其最终对象为只读，显然这最终对象也是为char类型的变量。故像**p=3这样的赋值是错误的，而像p=？ p++这样的操作合法。
（2）const char * const *p 限定最终对象和 p指向的指针为只读。这样 *p=?的操作也是错的。
（3）const char * const * const p 全部限定为只读，都不可以改写。
总结一下就是看const后跟的是什么，*为对象，变量为指针（针对const指针情况）

16.数据封装

C++是通过类进行封装，是把数据和与这些数据有关的操作封装在一个类中

C++中struct的默认类型是public，但是也可以设置为private形式

17.数组、指针

a:整个四维数组的地址

*(a+i) = a[i]

*(a+i)+j = a[i] +j

*((a+i)+j) = a[i][j]

*((a+i)+j)+k = a[i][j]+k

*( *((a+i)+j)+k ) = a[i][j][k]

*( *((a+i)+j)+k )+l = a[i][j][k]+l

*( *(*((a+i)+j)+k )+l ) = a[i][j][k][l]

18.关于const的问题

△ 欲阻止一个变量被改变，可以使用const关键字。

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

△ 对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为“左值”

△ 对于类的成员函数，若指定其为const类型，则表明其是一个常函数，不能修改类的成员 变量；

19.数据存储

union X{int x;char y[4]; 
};//答案为：：22或33

解释：0x是十六进制存储，若是小端存储，低位在低地址，即0x44是最低位，那么y[0]就是0x44，那么y[1]就是0x33，若为大端存储，那么高位在低地址，0x11是高位，即可得y[1] = 0x22,

20.指针、返回值

有如下一段程序：int f1(float);int f2(char);void f3(float);int (*pf)(float);以下语句合法的是（ A ）？A.int (*p)(float)=&f1;
B.pf=&f2;
C.pf=&f3;
D.pf=f3;解释：HTML中的符号实体 & 就是符号&int (*pf)(float)表示定义一个返回值为int，参数为float的函数指针，根据返回值类型以及参数类型一致选择A。

21.C++中的struct

• 在C++中，来自class的继承默认按照private继承处理，来自struct的继承默认按照public继承处理
• class的成员默认是private权限，struct默认是public权限
• c里面的struct只是变量的聚合体，struct不能有函数
• c++的struct可有构造和析构函数

22.根据程序填写结果

有以下程序
#include<iostream> 
#include<fstream> 
#include<string> 
using namespace std; 
int main() 
{ofstream File1("text.txt");  
string d("20160314"); 
string y=d.substr(0,4); 
int k=d.find("2");
int i=d.find("3"); 
string m=d.substr(k+2,i-k); 
string dd=d.substr(i+1,2); 
string n=dd+m+y; 
File1<<n<<endl; 
File1.close(); 
}                                            
文件text.txt中写入的结果是（14160312016）解释：substr(a, b)：从字符串的下标a开始，复制长度为b的字符子串find(c)：返回字符串中第一个值为c的下标因此，k=0，i=5

23.关于重载和虚函数说法

A.虚函数是类的成员函数

B.虚函数实现了C++的多态性

C.函数重载允许非成员函数，而虚函数不行

D.函数重载的调用是根据参数个数、序列来确定，而虚函数依据对象来确定