练习
- B
如果在try块中用throw "error"；语句抛出一个异常，则参数类型是( )的catch块能够捕获这个异常： (3.0分)
A
int *
B
const char *
C
char
D
const int
2.D
关于类模板的模板参数说法正确的是： (3.0分)
A
只可作为数据成员的类型
B
只可作为成员函数的返回值类型
C
只可作为成员函数的参数类型
D
既可作为数据成员的类型，也可说明成员函数的类型
3.D
以下模板哪个是合法的： (3.0分)
A
B
C
D
4.D
下面的程序段有一个错误，请指出出错的位置：
(3.0分)
A
char str[] = “hello”;
B
const char *p = “world”;
C
str[0] = ‘X’;
D
p[0] = ‘X’;
5.C
如果定义了一个类myclass，则为myclass类对象以成员函数形式重载后++运算符的声明应该为： (3.0分)
A
myclass operator++();
B
myclass& operator++();
C
myclass operator++( int );
D
myclass& operator++( int );
6.C
下面的程序段有一个错误，请指出出错的位置：
(3.0分)
A
const size_t array_size = 10 ;
B
int ia[array_size];
C
D
cout<<array_size<<endl;
7.B
如果myclass类定义了拷贝构造函数和一个整型参数的构造函数，还重载了赋值运算符，那么语句myclass obj = 100；会： (3.0分)
A
调用拷贝构造函数
B
调用整型参数的构造函数
C
调用赋值运算符
D
引起编译错误
8.B
已知MAX（a,b）定义如下，请问result值是多少：
(3.0分)
A
5
B
6
C
7
D
8
9.D
单选题
C＋＋异常处理机制中没有： (3.0分)
A
try
B
throw
C
catch
D
Finally
10.D
单选题
如果有const char* str = "OK";那么在32位机上sizeof（str）的值应该是： (3.0分)
A
1
B
2
C
3
D
4
11.C
请问以下程序段输出的内容是：
(3.0分)
A
11,11
B
12,12
C
12,4
D
11,4
12.A
对于int* pa[5]的描述正确的是： (3.0分)
A
pa是一个指针数组，分别指向5个不同的int型指针变量；
B
pa是一个指向某个数组中第5个元素的指针，该元素是int型变量；
C
pa[5]表示某个数组的第5个元素的值；
D
pa是一个具有5个元素的数组指针。
13.BCD
管理类中的指针，应该遵循以下什么规则： (3.0分)
A
每次创建类的新的对象的时，初始化指针并将使用计数置为0。
B
当对象作为另一对象的副本而建立时，复制构造函数复制相应指针并增加与之相应的使用计数的值。从copy-constructor 入手
C
对一个对象进行赋值的时候，赋值操作符减少左操作数所指对象的使用计数的值（如果为使用计数减少为 0，则删除对象），并增加右操作数所指对象的使用计数的值。从重载 operator = 入手。
D
调用析构函数的时候，析构函数减少使用计数的值，（如果使用计数减少至0，则删除对象）。
14.AB
以下程序段有错误，请指出错误的地方是：
(3.0分)
A
source = name
B
if(source == name)
C
strcpy(dest,name)
D
if(strcmp(dest, name) == 0)
15.是
通常用malloc或new申请内存之后，应该立即检查指针值是否为NULL。防止使用指针值为NULL的内存，以上说法是否正确。 (3.0分)
是
否
16.是
对于std::map类型的容器mapFriend来说，idFriendA是键值，friendA是数据，以下两种操作方式结果一定相同，上述说法是否正确。
(3.0分)
是
否
17.否
如果参数是指针，且仅作输入用，则应在类型前加const，以防止该指针
在函数体内被意外修改，以上说法是否正确。 (3.0分)
是
否
18.是
在成员函数中访问对象的数据成员时，可以直接用数据成员名，而在友员函数中访问对象的数据成员时，必须指明是哪个对象的数据成员。 (3.0分)
是
否
19.是
避免数组或指针的下标越界，特别要当心发生下标“多1”或者“少1”操作, 以上说法是否正确。 (3.0分)
是
否
20.是
以下是类的定义数据成员，请问是否正确。
(3.0分)
是
否
以下程序存在一定的缺陷，请分析并修订。
数据成员中有指针，涉及内存分配时，必须自己重新定义拷贝构造函数和赋值运算符，否则把objS传递给TestFun函数时，只会调用默认的拷贝构造函数，只会进行浅拷贝，当TestFun函数结束时，就会调用一次析构函数，释放m_pszTest指向的内存。
class CStr
{
public:
CStr(const char* pszTest)
{
if (NULL != pszTest)
{
int nLen = strlen(pszTest);
m_pszTest = new char[nLen + 1];
strcpy(m_pszTest, pszTest);
}
else
{
m_pszTest = new char[1];
m_pszTest[0] = '\0';
}
}
CStr(const CStr& s)
{
if (NULL != s.m_pszTest)
{
int nLen = strlen(s.m_pszTest);
m_pszTest = new char[nLen + 1];
strcpy(m_pszTest, s.m_pszTest);
}
else
{
m_pszTest = new char[1];
m_pszTest[0] = '\0';
}
}
CStr& operator=(const CStr& s)
{
if (this != &s)
{
delete[] m_pszTest;
if (NULL != s.m_pszTest)
{
int nLen = strlen(s.m_pszTest);
m_pszTest = new char[nLen + 1];
strcpy(m_pszTest, s.m_pszTest);
}
else
{
m_pszTest = new char[1];
m_pszTest[0] = '\0';
}
}
return *this;
}
~CStr()
{
if (NULL != m_pszTest)
{
delete[] m_pszTest;
m_pszTest = NULL;
}
}
void Show()
{
if (NULL != m_pszTest)
{
cout << m_pszTest << endl;
}
}
private:
char* m_pszTest;
};
void TestFun(CStr s)
{
s.Show();
}
void main()
{
CStr objS("Test");
TestFun(objS);
objS.Show();
}
改正以下程序中的错误，要求不能修改main函数代码。
#include<iostream>
using namespace std;
class CPerson
{
public:
int* pAge;
CPerson(int value)
{
pAge = new int(value);
}
// 定义拷贝构造函数
CPerson(const CPerson& p)
{
pAge = new int(*p.pAge);
}
// 定义拷贝赋值运算符
CPerson& operator=(const CPerson& p)
{
if (this != &p)
{
delete pAge;
pAge = new int(*p.pAge);
}
return *this;
}
~CPerson() {
delete pAge;
}
void PrintAge()
{
cout << "The age is" << *pAge << endl;
}
};
void Test(CPerson p)
{
cout << "In the Func" << endl;
}
int_tmain(int argc, _TCHAR* argv[])
{
CPerson p = 8;
Test(p);
p.PrintAge();
return 0;
}
21.22.
编写类似标准库find算法的函数模板，要求find能够实现以下程序调用。
template <class Iter, class T>
Iter find(Iter begin, Iter end, const T& value)
{
while (begin != end)
{
if (value == *begin)
{
return begin;
}
else
{
++begin;
}
}
return end;
}
以下代码出现缺陷，请分析并修订。
在main函数中，将pBase1强制转换为CBase2*类型，这样会导致pBase2指向的内存地址不正确，pBase1实际上指向的是CMD对象中CBase1部分的起始地址，而不是CBase2部分的起始地址。
class CBase1
{
public:
virtual void Test1() = 0;
};
class CBase2
{
public:
virtual void Test2() = 0;
virtual void Test3() = 0;
};
class CMD : public CBase1, public CBase2
{
public:
void Test1() { cout << "1111111111" << endl; }
void Test2() { cout << "22222222222" << endl; }
void Test3() { cout << "333333333333" << endl; }
};
void main()
{
CMD obj;
CBase1* pBase1 = &obj;
pBase1->Test1();
CBase2* pBase2 = dynamic_cast<CBase2*>(pBase1);
if (pBase2)
{
pBase2->Test2();
pBase2->Test3();
}
else
{
cout << "转换失败" << endl;
}
}
22.23.
以下程序段有一定的缺陷请指出下列代码问题并修订。
在Transaction的构造函数中，调用了init()函数，而init()函数又调用了纯虚函数logTransaction()，但在基类的构造函数中，派生类的部分还没有被构造，因此会出错
class Transaction
{
public:
Transaction()
{
// do nothing
}
virtual void logTransaction() const = 0;
protected:
void init(Transaction* trans)
{
trans->logTransaction();
}
};
class BuyTransaction : public Transaction
{// derived class
public:
BuyTransaction()
{
init(this);
}
virtual void logTransaction() const
{
printf("Buy Transaction.log Transaction call\n");
}
};
class SellTransaction : public Transaction
{// derived class
public:
SellTransaction()
{
init(this);
}
virtual void logTransaction() const
{
printf("Sell Transaction.log Transaction call\n");
}
};
int_t main(int argc, _TCHAR* argv[])
{
BuyTransaction buyTrans;
return 0;
}
请写出类String的拷贝构造函数与赋值函数，已知m_data为String类的私有成员。
// 拷贝构造函数
String(const String& str)
{
if (NULL != str.m_data)
{
int len = strlen(str.m_data);
m_data = new char[len + 1];
strcpy(m_data, str.m_data);
}
else
{
m_data = NULL;
}
}
// 赋值函数
String& operator=(const String& str)
{
if (this != &str)
{
delete[] m_data;
if (NULL != str.m_data)
{
int len = strlen(str.m_data);
m_data = new char[len + 1];
strcpy(m_data, str.m_data);
}
else
{
m_data = NULL;
}
}
return *this;
}
下面的程序演示静态局部变量的应用。请写出程序运行的输出结果。
Sum of 1*3 is 3
Sum of 2*3 is 9
Sum of 3*3 is 18
以下程序段存在缺陷，请分析说明并纠正。
GetMemory函数返回的是一个局部变量p的地址，而p在函数结束后会被释放，所以返回的指针是无效的
char* GetMemory(int num)
{
char* p = new char[num];
strcpy(p, "hello world");
return p;
}
void Test(void)
{
char* str = NULL;
str = GetMemory(20);
if (NULL != str)
{
printf("%s\n", str);
delete[] str;
}
}
请分析以下程序段存在的缺陷，并修订。
Derived 类中的 f 函数隐藏了 Base 类中的 f 函数，导致在 Test 函数中调用 pd->f(10) 时，无法找到匹配的函数
class Base
{
public:
void f(int x);
};
class Derived : public Base
{
public:
void f(char* str);
};
void Test(void)
{
Derived* pd = new Derived;
pd->Base::f(10);
}
请分析以下代码段的缺陷并改正。
Mything类没有重写Thing类的update(double)虚函数，只重写了update(int)虚函数
class Thing
{
public:
// ......
virtual void update(int);
virtual void update(double);
};
class Mything : public Thing
{
public:
//...
void update(int);
void update(double);
};
void main(void) {
Mything* mt = new Mything;
Thing* t = mt;
t->update(12.3);
mt->update(12.3);
}
以下程序段存在缺陷，请分析说明并纠正。
GetMemory函数的参数p是一个指针，当调用这个函数时，会将str指针的值（NULL）拷贝给p，然后在函数内部给p分配内存，但是这样做并不会改变str指针的值，str指针仍然是NULL
void GetMemory(char** p, int num)
{
*p = (char*)malloc(sizeof(char) * num);
}
void main(void)
{
char* str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello world");
printf(str);
free(str);
}
在类的设计过程中，通常遵循若在逻辑上A是B的“一部分”（a part of），则不允许B从A派生，而是要用A和其它东西组合出B。请按你的理解设计出眼（Eye）、鼻（Nose）、口（Mouth）、耳（Ear）、头（Head）的类。
class Eye
{
public:
Eye(string c)
{
m_color = c;
}
string getColor() const
{
return m_color;
}
private:
string m_color;
};
class Nose
{
public:
Nose(string s)
{
m_shape = s;
}
string getShape() const
{
return m_shape;
}
private:
string m_shape;
};
class Mouth
{
public:
Mouth(int s)
{
m_size = s;
}
int getSize() const
{
return m_size;
}
private:
int m_size;
};
class Ear
{
public:
Ear(string p)
{
m_position = p;
}
string getPosition() const
{
return m_position;
}
private:
string m_position;
};
class Head
{
public:
Head(string eyeColor, string noseShape, int mouthSize, string earPosition) :
m_leftEye(eyeColor),
m_rightEye(eyeColor),
m_nose(noseShape),
m_mouth(mouthSize),
m_leftEar(earPosition),
m_rightEar(earPosition)
{ }
private:
Eye m_leftEye, m_rightEye;
Nose m_nose;
Mouth m_mouth;
Ear m_leftEar, m_rightEar;
};