【每日一题】（D0723）strcpy 智能指针

一、选择题

1、以下代码的输出是（B）

std::map<int,int> m;
m[0] = 1；
m[1] = 2；
m[2] = 3；
m[3] = 4；
m[4] = 5；
for(auto it = m.begin(); it != m.end;)
{if(it->second ==2){m.erase(it++);printf("map after erase:%d\n",it->second);}else{++it;}
}
std:vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
for(auto it = v.begin();it != v.end();)
{if(*it == 2){v.erase(it++);printf("vector after erase:%d\n",*it);}else{++it;}
}

map after erase:3
vector after erase:3

map after erase:3
vector after erase:4

map after erase:4
vector after erase:4

map after erase:4
vector after erase:3

2、64位系统中以下结构体的大小为（C）

typedef struct
{unsigned int rztFlags;unsigned int nResultinfo;unsigned char* pResultInfo;int reserved[16];
}BMD_DataInfo;

A 24
B 76
C 80
D 88

分析： 正确答案C，如果是 32 位系统 sizeof(BMD_DataInfo) = 76；如果是 64 位系统 sizeof(BMD_DataInfo) = 80；

3、下列哪项不是进程的标准状态（C）

A 运行态
B 就绪态
C 调度态
D 等待态

分析： 进程的标准状态只有就绪态、运行态和等待态

4、32位系统上，以下程序的运行结果是（B）

void count(int* a,int b)
{static int c = 0;*a = ++c + *a + b;return;
}
int main(void)
{char* str = NULL;int i,sum = 0;str = (char*) malloc(16);memset(str,'0',16);strcpy(str,"12345678");for(i=0;i<sizeof(str);i++){count(&sum,str[i]-'0');}printf("%d\n",sum);return 0;
}

A 14
B 20
C 72
D 124

分析： 这道题是一个小陷阱，粗心大意选成了 C，其实 malloc 确实申请了16 个字节大空间，但是在 for 循环时，i < sizeof(str) ，str 的类型是 char* 的指针，占用 4 个字节，也就是 i<4 (i =0,1,2,3)。当 i = 0 时，sum = 2；当 i = 1 时，sum = 6；当 i = 2 时，sum = 12；当 i = 3 时，sum = 20。

5、运行下面代码，结果是什么（B）

#include<iostream>
template <class T> void f(T & i)
{std::cout<<1;
}
tempalte <> void f(const int & i)
{std::cout<<2;
}
int main()
{int i = 42;f(i);
}

A 1
B 2
C 编译错误
D 未定义行为

6、关于引用和指针，下列用法正确的是（C）

A char* pc = 0; char& rc = *pc;
B std::string& rs; const std::string&rs = 0;
C std::string rs; std::string *ps = &rs;

分析： 在C++中 0 代表空指针，可以初始化指针变量，但是 A 选项的第二句解引用空指针，这就不对了，A错误；引用在定义时必须初始化，B错误；

7、下面代码输出（C）

#include<iostream>
struct X
{X(){std::cout<<"X";}
};
int main()
{X x();
}

A X
B XX
C 无输出
D 未定义行为

8、对于 n 个节点的单向链表（无表头节点），需要指针单元的个数至少为（C）

A n-1
B n
C n+1
D 2n

分析： 在 n 个节点的单向链表（无表头节点）中，每个节点都有一个指针单元，即指针域，加上头指针，至少需要 n+1 个指针单元。

9、下面程序运行的结果是（B）

#include<iostream>
#include<map>
using namespace std;bool default_constructed = false;
bool constructed = false;
bool assigned = false;class C
{public:C(){default_constructed = true;}C(int){constructed = true;}C & operator =(const C&){assigned = true;return *this;}
}
int main()
{map<int,C> m;m[7] = C(1);cout << default_constructed << constructed << assigned;
}

A 101
B 111
C 011
D 110

10、std::map<key,value>，当key值不是非基本类型时，需要实现那个函数？（）

A operator<()
B operator<<()
C operator>>()
D operator>()

11、下面哪项不是C语言常用的运行速度优化方法（D）

A 查表
B 用移位实现乘除法运算
C 使用复合赋值表达式
D 采用多层 for 循环

12、以下关于异常的描述，正确的是（A）

A 异常发生后产生切换的上下文包括存储器中程序的代码和数据、它的栈、通用寄存器的内容、程序计数器、环境变量以及打开文件描述的集合
B 异常处理函数执行过程中不可能产生上下文切换
C 异常处理函数中可以对静态全局变量进行写操作
D 异常和终端是不同的两种处理机制

13、下面选项属于函数指针的是（D）

A (int ) func (int,int)
B int func(int int)
C 两者都是
D 两者都不是

分析： A、B 选项都是指针函数，这个函数有两个 int 类型的参数，返回值是整型指针。

14、在下述函数中，如果传入的是一个 std::string & 进来，那么v会被推倒成（）

template<typename T>
void print(T && v)
{}

A string &&
B string &
C string
D string *

15、下列资源一般不由操作系统管理的是（D）

A 内存
B 声卡
C CPU
D 以上皆非

16、使用以下哪种通信方式，尽量不要加锁（C）

A 信号量
B 信号
C 共享内存
D socket套接字

17、64位操作系统中给定以下结构体，问sizeof(A) = (B)

struct
{char t:4;char k:4;unsigned short i:8;unsigned char*p;unsigned long m;
}

A 9
B 16
C 24
D 40

18、32位设备下，下面哪个程序输出值最大（ AD ）

struct number
{char a;int b;short int c;
}
int main(int argc,char** argv)
{printf("%d\n",sizeof(number));return 0;
}

struct number
{int b;long int c;
}
int main(int argc,char** argv)
{printf("%d\n",sizeof(number));return 0;
}

struct number
{char a;char b;short int c;char d;
}
int main(int argc,char** argv)
{printf("%d\n",sizeof(number));return 0;
}

union number
{long int a;int b;char c;short int d;
}
int main(int argc,char** argv)
{printf("%d\n",sizeof(number));return 0;
}

分析： A、D 选项的结果都是 12，B 选项的结果是 8 ，C 选项的结果是 6。

19、公有继承的情况下，基类的成员（私有成员除外）在派生类中的访问权限是以下哪种（B）

A 受限制
B 保持不变
C 受保护
D 不受保护

20、以下哪种方式不属于进程间通信方式（A）

A 文件系统
B 管道
C 消息队列
D 信号量

21、关于动态内存分配的说法正确的是（C）

A 动态内存分配在栈上分配空间
B 动态内存分配在生命周期和所处的函数一致
C 动态内存分配要小心内存释放
D 动态内存分配不能超出物理内存的大小

分析： 动态内存分配在堆区，由程序员自己动态开辟和回收，故 A、B 错误；动态内存分配大小不要超出 heap size 堆的大小，D 错误。

22、析构函数里面不能做的事情是（B）

A 堆内存读写
B 抛出异常
C 临时智能指针中new对象
D 成员对象的释放

分析： 析构函数一般会释放对象所分配的资源，如果析构函数没有执行，那么这些资源就一直保留在内存中，这些资源没有得到释放，可能会导致内存泄露。所以析构函数中不能抛出异常。

23、在下述函数中，如果传入的是一个 std::string & 进来，那么v会被推倒成（）

template<typename T>
void print(T && v)
{}

A string &&
B string &
C string
D string *

24、下面说法错误的是（B）

A 构造函数不能声明成虚函数
B 析构函数不能声明成虚函数
C 虚函数的引入主要是为了实现多态
D 虚函数在子类中一定要被重新实现

分析： 构造函数不能声明成虚函数，析构函数可以声明成虚函数，而且有时候还必须声明成为虚函数。故 B 错误。

25、在嵌入式系统的存储部件中，存储速度最快的是（B）

A 内存
B 寄存器组
C Flash
D Cache

分析： 嵌入式系统的存储结构采用分级的方法来设计，从而使得整个存储系统分为四级，即寄存器组、高速缓冲 (Cache)、内存 (包括 flash)和外存，它们在存取速度上依次递减，而在存储容量上逐级递增。

26、哪种方式是非对称式加密（B）

A md5
B rsa
C sha256
D des

27、下面程序的输出结果是多少( C )

#define sum(num1,num2) num1+num2
int main(int argc, char** argv)
{printf("%d\n",sum(sum(2,5),sum(4,10))*sum(2,3));return 0;
}

A 51
B 17
C 34
D 105

分析： sum(sum(2,5),sum(4,10))*sum(2,3) 等价于 2 + 5 + 4 + 10 * 2 + 3 = 34

28、下面说法错误的是（ B ）

A 析构函数不能声明成虚函数
B 析构函数不能声明成虚函数
C 虚函数的引入主要是为了实现多态
D 虚函数在子类中一定要被重新实现

29、以下程序的运行结果是（A）

int x = 10;
int modifyvalue()
{return (x += 10);
}
int changevalue(int x)
{return (x -= 1);
}
void main()
{int x = 10;x++;changevalue(x);x++;modifyvalue();printf("First output:%d\n",x);x++;changevalue(x);printf("Second output:%d\n",x);modifyvalue();printf("Third output:%d\n",x);
}

A 12,13,13
B 22,23,23
22,23,33
D 12,13,23

分析： 这就是传值和传址的区别，changevalue(x)；传值时，形参是实参的一份临时拷贝，当函数调用完成之后，形参就会自动销毁，形参只在被调用的函数当中有效，出了被调函数它的生命周期也结束了。

30、在x64环境下，以下代码的输出是（）

#include<stdio.h>
#include<vector>
class A
{public:A(){printf("this is A Construct\n");}virtual ~A(){printf("this is A Destruct\n");}void func0(){printf("this is A func0\n");}virtual void func1(){printf("this is A func1\n");}virtual void func2(){printf("this is A func2\n");}virtual void func3(){printf("this is A func3\n");}
};
class B:public A
{public:B(){printf("this is B Construct\n");}~B(){printf("this is B Destruct\n");}void func0(){printf("this is B func0\n");}virtual void func1(){printf("this is B func1\n");}virtual void func2(){printf("this is B func2\n");}virtual void func3(){printf("this is B func3\n");}
};
int main()
{typedef void(*FUNC){};A* a =  new B();long long *p = (long long*)(*(long long*)a);FUNC f = (FUNC)(p[2]);f();delete a;return 0;
}

this is A Constuct
this is B Constuct
this is B func0
this is B Desturct
this is A Destruct

this is A Constuct
this is B Constuct
this is B func1
this is B Desturct
this is A Destruct

this is A Constuct
this is B Constuct
this is B func2
this is B Desturct
this is A Destruct

this is A Constuct
this is B Constuct
this is B func3
this is B Desturct
this is A Destruct

二、填空题

31、虚继承主要为了解决（多重继承）问题。

32、有一个双向循环链表，每个节点中有指针pre和next分别指向前一个和后一个节点，现需要将ins节点插入到cur节点之后，请补充代码：

cur->next_>pre=ins;
ins->next=cur->next->next;
ins->pre = cur;

33、32位设备下，sizeof(0xAABBCCDD)的值是多少？ （4）

34、shared_ptr是通过（引用计数）方式来实现多个share_ptr对象之间的资源共享。

35、假设a为无符号整型，则a%1024 == a__(1024-1);

三、编程题

36、不调用C/C++的字符串库函数，请编写函数strcpy。

char * strcpy(char * strDest,const char * strSrc)
{assert(strDest && strSrc) //  [1]char * strDestCopy = strDest;      //  [2]while ((*strDest++ = *strSrc++)!='\0');   //[3]return strDestCopy;
}

37、通过C++11模板元编程，实现一个功能判断一个模板参数是否为智能指针。

#include <iostream>
#include <tr1/memory>
#include <typeinfo>
#include <vector>
using namespace std;template<typename T>
struct smart_ptr_checker {enum {value = false};typedef long type;
};template<template<typename> class P, typename T>
struct smart_ptr_checker< P<T> > {enum {value = true};template<typename C> static bool test( typeof(&C::operator->) );template<typename C> static long test(...);typedef typeof(test<P<T> >(0)) type;
};int main()
{cout << typeid(smart_ptr_checker<int>::type).name() << endl;  // longcout << typeid(smart_ptr_checker<tr1::shared_ptr<int> >::type).name() << endl;  // boolcout << typeid(smart_ptr_checker<vector<int> >::type).name() << endl;  // longreturn 0;
}

如果是A为智能指针类，则smart_ptr_checker< A>::type == bool；否则 smart_ptr_checker< A>::type == long。