刚好复习下C++的很多细节知识
第一部分：
| 请写出 BOOL flag 与“零值”比较的 if 语句。（3分） | |
| 标准答案： if ( flag ) if ( !flag ) | 如下写法均属不良风格，不得分。 if (flag == TRUE) if (flag == 1 ) if (flag == FALSE) if (flag == 0) |
| 请写出 float x 与“零值”比较的 if 语句。（4分） | |
| 标准答案示例： const float EPSINON = 0.00001; if ((x >= - EPSINON) && (x <= EPSINON) 不可将浮点变量用“==”或“！=”与数字比较，应该设法转化成“>=”或“<=”此类形式。 | 如下是错误的写法，不得分。 if (x == 0.0) if (x != 0.0) |
| 请写出 char *p 与“零值”比较的 if 语句。（3分） | |
| 标准答案： if (p == NULL)if (p != NULL) | 如下写法均属不良风格，不得分。 if (p == 0) if (p != 0) if (p) if (!) |
| char *p = str ; int n = 10; char str[] = “Hello” ;请计算 sizeof (str ) = 6 sizeof ( p ) = 4 （2分） （2分）
sizeof ( n ) = 4 （2分） | void Func ( char str[100]) { 请计算 sizeof( str ) = 4 } （2分） |
| void *p = malloc( 100 ); 请计算 sizeof ( p ) = 4 （2分） |
二、以下为
三、简答题（
1、头文件中的 ifndef/define/endif 干什么用？（5分）
答：防止该头文件被重复引用。
#include ，编译器从标准库路径开始搜索 filename.h对于#include “filename.h” ，编译器从用户的工作路径开始搜索 filename.h
3.const 有什么用途？（请至少说明两种）（5分）
答：
4.在C++ 程序中调用被 C编译器编译后的函数，为什么要加 extern “C”？ （5分）
答：
5.请简述以下两个for循环的优缺点（5分）
| for (i=0; i { if (condition) DoSomething(); else DoOtherthing(); } | if (condition) { for (i=0; i DoSomething(); } else { for (i=0; i DoOtherthing(); } |
| 优点：程序简洁 缺点：多执行了N-1次逻辑判断，并且打断了循环“流水线”作业，使得编译器不能对循环进行优化处理，降低了效率。 | 优点：循环的效率高 缺点：程序不简洁
|
5分，共20分）
| void GetMemory(char *p) { p = (char *)malloc(100); } void Test(void) { char *str = NULL; GetMemory(str); strcpy(str, "hello world"); printf(str); } 请问运行Test函数会有什么样的结果？ 答：程序崩溃。 因为 Test函数中的 str一直都是 NULL。 strcpy(str, "hello world");将使程序崩溃。 GetMemory并不能传递动态内存， | char *GetMemory(void) { char p[] = "hello world"; return p; } void Test(void) { char *str = NULL; str = GetMemory(); printf(str); } 请问运行Test函数会有什么样的结果？ 答：可能是乱码。 因为GetMemory返回的是指向“栈内存”的指针，该指针的地址不是 NULL，但其原现的内容已经被清除，新内容不可知。 补充，char[]="xxxxxxxxxxx"不是分配在堆上的常量，所以会出现这个错误 使用char*可避免 |
| void GetMemory2(char **p, int num) { *p = (char *)malloc(num); } void Test(void) { char *str = NULL; GetMemory(&str, 100); strcpy(str, "hello"); printf(str); } 请问运行Test函数会有什么样的结果？ 答：
1)因为char*产生在堆上，在堆上分配空间是不会有问题的，所以可以输出结果 2)能够输出hello2）内存泄漏 | void Test(void) { char *str = (char *) malloc(100); strcpy(str, free(str); if(str != NULL) { strcpy(str, printf(str); } } 请问运行Test函数会有什么样的结果？ 答：篡改动态内存区的内容，后果难以预料，非常危险。 因为free(str);之后，str成为野指针， if(str != NULL)语句不起作用。 “hello”);“world”); |
五、编写
已知
（
char *strcpy(char *strDest, const char *strSrc);
（
答：为了实现链式表达式。 // 2分
例如
{
assert((
char *address =
while( (*
NULL ;
return address ; // 2分
}
六、编写类
已知类
class String
{
public:
String(const char *str = NULL); // 普通构造函数
String(const String &other); // 拷贝构造函数
~ String(void); // 析构函数
String & operate =(const String &other); // 赋值函数
private:
char *m_data; // 用于保存字符串
};
请编写String的上述4个函数。
标准答案：
// String的析构函数
{
delete [] m_data;
// 由于m_data是内部数据类型，也可以写成 delete m_data;
}
// String的普通构造函数
{
if(str==NULL)
{
m_data = new char[1]; // 若能加 NULL 判断则更好
*m_data =
}
else
{
int length = strlen(str);
m_data = new char[length+1]; // 若能加 NULL 判断则更好
strcpy(m_data, str);
}
}
// 拷贝构造函数
String::String(const String &other) // 3分
{
int length = strlen(other.m_data);
m_data = new char[length+1]; // 若能加 NULL 判断则更好
strcpy(m_data, other.m_data);
}
// 赋值函数
String & String::operate =(const String &other) // 13分
{
// (1) 检查自赋值 // 4分
if(this == &other)
return *this;
// (2) 释放原有的内存资源 // 3分
delete [] m_data;
// （3）分配新的内存资源，并复制内容 // 3分
int length = strlen(other.m_data);
m_data = new char[length+1]; // 若能加 NULL 判断则更好
strcpy(m_data, other.m_data);
// （4）返回本对象的引用 // 3分
return *this;
}
C++语言支持函数重载，C语言不支持函数重载。函数被C++编译后在库中的名字与C语言的不同。假设某个函数的原型为： void foo(int x, int y);该函数被C编译器编译后在库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字。C++提供了C连接交换指定符号extern“C”来解决名字匹配问题。1）可以定义 const 常量2）const可以修饰函数的参数、返回值，甚至函数的定义体。被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。2、#include 和 #include “filename.h” 有什么区别？（5分） >>
已知
六、编写类
已知类
class String
{
public:
String(const char *str = NULL); // 普通构造函数
String(const String &other); // 拷贝构造函数
~ String(void); // 析构函数
String & operate =(const String &other); // 赋值函数
private:
char *m_data; // 用于保存字符串
};
请编写String的上述4个函数。
(二)
void * ( * (*fp1)(int))[10];
float (*(* fp2)(int,int,int))(int);
int (* ( * fp3)())[10]();
分别表示什么意思？
答：1.void * ( * (*fp1)(int))[10];
fp1是一个指针，指向一个函数，这个函数的参数为int型，函数的返回值是一个指针，这个指针指向一个数组，这个数组有10个元素，每个元素是一个void*型指针。
2.float (*(* fp2)(int,int,int))(int);
fp2是一个指针，指向一个函数，这个函数的参数为3个int型，函数的返回值是一个指针，这个指针指向一个函数，这个函数的参数为int型，函数的返回值是float型。
3.int (* ( * fp3)())[10]();
fp3是一个指针，指向一个函数，这个函数的参数为空，函数的返回值是一个指针，这个指针指向一个数组，这个数组有10个元素，每个元素是一个指针，指向一个函数，这个函数的参数为空，函数的返回值是int型。
第二部分：
1. 用变量a给出下面的定义
a) 一个整型数（An integer）
b)一个指向整型数的指针（ A pointer to an integer）
c)一个指向指针的的指针，它指向的指针是指向一个整型数（ A pointer to a pointer to an intege）r
d)一个有10个整型数的数组（ An array of 10 integers）
e) 一个有10个指针的数组，该指针是指向一个整型数的。（An array of 10 pointers to integers）
f) 一个指向有10个整型数数组的指针（ A pointer to an array of 10 integers）
g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数（A pointer to a function that takes an integer as an argument and returns an integer）
h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数（ An array of ten pointers to functions that take an integer argument and return an integer ）
答案是：
a) int a; // An integer
b) int *a; // A pointer to an integer
c) int **a; // A pointer to a pointer to an integer
d) int a[10]; // An array of 10 integers
e) int *a[10]; // An array of 10 pointers to integers
f) int (*a)[10]; // A pointer to an array of 10 integers
g) int (*a)(int); // A pointer to a function a that takes an integer argument and returns an integer
h) int (*a[10])(int); // An array of 10 pointers to functions that take an integer argument and return an integer
人们经常声称这里有几个问题是那种要翻一下书才能回答的问题，我同意这种说法。当我写这篇文章时，为了确定语法的正确性，我的确查了一下书。但是当我被面试的时候，我期望被问到这个问题（或者相近的问题）。因为在被面试的这段时间里，我确定我知道这个问题的答案。应试者如果不知道所有的答案（或至少大部分答案），那么也就没有为这次面试做准备，如果该面试者没有为这次面试做准备，那么他又能为什么出准备呢？
Static
2. 关键字static的作用是什么？
这个简单的问题很少有人能回答完全。在C语言中，关键字static有三个明显的作用：
1)在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。
2) 在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。
3) 在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。
大多数应试者能正确回答第一部分，一部分能正确回答第二部分，同是很少的人能懂得第三部分。这是一个应试者的严重的缺点，因为他显然不懂得本地化数据和代码范围的好处和重要性。
Const
3．关键字const有什么含意？
我只要一听到被面试者说："const意味着常数"，我就知道我正在和一个业余者打交道。去年Dan Saks已经在他的文章里完全概括了const的所有用法，因此ESP(译者：Embedded Systems Programming)的每一位读者应该非常熟悉const能做什么和不能做什么.如果你从没有读到那篇文章，只要能说出const意味着"只读"就可以了。尽管这个答案不是完全的答案，但我接受它作为一个正确的答案。（如果你想知道更详细的答案，仔细读一下Saks的文章吧。）
如果应试者能正确回答这个问题，我将问他一个附加的问题：
下面的声明都是什么意思？
const int a;
int const a;
const int *a;
int * const a;
int const * a const;
/******/
前两个的作用是一样，a是一个常整型数。第三个意味着a是一个指向常整型数的指针（也就是，整型数是不可修改的，但指针可以）。第四个意思a是一个指向整型数的常指针（也就是说，指针指向的整型数是可以修改的，但指针是不可修改的）。最后一个意味着a是一个指向常整型数的常指针（也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的）。如果应试者能正确回答这些问题，那么他就给我留下了一个好印象。顺带提一句，也许你可能会问，即使不用关键字 const，也还是能很容易写出功能正确的程序，那么我为什么还要如此看重关键字const呢？我也如下的几下理由：
1) 关键字const的作用是为给读你代码的人传达非常有用的信息，实际上，声明一个参数为常量是为了告诉了用户这个参数的应用目的。如果你曾花很多时间清理其它人留下的垃圾，你就会很快学会感谢这点多余的信息。（当然，懂得用const的程序员很少会留下的垃圾让别人来清理的。）
2) 通过给优化器一些附加的信息，使用关键字const也许能产生更紧凑的代码。
3) 合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码修改。简而言之，这样可以减少bug的出现。
第三部分：
1、什么是函数原型、声明和定义
2、数组和指针的区别
3、怎样理解a+++++b
4、详细解释const和volatile， 一个变量可以同时被说明为const和volatile吗?
5、什么是左值、右值?
1)函数定义是告诉编译器，"遇到这个函数的调用时应该这样做..."
函数声明是告诉编译器，"这个函数存在了，请不要装作不知道。"
函数原型是告诉编译器，"想进入这个函数的大门需要按照我指明的这种方式来敲门，不然就是敲错门了。"
所谓声明，是用来将一个object,function,class或template的型别告诉编译器，声明式并不带有细节信息。
所谓定义，是用来将细节信息提供给编译器。对object而言，其定义式是编译器为他配置内存的地点，对function或function template而言，其定义是提供函数本体。对class或class template而言，其定义式必须给出该class或template所有members.
所谓函数原型包括关于参数类型和返回值的全部信息。C++要求必须写出函数原型。
说明一个变量意味着向编译程序描述变量的类型，但并不为变量分配存储空间。定义一个变量意味着在说明变量的同时还要为变量分配存储空间。
2.以下选自网上：/* extn.c */
char s[] = "Hello world.";
__________________________________
/* main.c */
extern char *s; /* XXX */
int main()
{
s[0] = 'A';
return 0;
}
__________________________________
$ gcc -c main.c extn.c
$ gcc -o main main.o extn.o
$ ./main
Segmentation fault (core dumped)
这是 C 中容易犯的一个经典错误。正确的应该是在 main.c 中声明 s 为
extern char s[];
把修改前后的 main.c 分别 gcc -S 编译成汇编，一比较就清楚了：
$ diff main.s.old main.s
12,13c12
< movl s, %eax
< movb $65, (%eax)
---
> movb $65, s
可见：错误版本中 s 声明为指针后，执行时先要取到 s 这个符号本身的地址，
从该地址处取出 s 代表的地址放到 eax 中，然后往这个地址存 'A'，但是，s
在 extn.o 中作为数组存放在 .text 段中，这个符号的地址就是 extn.o 中那
个数组的地址，该处存放的东西是 "Hello world."，取一个指针出来就是四个
字节'H', 'e', 'l', 'l'代表的 long，在 little-endian 平台上它是
0x6c6c6548，再往这个地址存字符 'A'，就 core dump 了。而在正确版本中，
已经知道它是数组了，就只会往 s 这个符号本身的地址处存放了。这便是数组
与指针的区别。
总结：访问指针时，先要找到指针变量本身的地址，从该地址处再取到存放的指
针值，然后再对指针指向的对象进行访问，是间接访问。访问数组则是先找数组
变量符号代表的地址，对这个地址指向的对象进行访问，是直接访问。
C语言的声明的优先级规则如下：
---------------------------------------------------------------
A 声明从它的名字开始读取，然后按照优先级顺序依次读取
B 优先级从高到低依次是：
B.1 声明中被括号括起来的那一部分
B.2 后缀操作符【圆括号()表示这是一个函数，方括号[]表
示这是一个数组】
B.3 前缀操作符【*表示这是一个指向......的指针】
C 如果const或volatile关键字的后面紧跟说明符【如int、long等】，
那么它作用于类型说明符。在其他情况下，const和【或】volatile
关键字作用于它左边紧邻的指针星号。
----------------------------------------------------------------
下面看一个例子：
char * const *(*next)();
-------- ------------------------------------------------------
运用规则 解释
-------- ------------------------------------------------------
A 首先，看变量名"next"，并注意到它直接被括号括住
B.1 先把括号里面的东西看成一个整体，得出"next是一个指向......
的指针"
B 然后考虑括号外面的东西，在星号前缀和括号后缀之间做出选择
B.2 B.2规则告诉我们优先级较高的是右边的函数括号,所以得出"next
是一个函数指针，指向一个返回......的函数"
B.3 然后，处理前缀"*"，得出指针所指的内容
C 最后，把"char* const"解释为指向字符的常量指针
什么是引用
引用是个别名，当建立引用时，程序用另一个变量或对象的名字初始化它。从那时起，引用作为目标的别名而使用，对引用的改动实际就是对目标的改动。引用不是值，不占存储空间，声明引用时，目标的存储状态不会改变。所以既然定义的概念有具体分配空间的含义，那么引用只有声明，没有定义。C++没有提供访问引用本身地址的方法，因为它与指针或其他变量的地址不同，它没有任何意义。
抽象类
一个不能有实例对象的类，就是抽象类，这样的类唯一的用途是被继承。一个抽象类至少具有一个纯虚函数。
虚拟继承
纯虚函数的需要性
1． 多态性是核心概念，它通过虚函数实现。
2． 纯虚函数引伸出抽象类，后者主要是向层次结构中的各成员定义接口。或向其它类提供基类，其他类从基类继承和实现接口。
3． 动态关联是指将：
基类中的虚函数与派生类中虚函数的实现相联系，联系的钮带是基类指针。
4． 实现多态性的前提是：
------系统中已存在基类与派生类（一般是作为基类的对象）
------派生类功能的实现是通过调用基类的虚函数，进而由编译器实现具体的派生类的功能
5． 虚函数的形式是：前面加有VIRTUAL，没参数，不返回值，的常量函数。
6． 纯虚函数是初始化为0的虚函数。
7． 多态性是指：通过继承相关但又不同的类，他们的对象能够对同一个函数的调用作出不同的响应。
8． 多态的扩展性表现为：软件可用与接受消息的对象类型无关的方式编写。
9． 派生类对象的多态操作能力是通过引用基类的指针实现的。
10．派生类对象的基类指针是一个或多个啊，指向派生类对象的基类指针是实例化了吧，因此才会有多个，也才能形成指针数组。
1.了解C++是如何在内部实现多态,虚拟函数和动态关联的目的是:能在最合适的时候选择使用多态.
2.特殊的数据结构:
-----多态能在运行时实现是依靠编译器建立的特殊需要的数据结构
-----执行程序只有利用了这些特殊的数据结构才能实现虚拟函数
-----执行程序也只有利用了这些特殊的数据结构才能实现与多态相关的动态关联.
3.虚函数的正确实现依靠的是:虚函数表(那个特殊的数据结构)
4.纯虚函数:即没有实现方法的虚函数.
1． 与动态关联相关的概念：
----虚函数表，函数指针，数组，类的虚函数，，属类的对象的虚函数版本
----带有虚函数类的每一个对象都包含一指向该类虚函数表的指针
-----虚函数调用VS对应类的虚函数版本
-----每一个包含虚函数的类都有一个虚函数表
-----虚函数表实现为包含函数指针的数组
-----虚函数版本是虚函数在类的对象中的实现，是具体化了的虚函数。
2． 虚函数调用流程的第二次阅读：
----建立特殊的数据结构
----编译器利用此数据结构执行虚函数，实现多态的动态关联
----虚函数表让执行程序选择每次执行（调用）虚函数时正确的实现方法，而虚函数表本身实现为包含函数指针的数组。
----抽象类的两种解释方法：纯虚函数，与虚函数表的0指针。
3． 多态是通过复杂的数据结构实现的，涉及三层指针
---------虚函数表中的函数指针
---------虚函数表本身的指针（放在对象前面，将其与对象（由带虚函数的类实例化而来的对象）相连接）
---------指向被虚函数调用的对象的指针。
1． 虚函数，多态，动态关联是一组相联系的概念。
2． 抽象类唯一的用途是为其它类提供合适的基类，其它类从它这里继承和实现接口，抽象类或抽象基类因为含义太广泛而定义不出实在的对象
3． 有了虚函数与多态性，程序员要做是处理普遍性而编译器则来处理特殊性
4． 与虚函数和多态性相关的动态关联为ISV（独立软件商）提供了盈利空间，ISV可开发能处理专用的类出售，软件开发者买这个类以便使用它的派生类来为自己的产品服务。
1． 基类的纯虚函数无具体的实现。
2． 派生类构造函数参数的个数多于其基类的构造函数，其共同的部分是由传递给基类构造函数参数而生成实现。
3． 类成员的构成：
------构造和析构函数
------派生类构造函数参数，其特殊的部分多半是纯虚函数的实现而设置
------而构造函数的参数而设置的函数
------私有部分：为构造函数的参数而设置的数据成员
4． 纯虚函数：无参数，无返回值，前面加有VIRTUAL的函数，且设为0的函数。
5． 多态性可通过：
基类引用 或 基类指针
调用虚函数来完成。
1． 实现与接口两种继承的结构是不一样的：
------实现继承通常是并联的形式，派生类之间无关系
------接口继承通常是串联的形式，派生类之间仍有层次的继承关系。
2． 并联继承在高层实现一些功能，串联继承是在具体的类中实现一些功能。
3． 两种方式中基类指针或引用的使用是一样的，是多态性成立的基本技巧。
const关键字实在是神通广大。在类的外面，它可以用于全局或名字空间常量，以及静态对象（某一文件或程序块范围内的局部对象）。在类的内部，它可以用于静态和非静态成员。对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const，还有，两者都不指定为const：
char *p = "hello"; //非const指针, //非const数据
const char *p = "hello"; //非const指针,//const数据
char *const p = "hello"; //const指针, 非const数据
const char * const p = "hello"; //const指针,const数据
第四部分：
1.是不是一个父类写了一个virtual 函数，如果子类覆盖它的函数不加virtual ,也能实现多态?
virtual修饰符会被隐形继承的。private 也被集成，只事派生类没有访问权限而已。virtual可加可不加。子类的空间里有父类的所有变量(static除外)。同一个函数只存在一个实体(inline除外)。子类覆盖它的函数不加virtual ,也能实现多态。在子类的空间里，有父类的私有变量。私有变量不能直接访问。
--------------------------------------------------------------------------
2.输入一个字符串，将其逆序后输出。（使用C++，不建议用伪码）
#include <iostream>
using namespace std;
void main()
{
char a[50];memset(a,0,sizeof(a));
int i=0,j;
char t;
cin.getline(a,50,'/n');
for(i=0,j=strlen(a)-1;i<strlen(a)/2;i++,j--)
{
t=a[i];
a[i]=a[j];
a[j]=t;
}
cout<<a<<endl;
}
//第二种
string str;
cin>>str;
str.replace;
cout<<str;
--------------------------------------------------------------------------
3.请简单描述Windows内存管理的方法。
内存管理是操作系统中的重要部分，两三句话恐怕谁也说不清楚吧～～
我先说个大概，希望能够抛砖引玉吧
当程序运行时需要从内存中读出这段程序的代码。代码的位置必须在物理内存中才能被运行，由于现在的操作系统中有非常多的程序运行着，内存中不能够完全放下，所以引出了虚拟内存的概念。把哪些不常用的程序片断就放入虚拟内存，当需要用到它的时候在load入主存（物理内存）中。这个就是内存管理所要做的事。内存管理还有另外一件事需要做：计算程序片段在主存中的物理位置，以便CPU调度。
内存管理有块式管理，页式管理，段式和段页式管理。现在常用段页式管理
块式管理：把主存分为一大块、一大块的，当所需的程序片断不在主存时就分配一块主存空间，把程 序片断load入主存，就算所需的程序片度只有几个字节也只能把这一块分配给它。这样会造成很大的浪费，平均浪费了50％的内存空间，但时易于管理。
页式管理：把主存分为一页一页的，每一页的空间要比一块一块的空间小很多，显然这种方法的空间利用率要比块式管理高很多。
段式管理：把主存分为一段一段的，每一段的空间又要比一页一页的空间小很多，这种方法在空间利用率上又比页式管理高很多，但是也有另外一个缺点。一个程序片断可能会被分为几十段，这样很多时间就会被浪费在计算每一段的物理地址上（计算机最耗时间的大家都知道是I/O吧）。
段页式管理：结合了段式管理和页式管理的优点。把主存分为若干页，每一页又分为若干段。好处就很明显，不用我多说了吧。
各种内存管理都有它自己的方法来计算出程序片断在主存中的物理地址，其实都很相似。
这只是一个大概而已，不足以说明内存管理的皮毛。无论哪一本操作系统书上都有详细的讲解
--------------------------------------------------------------------------
4.
#include "stdafx.h"
#define SQR(X) X*X
int main(int argc, char* argv[])
{
int a = 10;
int k = 2;
int m = 1;
a /= SQR(k+m)/SQR(k+m);
printf("%d/n",a);
return 0;
}
这道题目的结果是什么啊?
define 只是定义而已，在编择时只是简单代换X*X而已，并不经过算术法则的
a /= (k+m)*(k+m)/(k+m)*(k+m);
=>a /= (k+m)*1*(k+m);
=>a = a/9;
=>a = 1;
--------------------------------------------------------------------------
5.
const 符号常量；
(1)const char *p
(2)char const *p
(3)char * const p
说明上面三种描述的区别；
如果const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；
如果const位于星号的右侧，const就是修饰指针本身，即指针本身是常量。
(1)const char *p
一个指向char类型的const对象指针，p不是常量,我们可以修改p的值，使其指向不同的char，但是不能改变它指向非char对象，如：
const char *p;
char c1='a';
char c2='b';
p=&c1;//ok
p=&c2;//ok
*p=c1;//error
(2)char const *p
(3)char * const p
这两个好象是一样的，此时*p可以修改，而p不能修改。
(4)const char * const p
这种是地址及指向对象都不能修改。
--------------------------------------------------------------------------
6.下面是C语言中两种if语句判断方式。请问哪种写法更好？为什么？
int n;
if (n == 10) // 第一种判断方式
if (10 == n) // 第二种判断方式
如果少了个=号,编译时就会报错,减少了出错的可能行,可以检测出是否少了=
--------------------------------------------------------------------------
7.下面的代码有什么问题？
void DoSomeThing(...)
{
char* p;
...
p = malloc(1024); // 分配1K的空间
if (NULL == p)
return;
...
p = realloc(p, 2048); // 空间不够，重新分配到2K
if (NULL == p)
return;
...
}
A:
p = malloc(1024); 应该写成： p = (char *) malloc(1024);
没有释放p的空间，造成内存泄漏。
--------------------------------------------------------------------------
8.下面的代码有什么问题？并请给出正确的写法。
void DoSomeThing(char* p)
{
char str[16];
int n;
assert(NULL != p);
sscanf(p, "%s%d", str, n);
if (0 == strcmp(str, "something"))
{
...
}
}
A:
sscanf(p, "%s%d", str, n); 这句该写成： sscanf(p, "%s%d", str, &n);
--------------------------------------------------------------------------
9.下面代码有什么错误?
Void test1()
{
char string[10];
char *str1="0123456789";
strcpy(string, str1);
}
数组越界
--------------------------------------------------------------------------
10.下面代码有什么问题?
Void test2()
{
char string[10], str1[10];
for(i=0; i<10;i++)
{
str1[i] ='a';
}
strcpy(string, str1);
}
数组越界
--------------------------------------------------------------------------
11.下面代码有什么问题?
Void test3(char* str1)
{
char string[10];
if(strlen(str1)<=10)
{
strcpy(string, str1);
}
}
==数组越界
==strcpy拷贝的结束标志是查找字符串中的/0 因此如果字符串中没有遇到/0的话 会一直复制，直到遇到/0,上面的123都因此产生越界的情况
建议使用 strncpy 和 memcpy
--------------------------------------------------------------------------
12.下面代码有什么问题?
#define MAX_SRM 256
DSN get_SRM_no()
{
static int SRM_no; //是不是这里没赋初值？
int I;
for(I=0;I<MAX_SRM;I++,SRM_no++)
{
SRM_no %= MAX_SRM;
if(MY_SRM.state==IDLE)
{
break;
}
}
if(I>=MAX_SRM)
return (NULL_SRM);
else
return SRM_no;
}
系统会初始化static int变量为0,但该值会一直保存,所谓的不可重入...
--------------------------------------------------------------------------
13.写出运行结果:
{// test1
char str[] = "world"; cout << sizeof(str) << ": ";
char *p = str; cout << sizeof(p) << ": ";
char i = 10; cout << sizeof(i) << ": ";
void *pp = malloc(10); cout << sizeof(p) << endl;
}
6：4：1：4
--------------------------------------------------------------------------
14.写出运行结果:
{// test2
union V {
struct X {
unsigned char s1:2;
unsigned char s2:3;
unsigned char s3:3;
} x;
unsigned char c;
} v;
v.c = 100;
printf("%d", v.x.s3);
}
3
--------------------------------------------------------------------------
15.用C++写个程序，如何判断一个操作系统是16位还是32位的？不能用sizeof()函数
A1:
16位的系统下，
int i = 65536;
cout << i; // 输出0；
int i = 65535;
cout << i; // 输出-1；
32位的系统下，
int i = 65536;
cout << i; // 输出65536；
int i = 65535;
cout << i; // 输出65535；
A2:
int a = ~0;
if( a>65536 )
{
cout<<"32 bit"<<endl;
}
else
{
cout<<"16 bit"<<endl;
}
--------------------------------------------------------------------------
16.C和C++有什么不同?
从机制上：c是面向过程的（但c也可以编写面向对象的程序）；C++是面向对象的，提供了类。但是，
C++编写面向对象的程序比c容易
从适用的方向：c适合要求代码体积小的，效率高的场合，如嵌入式；C++适合更上层的，复杂的； llinux核心大部分是c写的，因为它是系统软件，效率要求极高。
从名称上也可以看出，C++比c多了+，说明C++是c的超集；那为什么不叫c+而叫C++呢，是因为C++比
c来说扩充的东西太多了，所以就在c后面放上两个+；于是就成了C++
C语言是结构化编程语言，C++是面向对象编程语言。
C++侧重于对象而不是过程，侧重于类的设计而不是逻辑的设计。
--------------------------------------------------------------------------
17.在不用第三方参数的情况下，交换两个参数的值
#include <stdio.h>
void main()
{
int i=60;
int j=50;
i=i+j;
j=i-j;
i=i-j;
printf("i=%d/n",i);
printf("j=%d/n",j);
}
方法二：
i^=j;
j^=i;
i^=j;
方法三：
// 用加减实现，而且不会溢出
a = a+b-(b=a)
--------------------------------------------------------------------------
18.有关位域的面试题（为什么输出的是一个奇怪的字符）
a.t = 'b';效果相当于 a.t= 'b' & 0xf;
'b' --> 01100010
'b' & 0xf -->>00000010
所以输出Ascii码为2的特殊字符
char t:4;就是4bit的字符变量，同样
unsigned short i:8;就是8bit的无符号短整形变量
--------------------------------------------------------------------------
19.int i=10, j=10, k=3; k*=i+j; k最后的值是?
60
--------------------------------------------------------------------------
20.进程间通信的方式有?
进程间通信的方式有 共享内存， 管道 ，Socket ，消息队列 , DDE等
--------------------------------------------------------------------------
21.
struct A
{
char t:4;
char k:4;
unsigned short i:8;
unsigned long m;
}
sizeof(A)=?（不考虑边界对齐）
7
struct CELL // Declare CELL bit field
{
unsigned character : 8; // 00000000 ????????
unsigned foreground : 3; // 00000??? 00000000
unsigned intensity : 1; // 0000?000 00000000
unsigned background : 3; // 0???0000 00000000
unsigned blink : 1; // ?0000000 00000000
} screen[25][80]; // Array of bit fields
二、位结构
位结构是一种特殊的结构, 在需按位访问一个字节或字的多个位时, 位结构
比按位运算符更加方便。
位结构定义的一般形式为:
struct位结构名{
数据类型 变量名: 整型常数;
数据类型 变量名: 整型常数;
} 位结构变量;
其中: 数据类型必须是int(unsigned或signed)。 整型常数必须是非负的整
数, 范围是0~15, 表示二进制位的个数, 即表示有多少位。
变量名是选择项, 可以不命名, 这样规定是为了排列需要。
例如: 下面定义了一个位结构。
struct{
unsigned incon: 8; /*incon占用低字节的0~7共8位*/
unsigned txcolor: 4;/*txcolor占用高字节的0~3位共4位*/
unsigned bgcolor: 3;/*bgcolor占用高字节的4~6位共3位*/
unsigned blink: 1; /*blink占用高字节的第7位*/
}ch;
位结构成员的访问与结构成员的访问相同。
例如: 访问上例位结构中的bgcolor成员可写成:
ch.bgcolor
注意:
1. 位结构中的成员可以定义为unsigned, 也可定义为signed, 但当成员长
度为1时, 会被认为是unsigned类型。因为单个位不可能具有符号。
2. 位结构中的成员不能使用数组和指针, 但位结构变量可以是数组和指针,
如果是指针, 其成员访问方式同结构指针。
3. 位结构总长度(位数), 是各个位成员定义的位数之和, 可以超过两个字
节。
4. 位结构成员可以与其它结构成员一起使用。
例如:
struct info{
char name[8];
int age;
struct addr address;
float pay;
unsigned state: 1;
unsigned pay: 1;
}workers;
上例的结构定义了关于一个工人的信息。其中有两个位结构成员, 每个位结
构成员只有一位, 因此只占一个字节但保存了两个信息, 该字节中第一位表示工
人的状态, 第二位表示工资是否已发放。由此可见使用位结构可以节省存贮空间。
--------------------------------------------------------------------------
22.下面的函数实现在一个固定的数上加上一个数，有什么错误，改正
int add_n(int n)
{
static int i=100;
i+=n;
return i;
}
答:
因为static使得i的值会保留上次的值。
去掉static就可了
--------------------------------------------------------------------------
23.下面的代码有什么问题?
class A
{
public:
A() { p=this; }
~A() { if(p!=NULL) { delete p; p=NULL; } }
A* p;
};
答:
会引起无限递归
--------------------------------------------------------------------------
24.
union a {
int a_int1;
double a_double;
int a_int2;
};
typedef struct
{
a a1;
char y;
} b;
class c
{
double c_double;
b b1;
a a2;
};
输出cout<<sizeof(c)<<endl;的结果?
答:
VC6环境下得出的结果是32
另:
我(sun)在VC6.0+win2k下做过试验:
short - 2
int-4
float-4
double-8
指针-4
sizeof(union)，以结构里面size最大的为union的size
----------------------------------------------------------------------------------
25.i最后等于多少?
int i = 1;
int j = i++;
if((i>j++) && (i++ == j)) i+=j;
答:
i = 5
--------------------------------------------------------------------------
26.
unsigned short array[]={1,2,3,4,5,6,7};
int i = 3;
*(array + i) = ?
答:
4
--------------------------------------------------------------------------
27.
class A
{
virtual void func1()；
void func2();
}
Class B: class A
{
void func1(){cout << "fun1 in class B" << endl;}
virtual void func2(){cout << "fun2 in class B" << endl;}
}
A, A中的func1和B中的func2都是虚函数.
B, A中的func1和B中的func2都不是虚函数.
C, A中的func2是虚函数.，B中的func1不是虚函数.
D, A中的func2不是虚函数，B中的func1是虚函数.
答:
A
--------------------------------------------------------------------------
28.
数据库：抽出部门，平均工资，要求按部门的字符串顺序排序，不能含有"human resource"部门，
employee结构如下：employee_id, employee_name, depart_id,depart_name,wage
答:
select depart_name, avg(wage)
from employee
where depart_name <> 'human resource'
group by depart_name
order by depart_name
--------------------------------------------------------------------------
29.
给定如下SQL数据库：Test(num INT(4)) 请用一条SQL语句返回num的最小值，但不许使用统计功能，如MIN，MAX等
答:
select top 1 num
from Test
order by num desc
--------------------------------------------------------------------------
30.
输出下面程序结果。
#include <iostream.h>
class A
{
public:
virtual void print(void)
{
cout<<"A::print()"<<endl;
}
};
class B:public A
{
public:
virtual void print(void)
{
cout<<"B::print()"<<endl;
};
};
class C:public B
{
public:
virtual void print(void)
{
cout<<"C::print()"<<endl;
}
};
void print(A a)
{
a.print();
}
void main(void)
{
A a, *pa,*pb,*pc;
B b;
C c;
pa=&a;
pb=&b;
pc=&c;
a.print();
b.print();
c.print();
pa->print();
pb->print();
pc->print();
print(a);
print(b);
print(c);
}
A:
A::print()
B::print()
C::print()
A::print()
B::print()
C::print()
A::print()
A::print()
A::print()
--------------------------------------------------------------------------
31.
试编写函数判断计算机的字节存储顺序是开序(little endian)还是降序(bigendian)
答:
bool IsBigendian()
{
unsigned short usData = 0x1122;
unsigned char *pucData = (unsigned char*)&usData;
return (*pucData == 0x22);
}
--------------------------------------------------------------------------
32.简述Critical Section和Mutex的不同点
答:
对几种同步对象的总结
1.Critical Section
A.速度快
B.不能用于不同进程
C.不能进行资源统计(每次只可以有一个线程对共享资源进行存取)
2.Mutex
A.速度慢
B.可用于不同进程
C.不能进行资源统计
3.Semaphore
A.速度慢
B.可用于不同进程
C.可进行资源统计(可以让一个或超过一个线程对共享资源进行存取)
4.Event
A.速度慢
B.可用于不同进程
C.可进行资源统计
--------------------------------------------------------------------------
33.一个数据库中有两个表:
一张表为Customer，含字段ID,Name;
一张表为Order，含字段ID,CustomerID（连向Customer中ID的外键）,Revenue；
写出求每个Customer的Revenue总和的SQL语句。
建表
create table customer
(
ID int primary key,Name char(10)
)
go
create table [order]
(
ID int primary key,CustomerID int foreign key references customer(id) , Revenue float
)
go
--查询
select Customer.ID, sum( isnull([Order].Revenue,0) )
from customer full join [order]
on( [order].customerid=customer.id )
group by customer.id
--------------------------------------------------------------------------
34.请指出下列程序中的错误并且修改
void GetMemory(char *p){
p=(char *)malloc(100);
}
void Test(void){
char *str=NULL;
GetMemory=(str);
strcpy(str,"hello world");
printf(str);
}
A:错误--参数的值改变后，不会传回
GetMemory并不能传递动态内存，Test函数中的 str一直都是 NULL。
strcpy(str, "hello world");将使程序崩溃。
修改如下:
char *GetMemory(){
char *p=(char *)malloc(100);
return p;
}
void Test(void){
char *str=NULL;
str=GetMemory(){
strcpy(str,"hello world");
printf(str);
}
方法二:void GetMemory2(char **p)变为二级指针.
void GetMemory2(char **p, int num)
{
*p = (char *)malloc(sizeof(char) * num);
}
--------------------------------------------------------------------------
35.程序改错
class mml
{
private:
static unsigned int x;
public:
mml(){ x++; }
mml(static unsigned int &) {x++;}
~mml{x--;}
pulic:
virtual mon() {} = 0;
static unsigned int mmc(){return x;}
......
};
class nnl:public mml
{
private:
static unsigned int y;
public:
nnl(){ x++; }
nnl(static unsigned int &) {x++;}
~nnl{x--;}
public:
virtual mon() {};
static unsigned int nnc(){return y;}
......
};
代码片断:
mml* pp = new nnl;
..........
delete pp;
A:
基类的析构函数应该为虚函数
virtual ~mml{x--;}
--------------------------------------------------------------------------
36.101个硬币100真、1假，真假区别在于重量。请用无砝码天平称两次给出真币重还是假币重的结论。
答:
101个先取出2堆,
33,33
第一次称,如果不相等,说明有一堆重或轻
那么把重的那堆拿下来,再放另外35个中的33
如果相等,说明假的重,如果不相等,新放上去的还是重的话,说明假的轻(不可能新放上去的轻)
第一次称,如果相等的话，这66个肯定都是真的,从这66个中取出35个来,与剩下的没称过的35个比
下面就不用说了
方法二:
第3题也可以拿A(50),B(50)比一下，一样的话拿剩下的一个和真的比一下。
如果不一样，就拿其中的一堆。比如A(50)再分成两堆25比一下，一样的话就在
B(50)中，不一样就在A(50)中，结合第一次的结果就知道了。
--------------------------------------------------------------------------
37.static变量和static 函数各有什么特点？
答:
static变量：在程序运行期内一直有效，如果定义在函数外，则在编译单元内可见，如果在函数内，在在定义的block内可见；
static函数：在编译单元内可见；
--------------------------------------------------------------------------
38.用C 写一个输入的整数,倒着输出整数的函数,要求用递归方法 ;
答:
void fun( int a )
{
printf( "%d", a%10 );
a /= 10;
if( a <=0 )return;
fun( a );
}
--------------------------------------------------------------------------
39.写出程序结果:
void Func(char str[100])
{
printf("%d/n", sizeof(str));
}
答:
4
分析:
指针长度
--------------------------------------------------------------------------
40.int id[sizeof(unsigned long)];
这个对吗？为什么??
答:
对
这个 sizeof是编译时运算符，编译时就确定了
可以看成和机器有关的常量。
第五部分：
int func(x)
{
int countx = 0;
<script type="text/javascript">
</script>
while(x)
{
countx ++;
x = x&(x-1);
}
return countx;
}
const int &ra=a;
ra=1; //错误
a=1; //正确
void bar(string & s);
bar("hello world");
int &put(int n);
int vals[10];
int error=-1;
void main()
{
put(0)=10; //以put(0)函数值作为左值，等价于vals[0]=10;
put(9)=20; //以put(9)函数值作为左值，等价于vals[9]=20;
cout<<vals[0];
cout<<vals[9];
}
int &put(int n)
{
if (n>=0 && n<=9 ) return vals[n];
else { cout<<"subscript error"; return error; }
}
1. 结构和联合都是由多个不同的数据类型成员组成, 但在任何同一时刻, 联合中只存放了一个被选中的成员（所有成员共用一块地址空间）, 而结构的所有成员都存在（不同成员的存放地址不同）。
2. 对于联合的不同成员赋值, 将会对其它成员重写, 原来成员的值就不存在了, 而对于结构的不同成员赋值是互不影响的。
union
{
int i;
char x[2];
}a;
void main()
{
a.x[0] = 10;
a.x[1] = 1;
printf("%d",a.i);
}
答案：266 (低位低地址，高位高地址，内存占用情况是Ox010A）
{
union{ /*定义一个联合*/
int i;
struct{ /*在联合中定义一个结构*/
char first;
char second;
}half;
}number;
number.i=0x4241; /*联合成员赋值*/
printf("%c%c/n", number.half.first, mumber.half.second);
number.half.first='a'; /*联合中结构成员赋值*/
number.half.second='b';
printf("%x/n", number.i);
getch();
}
答案： AB (0x41对应'A',是低位；Ox42对应'B',是高位）
答案：
char *strcpy(char *strDest, const char *strSrc)
{
if ( strDest == NULL || strSrc == NULL)
return NULL ;
if ( strDest == strSrc)
return strDest ;
char *tempptr = strDest ;
while( (*strDest++ = *strSrC++) != ‘/0’)
;
return tempptr ;
}
{
public:
String(const char *str = NULL); // 通用构造函数
String(const String &another); // 拷贝构造函数
~ String(); // 析构函数
String & operater =(const String &rhs); // 赋值函数
private:
char *m_data; // 用于保存字符串
};
{
if ( str == NULL ) //strlen在参数为NULL时会抛异常才会有这步判断
{
m_data = new char[1] ;
m_data[0] = '/0' ;
}
else
{
m_data = new char[strlen(str) + 1];
strcpy(m_data,str);
}
{
m_data = new char[strlen(another.m_data) + 1];
strcpy(m_data,other.m_data);
}
String& String::operator =(const String &rhs)
{
if ( this == &rhs)
return *this ;
delete []m_data; //删除原来的数据，新开一块内存
m_data = new char[strlen(rhs.m_data) + 1];
strcpy(m_data,rhs.m_data);
return *this ;
}
String::~String()
{
delete []m_data ;
}
作为一种面向对象的语言，C++支持函数重载，而过程式语言C则不支持。函数被C++编译后在符号库中的名字与C语言的不同。例如，假设某个函数的原型为：
_foo_int_int这样的名字包含了函数名、函数参数数量及类型信息，C++就是靠这种机制来实现函数重载的。例如，在C++中，函数void foo( int x, int y )与void foo( int x, float y )编译生成的符号是不相同的，后者为_foo_int_float。
未加extern "C"声明时的连接方式
#ifndef MODULE_A_H
#define MODULE_A_H
int foo( int x, int y );
#endif
＃i nclude "moduleA.h"
foo(2,3);
加extern "C"声明后的编译和连接方式
加extern "C"声明后，模块A的头文件变为：
#ifndef MODULE_A_H
#define MODULE_A_H
extern "C" int foo( int x, int y );
#endif
（1）模块A编译生成foo的目标代码时，没有对其名字进行特殊处理，采用了C语言的方式；
如果在模块A中函数声明了foo为extern "C"类型，而模块B中包含的是extern int foo( int x, int y ) ，则模块B找不到模块A中的函数；反之亦然。
所以，可以用一句话概括extern “C”这个声明的真实目的（任何语言中的任何语法特性的诞生都不是随意而为的，来源于真实世界的需求驱动。我们在思考问题时，不能只停留在这个语言是怎么做的，还要问一问它为什么要这么做，动机是什么，这样我们可以更深入地理解许多问题）：实现C++与C及其它语言的混合编程。
{
＃i nclude "cExample.h"
}
C++引用C函数例子工程中包含的三个文件的源代码如下：
#ifndef C_EXAMPLE_H
#define C_EXAMPLE_H
extern int add(int x,int y);
#endif
/* c语言实现文件：cExample.c */
＃i nclude "cExample.h"
int add( int x, int y )
{
return x + y;
}
// C++实现文件，调用add：cppFile.cpp
extern "C"
{
＃i nclude "cExample.h"
}
int main(int argc, char* argv[])
{
add(2,3);
return 0;
}
#ifndef CPP_EXAMPLE_H
#define CPP_EXAMPLE_H
extern "C" int add( int x, int y );
#endif
/* C实现文件 cFile.c
/* 这样会编译出错：＃i nclude "cExample.h" */
extern int add( int x, int y );
int main( int argc, char* argv[] )
{
add( 2, 3 );
return 0;
}
答案：都是在堆(heap)上进行动态的内存操作。用malloc函数需要指定内存分配的字节数并且不能初始化对象，new 会自动调用对象的构造函数。delete 会调用对象的destructor，而free 不会调用对象的destructor.
答案：i 为30。
答案：不是。两个不同类型的指针之间可以强制转换（用reinterpret cast)。C#是类型安全的。
答案：全局对象的构造函数会在main 函数之前执行。
1） 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static 变量。
2） 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集。
3） 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存，程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由程序员决定，使用非常灵活，但问题也最多。
答案：肯定不是零。举个反例，如果是零的话，声明一个class A[10]对象数组，而每一个对象占用的空间是零，这时就没办法区分A[0],A[1]…了。
答案：通用寄存器给出的地址，是段内偏移地址，相应段寄存器地址*10H+通用寄存器内地址，就得到了真正要访问的地址。
答案：
BOOL : if ( !a ) or if(a)
int : if ( a == 0)
float : const EXPRESSION EXP = 0.000001
if ( a < EXP && a >-EXP)
pointer : if ( a != NULL) or if(a == NULL)
答案： 1） const 常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误。
2） 有些集成化的调试工具可以对const 常量进行调试，但是不能对宏常量进行调试。
数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。指针可以随时指向任意类型的内存块。
(1)修改内容上的差别
char a[] = “hello”;
a[0] = ‘X’;
char *p = “world”; // 注意p 指向常量字符串
p[0] = ‘X’; // 编译器不能发现该错误，运行时错误
(2) 用运算符sizeof 可以计算出数组的容量（字节数）。sizeof(p),p 为指针得到的是一个指针变量的字节数，而不是p 所指的内存容量。C++/C 语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。 注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。
char a[] = "hello world";
char *p = a;
cout<< sizeof(a) << endl; // 12 字节
cout<< sizeof(p) << endl; // 4 字节
计算数组和指针的内存容量
void Func(char a[100])
{
cout<< sizeof(a) << endl; // 4 字节而不是100 字节
}
答案：
a.成员函数被重载的特征：
（1）相同的范围（在同一个类中）；
（2）函数名字相同；
（3）参数不同；
（4）virtual 关键字可有可无。
b.覆盖是指派生类函数覆盖基类函数，特征是：
（1）不同的范围（分别位于派生类与基类）；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有virtual 关键字。
c.“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual 关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）
答案：( ( a + b ) + abs( a - b ) ) / 2
答案：
cout << __FILE__ ;
cout<<__LINE__ ;
__FILE__和__LINE__是系统预定义宏，这种宏并不是在某个文件中定义的，而是由编译器定义的。
答案：可以，可以用_onexit 注册一个函数，它会在main 之后执行int fn1(void), fn2(void), fn3(void), fn4 (void);
void main( void )
{
String str("zhanglin");
_onexit( fn1 );
_onexit( fn2 );
_onexit( fn3 );
_onexit( fn4 );
printf( "This is executed first./n" );
}
int fn1()
{
printf( "next./n" );
return 0;
}
int fn2()
{
printf( "executed " );
return 0;
}
int fn3()
{
printf( "is " );
return 0;
}
int fn4()
{
printf( "This " );
return 0;
}
The _onexit function is passed the address of a function (func) to be called when the program terminates normally. Successive calls to _onexit create a register of functions that are executed in LIFO (last-in-first-out) order. The functions passed to _onexit cannot take parameters.
答案：
void Order(vector<int>& data) //bubble sort
{
int count = data.size() ;
int tag = false ; // 设置是否需要继续冒泡的标志位
for ( int i = 0 ; i < count ; i++)
{
for ( int j = 0 ; j < count - i - 1 ; j++)
{
if ( data[j] > data[j+1])
{
tag = true ;
int temp = data[j] ;
data[j] = data[j+1] ;
data[j+1] = temp ;
}
}
if ( !tag )
break ;
}
}
void main( void )
{
vector<int>data;
ifstream in("c://data.txt");
if ( !in)
{
cout<<"file error!";
exit(1);
}
int temp;
while (!in.eof())
{
in>>temp;
data.push_back(temp);
}
in.close(); //关闭输入文件流
Order(data);
ofstream out("c://result.txt");
if ( !out)
{
cout<<"file error!";
exit(1);
}
for ( i = 0 ; i < data.size() ; i++)
out<<data[i]<<" ";
out.close(); //关闭输出文件流
}
struct Node
{
int data ;
Node *next ;
};
typedef struct Node Node ;
(1)已知链表的头结点head,写一个函数把这个链表逆序 ( Intel)
{
if ( head == NULL || head->next == NULL )
return head;
Node *p1 = head ;
Node *p2 = p1->next ;
Node *p3 = p2->next ;
p1->next = NULL ;
while ( p3 != NULL )
{
p2->next = p1 ;
p1 = p2 ;
p2 = p3 ;
p3 = p3->next ;
}
p2->next = p1 ;
head = p2 ;
return head ;
}
(2)已知两个链表head1 和head2 各自有序，请把它们合并成一个链表依然有序。(保留所有结点，即便大小相同）
Node * Merge(Node *head1 , Node *head2)
{
if ( head1 == NULL)
return head2 ;
if ( head2 == NULL)
return head1 ;
Node *head = NULL ;
Node *p1 = NULL;
Node *p2 = NULL;
if ( head1->data < head2->data )
{
head = head1 ;
p1 = head1->next;
p2 = head2 ;
}
else
{
head = head2 ;
p2 = head2->next ;
p1 = head1 ;
}
Node *pcurrent = head ;
while ( p1 != NULL && p2 != NULL)
{
if ( p1->data <= p2->data )
{
pcurrent->next = p1 ;
pcurrent = p1 ;
p1 = p1->next ;
}
else
{
pcurrent->next = p2 ;
pcurrent = p2 ;
p2 = p2->next ;
}
}
if ( p1 != NULL )
pcurrent->next = p1 ;
if ( p2 != NULL )
pcurrent->next = p2 ;
return head ;
}
(3)已知两个链表head1 和head2 各自有序，请把它们合并成一个链表依然有序，这次要求用递归方法进行。 (Autodesk)
答案：
Node * MergeRecursive(Node *head1 , Node *head2)
{
if ( head1 == NULL )
return head2 ;
if ( head2 == NULL)
return head1 ;
Node *head = NULL ;
if ( head1->data < head2->data )
{
head = head1 ;
head->next = MergeRecursive(head1->next,head2);
}
else
{
head = head2 ;
head->next = MergeRecursive(head1,head2->next);
}
return head ;
}
class B
{
public:
B()
{
cout<<"default constructor"<<endl;
}
~B()
{
cout<<"destructed"<<endl;
}
B(int i):data(i) //B(int) works as a converter ( int -> instance of B)
{
cout<<"constructed by parameter " << data <<endl;
}
private:
int data;
};
B Play( B b)
{
return b ;
}
int main(int argc, char* argv[]) constructed by parameter 5
{ destructed B(5)形参析构
B t1 = Play(5); B t2 = Play(t1); destructed t1形参析构
return 0; destructed t2 注意顺序！
} destructed t1
int main(int argc, char* argv[]) constructed by parameter 5
{ destructed B(5)形参析构
B t1 = Play(5); B t2 = Play(10); constructed by parameter 10
return 0; destructed B(10)形参析构
} destructed t2 注意顺序！
答案：
const int MINNUMBER = -32767 ;
int find_sec_max( int data[] , int count)
{
int maxnumber = data[0] ;
int sec_max = MINNUMBER ;
for ( int i = 1 ; i < count ; i++)
{
if ( data[i] > maxnumber )
{
sec_max = maxnumber ;
maxnumber = data[i] ;
}
else
{
if ( data[i] > sec_max )
sec_max = data[i] ;
}
}
return sec_max ;
}
比如有class A : public class B, public class C {}
那么A的内存结构大致是怎么样的？
这个是compiler-dependent的, 不同的实现其细节可能不同。
如果不考虑有虚函数、虚继承的话就相当简单；否则的话，相当复杂。
可以参考《深入探索C++对象模型》，或者：
http://blog.csdn.net/wfwd/archive/2006/05/30/763797.aspx
struct node { char val; node* next;}
bool check(const node* head) {} //return false : 无环；true: 有环
bool check(const node* head)
{
if(head==NULL) return false;
node *low=head, *fast=head->next;
while(fast!=NULL && fast->next!=NULL)
{
low=low->next;
fast=fast->next->next;
if(low==fast) return true;
}
return false;
}
1043
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
