每日练习(12)

C++

1.

int totalBlank = 0;
int blankNum = 0;
int taglen = page.taglst.size();
A       for (int i = 1; i < taglen - 1; ++i)
{
//check blank
B             while (page.taglst[i] == "<br>" && i < taglen)
{
C                       ++totalBlank;
D                       ++i;
}
E             if (totalBlank > 10)
F                      blankNum += totalBlank;
G             totalBlank = 0;
}

应当是B语句最有可能导致数组越界因为它应该先判断大小再判断是否==

2.

所谓虚函数就是多态情况下只执行一个, 而从继承的概念来讲, 总是要先构造父类对象, 然后才能是子类对象,

如果构造函数设为虚函数, 那么当你在构造父类的构造函数时就不得不显示的调用构造, 还有一个原因就是为了防错,

试想如果你在子类中一不小心重写了个跟父类构造函数一样的函数, 那么你的父类的构造函数将被覆盖, 也即不能完成父类的构造.就会出错.

在构造函数不要调用虚函数。在基类构造的时候，虚函数是非虚，不会走到派生类中，既是采用的静态绑定。

显然的是：当我们构造一个子类的对象时，先调用基类的构造函数，构造子类中基类部分，

子类还没有构造，还没有初始化，如果在基类的构造中调用虚函数，如果可以的话就是调用一个还没有被初始化的对象，那是很危险的，

所以C++中是不可以在构造父类对象部分的时候调用子类的虚函数实现。但是不是说你不可以那么写程序，你这么写，编译器也不会报错。

只是你如果这么写的话编译器不会给你调用子类的实现，而是还是调用基类的实现。

在析构函数中也不要调用虚函数。在析构的时候会首先调用子类的析构函数，析构掉对象中的子类部分，

然后在调用基类的析构函数析构基类部分，如果在基类的析构函数里面调用虚函数，

会导致其调用已经析构了的子类对象里面的函数，这是非常危险的

3.一个类定义中，只要有一个函数模板，则这个类是类模板

4.auto_ptr的意义

std::auto_ptr是C++标准库里面的模版类， 属于智能指针

当系统异常退出的时候避免资源泄漏（内存）。 其他的资源还对应其他的智能指针。

2 auto_ptr的使用

std::auto_ptr test(new int（1）);

test将是一个auto_ptr的对象，使用一个int指针进行初始化。

test可以象其他指针一样使用，如使用* 使用->但是＋＋不可以使用，以后也许会扩展，其实难对++做越界管理，也许可以放弃一些速度。

当使用auto_ptr的时候，必须使用显式的类型转化来初始化，如auto_ptr a(new classA）

而不能使用auto_ptr a = new classA;

3 auto_ptr所有权的转移

auto_ptr对所有权有严格的约定，一个auto_ptr只能控制一个指针，不能控制多个，当auto_ptr拥有一个指针的时候就不能在拥有其他的指针了。

同时，不同的auto_ptr不能拥有同一个指针。

4.[编 译器在为类对象分配栈空间时，会先检查类的析构函数的访问性，其实不光是析构函数，只要是非静态的函数，编译器都会进行检查。如果类的析构函数是私有的，则编译器不会在栈空间上为类对象分配内存。

因此， 将析构函数设为私有，类对象就无法建立在栈（静态）上了，只能在堆上（动态new）分配类对象 。]

5.不能被重载的运算符: ::, *. ? :

必须作为成员函数重载的运算符 : = ->

6.重复多次 fclose 一个打开过一次的 FILE *fp 指针会有什么结果？

导致文件描述符结构中指针指向的内存被重复释放，进而导致一些不可预期的异常

7.short类型的数据占用2个字节16位，可表示的最大整数值为65535，即1111 1111 1111 1111，

而65537转换成二进制为1 0000 0000 0000 0001，最高位的1溢出，因此i的值为0000 0000 0000 0001，即为1，而j = i + 1，故j = 2。

8.

class A
{
int _a;
public:
A(int a) : _a(a)
{
}
friend int f1(A &);
friend int f2(const A &);
friend int f3(A);
friend int f4(const A);
};

一个区分左值与右值的便捷方法是：看能不能对表达式取地址，如果能，则为左值，否则为右值。

f1(0)不可以，0是常量右值，非常量引用的初始值必须为左值，所以不可行

9.函数fun的声明为int fun(int *p[4]), 以下哪个变量可以作为fun的合法参数

数组会退化成指针，所以传参传递的应当是二级指针

10.

int main(void) { http://www.taobao.com cout << "welcome to taobao" << endl;
}

程序运行正常

11.内联函数在编译期间用内敛函数体替换掉

12.在x86的机器上，int a = 0xabcd1234 char b = （（char*）&a）[0]请问b是多少0x34，四个字节16进制有8个位置，一个字节应当对应两个位置

13.

class A {
public:
int GetValue() const {
vv = 1;
return vv;
}
private:
int vv;
};

去掉const或者给vv定义为mutable

14.

#include <iostream>

using namespace std;

char* getMem(void) {
//  char p[] = "hello world ";//栈里
//  char* p = "hello world ";//静态区里
//  p[5] = 0x0;//第二种就报错，第一种则是任意输出
char *p = new char[6];
for (int i = 0; i < 5; ++i)
{
p[i] = 'h';
}
p[5] = '\0';
return p;//这样可以但是会有内存泄漏
}
void test(void) {
char *s = 0x0;
s = getMem();
printf(s);
}

int main()
{
test();
return 0;
}

15.

#include <stdio.h>
int f(int a［ ］, int n)
{
if (n > 1)
{
int t;
t = f(a, n - 1);
return t > a[n - 1] ？ t：a［n - 1］;
}
else
return a[0];
}
main()
{
int a［ ］ = { 8,2,9,1,3,6,4,7,5 };
printf("%d\n", f(a, 9));
}

求数组中最大数

16.

（1） 进程间通信方法有：文件映射、共享内存、匿名管道、命名管道、邮件槽、剪切板、动态数据交换、对象连接与嵌入、动态连接库、远程过程调用等

（2） 事件、临界区、互斥量、信号量可以实现线程同步