Jeff的错题集（九）：奥利给！

题一：
下面哪些运算符不能被重载？（）
正确答案: A B C 你的答案: A B (错误)
三目运算符“？：”
作用域运算符“：：”
对象成员运算符“.”
指针成员运算符“->”
解答：
不能被重载的运算符只有五个，分别是

1. . （成员访问运算符）
2. • （成员指针访问运算符）
3. :: （域运算符）
4. sizeof （长度运算符）
5. ?: （条件运算符）
   前两个运算符不能重载是为了保证访问成员的功能不被改变 ，域运算符和sizeof运算符的运算对象是类型而不是变量或者一般表达式，不具备重载的特征。

题二：
稀疏矩阵压缩的存储方法是：（）
正确答案: A D 你的答案: A C (错误)
三元组
二维数组
散列
十字链表
解答：
三元组表示稀疏矩阵可大大节省空间，但是当涉及到矩阵运算时，要大量移动元素。

十字链表表示法可以避免大量移动元素。
节点结构如下： down指向同列下一个节点，right指向同行下一个节点

矩阵部分表示如下：

题三：
若调用fputc函数输出字符成功，则其返回值是（）。
正确答案: D 你的答案: C (错误)
EOF
1
0
输出的字符
解答：
【解释】fputc函数输出字符成功时，其返回值就是输出的字符。故选择答案是D.
题四：
若使用枚举法求解TSP算法，则时间复杂度是（）
正确答案: B 你的答案: D (错误)
n!
(n-1)!
n^2
n
解答：
枚举法解决旅行商问题，即在一个连通图里在每一个节点上进行穷举，第一个节点为n-1，第二个节点n-2，……，即为(n-1)!
题五：
下面哪种情况下,B不能隐式转换为A?
正确答案: B 你的答案: D (错误)
class B:public A{}
class A:public B{}
class B{operator A();}
class A{A(const B&);}
解答：
答案A,表示A是基类，B是派生类，向上级类型转换是隐式的，因为部分元素丢弃可以自动完成，向下转型是显式的因为不知道应该增加的值是什么。所以B不能。
答案C，Operator除了表示函数重载操作符，还可以表示B类型可以装换为A类型。这个知识点就有点偏了。
答案D，拷贝构造函数， B b = A 肯定是可以的。
题六：
堆排序的时间复杂度是（），堆排序中建堆过程的时间复杂度是（）。
正确答案: C 你的答案: D (错误)
O(n2),O(n log n)
O(n),O(n log n)
O(n log n),(n)
O(n log n),O(n log n)
解答：
堆排序的时间，主要由建立初始堆和反复重建堆这两部分的时间开销构成，它们均是通过调用Heapify实现的。时间复杂度O(n*logn)
如果从底部最后的父节点开始建堆，那么我们可以大概算一下： 假如有N个节点，那么高度为H=logN，最后一层每个父节点最多只需要下调1次，倒数第二层最多只需要下调2次，顶点最多需要下调H次，而最后一层父节点共有2^{(H-1)个,倒数第二层公有2}(H-2),顶点只有1(2^0)个，所以总共的时间复杂度为s = 1 * 2^(H-1) + 2 * 2^(H-2) + … + (H-1) * 2^1 + H * 2^0 将H代入后s= 2N - 2 - log2(N)，近似的时间复杂度就是O(N)。
题七：
能说明快速排序是不稳定的排序方法的一组关键字序列是( ).
正确答案: C 你的答案: D (错误)
(10，20， 30， 40，50)
(50， 40， 30, 20，10)
(20, 20，30，10，40)
(20， 40， 30, 30， 10)
解答：
快排的原理是取基准分区，左边的小于或等于基准，右边的大于基准。依次类推，直到每区只有一个元素。
不稳定的含义是建立在有两个相同元素在排序前后，相对位置发生了变化。所以排除A、B选项。
C选项(20, 20，30，10，40)根据快排原理，当比对到10，则10与第一个20交换位置，则相对于第二个20发生了位置变化。所以不稳定。
题八：
带头结点的单链表head为空的判定条件（ ）
正确答案: B 你的答案: C (错误)
headNULL
head->nextNULL
head->nexthead
head!=NULL
解答：
1、带头结点单链表：head->nextNULL
2、带头结点循环链表：head->nexthead
3、不带头结点单链表：headNULL
题九：
下面有关c++线程安全，说法错误的是？
两个难点：
正确答案: C 你的答案: B (错误)
线程安全问题都是由全局变量及静态变量引起的
若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全
c++标准库里面的string保证是线程安全的
POSIX线程标准要求C标准库中的大多数函数具备线程安全性
线程安全问题都是由全局变量及静态变量引起的 ？
答案：
1.局部变量局部使用是安全的
为什么?因为每个thread 都有自己的运行堆栈，而局部变量是生存在堆栈中,大家不干扰。
2.全局原生变量多线程读写是不安全的 ， 全局变量是在堆(heap)中。
3.函数静态变量多线程读写也是不安全的。
4.volatile能保证全局整形变量是多线程安全的么？
不能。 volatile仅仅是告诫compiler不要对这个变量作优化，每次都要从memory取数值，而不是从register
5.InterlockedIncrement保证整型变量自增的原子性
写好多线程安全的法宝就是封装，使数据有保护的被访问到
安全性：
局部变量 > 成员变量 > 全局变
题十：
下面代码打印结果为（）
class Base {
char data[3];
public:
virtual void f() { cout << “Base::f” << endl; }
virtual void g() { cout << “Base::g” << endl; }
virtual void h() { cout << “Base::h” << endl; }
};
int main()
{
cout << sizeof(Base)<< endl;
return 0;
}
正确答案: C 你的答案: D (错误)
6
7
8
9
解答：
类中虚函数存放的只是虚函数表的指针，4个字节，加上char求组的3个字节，对齐以后就是8字节
题十一：
数组A=array[1…100，1…100]以行序为主序存储，设每个数据元素占2个存储单元，基地址为10，则LOC[5，5]应为。
正确答案: C 你的答案: B (错误)
1020
1010
818
808
解答：

题十二：
32位机器上，有三个类A B C定义如下, 请确定sizeof(A) sizeof(B) sizeof©的大小顺序.
struct A{
A() {}
~A() {}
int m1;
int m2;
};
struct B:A{
B() {}
~B() {}
int m1;
char m2;
static char m3;
};
struct C{
C() {}
virtual~C() {}
int m1;
short m2;
};
正确答案: D 你的答案: D (正确)
A=B=C
A A=C A 解答：
Examples:
//空类：
class CBase
{ };
空类也会被实例化，编译器会给空类隐含的添加一个字节，sizeof()的结果是1。

//这个也是空类
class Base
{
public:
Base();
~Base();
}; //1字节

class CBase
{
public:
CBase(void); //其他成员函数不归入sizeof统计
virtual ~CBase(void); //虚析构函数 virtual ~Base() 的指针占4子字节
private:
int a; //32位机器上，32 / 8 = 4 字节
char *p; // 同上 4字节
};//一共 4 + 4 + 4 = 12 字节

class Derive:public Base //Derive类首先要具有Base类的部分，也就是占12字节
{
public:
Derive():Base(){};
~Derive(){};
private:
static int st; //非实例独占 , static int st;不归入sizeof统计
int d; //占4字节
char *p; //4字节指针
}; //12 + 8 = 20 字节
1.类的大小为类的非静态成员数据的类型大小之和，也就是说静态成员数据不作考虑。
2.普通成员函数与sizeof无关。
3.虚函数由于要维护在虚函数表，所以要占据一个指针大小，也就是4字节。
4.类的总大小也遵守类似class字节对齐的，调整规则。

//32位机器上，有三个类A B C定义如下, 请确定sizeof(A)=8 sizeof(B)=8+5+对齐=16 sizeof©=10+对齐=12的大小顺序.
struct A{
A() {}
~A() {}
int m1; // 4
int m2; // 4
};
struct B:A{
B() {}
~B() {}
int m1; // 4
char m2; // 1
static char m3;
};
struct C{
C() {}
virtual~C() {} // 4
int m1; // 4
short m2; // 2
};

32位编译器：
char ：1个字节
char*（即指针变量）: 4个字节（32位的寻址空间是2^32, 即32个bit，也就是4个字节。同理64位编译器）
short int : 2个字节
int： 4个字节
unsigned int : 4个字节
float: 4个字节
double: 8个字节
long: 4个字节
long long: 8个字节
unsigned long: 4个字节
64位编译器：
char ：1个字节
char*(即指针变量): 8个字节
short int : 2个字节
int： 4个字节
unsigned int : 4个字节
float: 4个字节
double: 8个字节
long: 4个字节
long long: 8个字节
unsigned long: 8个字节