//---------------------------------------------------------------------------------------

Q:写一个病毒
A:
while (1)
        {
               int *p = new int[10000000];
        }

//---------------------------------------------------------------------------------------

Q:有A、B、C、D四个人，要在夜里过一座桥。他们通过这座桥分别需要耗时1、2、5、10分钟，只有
一支手电，并且同时最多只能两个人一起过桥。请问，如何安排，能够在17分钟内这四个人都过桥？
A:
答案:
第一步:A(1)和B(2)过桥，A(1)返回 Cost：1+2
第二步: C(5)和D(10)过桥，B(2)返回 Cost：10+2
第三步: A(1)和B(2)过桥 Cost：2

//---------------------------------------------------------------------------------------

Q:实现strlen函数，不许用任何变量~
A:
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string>

using namespace std;

int myStrlen(const char *str)
{
return *str ? ( *(str+1) ? ( 1 + myStrlen(str+1) ) : 1 ) : 0 ;
}

int main()
{
char *orig = "Hello, World!";

cout << orig << " (char *)" << endl;
cout << myStrlen(orig) << endl;

return 0;
}

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
把 *str ? ( *(str+1) ? ( 1 + myStrlen(str+1) ) : 1 ) : 0 展开来

int myStrlen(const char *str)
{
if( *str != 0 )
{
   if( *(str+1) != 0 )
   {
    return ( 1 + myStrlen(str+1) );
   }
   else
   {
    return 1;
   }
}
else
{
   return 0;
}
}

//---------------------------------------------------------------------------------------

Q:用递归写出 x! = x * (x-1) * (x-2) * (x-3) * ... * 2 * 1
A:

unsigned short factorial(unsigned short a);

int main(void)
{
int num;
int total;
cout<<"请输入数据: "<<endl;
cin>>num;
total = factorial(num);
cout<<"结果为: "<<total<<endl;
return 0;
}

factorial(a)
{
if( a == 1 )
{
   return 1;
}
else
{
   a *= factorial(a-1);
   return a;
}
}

//---------------------------------------------------------------------------------------

Q:下列哪两个是等同的
int b;
A const int* a = &b;
B const* int a = &b;
C const int* const a = &b;
D int const* const a = &b;

答: (C = D) 这两个是等同的 都表示常量指针常量（指针本身是常量，而且所指内容也是常量）  
A const int* a = &b;         //常量指针，只能够读出内存的数据，却不能修改内存的数据。
B const* int a = &b;         //非法的。
C const int* const a = &b;   //内存数据和指针的地址都不能够修改
D int const* const a = &b;   //内存数据和指针的地址都不能够修改
E int * const a = &b;        //指针常量，指针的地址不能够修改，只能指向b。

//---------------------------------------------------------------------------------------

Q:内联函数在编译时是否做参数类型检查？  
void g(base & b)
{
b.play;    
}    
   
void main()
{
son s;    
g(s);    
return;    
}

A:
内联函数要做参数类型检查, 这是内联函数跟宏相比的优势。

//---------------------------------------------------------------------------------------

Q:C++函数中值的传递方式有哪几种?
A:
C++函数中值的传递有三种传递方式：1.值传递 2.指针传递 3.引用传递

//---------------------------------------------------------------------------------------

Q:头文件的作用是什么?
A:
1.通过头文件调用程序库功能，用户只需要按照头文件中的接口声明来调用库功能，而不必关心接口怎么实现的，编译器会从程序库里提取相应的代码。
2.加强类型的安全检查，函数或者接口被使用时候，方式和头文件中的声明不一致，编译器会之处错误。

//---------------------------------------------------------------------------------------

Q:内存的分配方式的分配方式有几种?
A:
1.从静态存储区域分配，内存编译的时候就已经分配好了，这块内存在程序的整个运行期间都存在，例如：全局变量，静态变量。
2.在栈上创建，在执行函数时，函数内局部变量的存储单元可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内分配运算内置于处理器的指令集中，效率很高，但是分配内存容量有限。
3.从堆上分配，亦称动态内存分配。程序运行的时候用malloc或new申请任意多少的内存，程序员自己负责在任何时用free或delete释放内存。

//---------------------------------------------------------------------------------------

Q:实现双向链表删除一个节点P，在节点P后插入一个节点，写出这两个函数;
A:
typedef struct DNode
{
int date;
DNode * prior;
DNode * next;
};

DNode * DList;

void insertNode(DList &list, int pValue)
{
DList p = list;

if( p == NULL )
   return;
  
while( p->date != pValue )
{
   p = p->next;
}

DNode *q = new DNode();

p->date = pValue;
p->next->prior = q;
q->next = p->next;
p->next = q;
q->prior = p;

}

void deleteNode(DList &list, int pValue)
{
DList p = list;

if( p == NULL )
   return;

while( p->date != NULL )
{
   p = p->next;
}

p->prior->next = p->next;
p->next->prior = p->prior;

//free p;
delete p;
}

//---------------------------------------------------------------------------------------

Q:C++里面是不是所有的动作都是main()引起的？如果不是，请举例.
A:
当然不是所有的动作都是main()引起的，只是编译器由main()开始执行的
静态变量和全局变量的分配早在main之前完成
内联，模板，函数声明，宏的扩展全是预编译期行为，也不是main()完成的
注:C++和main()逻辑上没有必然的联系。

//---------------------------------------------------------------------------------------

Q:如何定义和实现一个类的成员函数为回调函数？
A:
把成员函数申明为static就可以了。

//---------------------------------------------------------------------------------------

Q:C++里面如何声明const void f(void)函数为C程序中的库函数？
A:
extern "C" void f(void);
所以extern "C"是强迫C++编译器对函数名进行修饰的时候采用C命名约定。

//---------------------------------------------------------------------------------------

Q:Windows程序的入口是哪里？写出Windows消息机制的流程。
A:
入口点是WinMain函数.

Windows消息机制的流程:

1.Windows中有一个系统消息队列，对于每一个正在执行的Windows应用程序,系统为其建立一个“消息队列”，即应用程序队列，用来存放该程序可能创建的各种窗口的消息。应用程序中含有一段称作“消息循环”的代码，用来从消息队列中检索这些消息并把它们分发到相应的窗口函数中。

2.Windows为当前执行的每个Windows程序维护一个「消息队列」。在发生输入事件之后，Windows将事件转换为一个「消息」并将消息放入程序的消息队列中。程序通过执行一块称之为「消息循环」的程序代码从消息队列中取出消息：

while(GetMessage (&msg, NULL, 0, 0))
{
    TranslateMessage (&msg) ;
    DispatchMessage (&msg) ;
}

TranslateMessage(&msg);将msg结构传给Windows，进行一些键盘转换。
DispatchMessage (&msg);又将msg结构回传给Windows。然后，Windows将该消息发送给适当的窗口消息处理程序，让它进行处理。

SendMessage()与PostMessage()之间的区别是什么？
它们两者是用于向应用程序发送消息的。PostMessagex()将消息直接加入到应用程序的消息队列中，不等程序返回就退出；而SendMessage()则刚好相反，应用程序处理完此消息后，它才返回。

//---------------------------------------------------------------------------------------

Q:把一个链表反向填空
A:
void reverse(test* head)
{
test* pe = head;
test* ps = head->next;
while(ps)
{
   //方法一 pe是固定不动
   pe->next = ps->next;
   ps->next = head;
   head = ps;
   ps = pe->next;
  
   //方法二 pe ps head 都向后移动
   //head = ps->next;
   //ps->next = pe;
   //pe = ps;
   //ps = head;
}
}

//---------------------------------------------------------------------------------------

Q:什么函数不能成为虚函数?
A:
构造函数()
内联函数(因为没有函数地址，在编译时插入，是个静态行为。)
静态成员函数(因为静态成员函数类似于全局函数，但是属于相应的类，在相应类的作用域下，没有this指针)

//--------------------------------------------------------------------------------------

Q:虚函数与接口的区别?
A:
虚函数的概念:
虚函数是动态联编的基础，它是引入派生概念之后用来表现基类和派生类成员函数之间的一种关系。虚函数在基类中定义，它也是一种成员函数，而且非静态成员函数。
若一个实例方法的声明中含有virtual修饰符，则称该方法为虚拟方法；一个虚拟方法的实现可以派生类取代。取代所继承的虚拟方法的实现的过程称为重写(覆盖)该方法；在一个虚拟方法调用中，该调用所涉及的那个实例的运行时类型确定了要被调用的究竟是该方法的哪一个实现。
虚函数的限制：
1.虚函数仅适用于有继承关系的类对象，所以只有类的成员函数才能说明为虚函数。
2.静态成员函数不能是虚函数。
3.内联函数不能是虚函数。
4.构造函数不能是虚函数。
5.析构函数可以是虚函数。

接口可以有静态成员、嵌套类型、抽象、虚拟成员、属性和事件。实现接口的任何类都必须提供接口中所声明的抽象成员的定义。接口可以要求任何实现类必须实现一个或多个其他接口。
对接口有以下限制：
接口可以任何可访问性来声明，但接口成员必须全都具有公共可访问性。
不能向成员或接口自身附加安全性权限。
接口可以定义类构造函数，但不能定义实例构造函数。
每种语言都必须为需要成员的接口映射一个实现提供规则，因为不只一个接口可以用相同的签名声明成员，且这些成员可以有单独的实现。
接口可以有类和结构来实现。为了只是类或结构实现了某接口，在该类或结构的基类列表中应该包含该接口的标识符。如果一个类或结构实现某接口，则它还隐式实现该接口的所有基接口。即使在类或结构的基类列表中没有显式列出所有基类接口，也是这样。

//--------------------------------------------------------------------------------------

Q:C++中虚函数怎么实现的?  
A:
每个定义了虚函数的类都有一张虚函数表vtbl(virtual function table)，这张表实际上是一个函数指针的数组，记录了虚函数的入口地址。只要这个类有虚函数，不管是自己定义的还是从父类继承过来的，那么类的每个实例---对象都有一个指针vptr(virtual function table pointer)，它指向类的虚函数表。
虚函数(多态)机制的三个条件:
1.派生关系
2.virtual 属性
3.指针-->访问方式

//---------------------------------------------------------------------------------------

Q:有12个小球,外形相同,其中一个小球的质量与其他11个不同，给一个天平,问如何用3次把这个小球找出来并且求出这个小球是比其他的轻还是重？

A:
将12个球分别编号为a1,a2,a3.......a10,a11,a12.
第一步：将12球分开3拨，每拨4个，a1~a4第一拨，记为b1， a5~a8第2拨，记为b2，其余第3拨，记为b3；
第二步：将b1和b2放到天平两盘上，记左盘为c1，右为c2；这时候分两中情况：

1.c1和c2平衡，此时可以确定从a1到a8都是常球；然后把c2拿空，并从c1上拿下a4，从a9到a12四球里随便取三球，假设为a9到a11，放到c2上。此时c1上是a1到a3，c2上是a9到a11。从这里又分三种情况：
A：天平平衡，很简单，说明没有放上去的a12就是异球，而到此步一共称了两次，所以将a12随便跟11个常球再称一次，也就是第三次，马上就可以确定a12是重还是轻；
B：若c1上升，则这次称说明异球为a9到a11三球中的一个，而且是比常球重。取下c1所有的球，并将a8放到c1上，将a9取下，比较a8和a11（第三次称），如果平衡则说明从c2上取下的a9是偏重异球，如果不平衡，则偏向哪盘则哪盘里放的就是偏重异球；
C：若c1下降，说明a9到a11里有一个是偏轻异球。次种情况和B类似，所以接下来的步骤照搬B就是；

2.c1和c2不平衡，这时候又分两种情况，c1上升和c1下降，但是不管哪种情况都能说明a9到a12是常球。这步是解题的关键。也是这个题最妙的地方。
A：c1上升，此时不能判断异球在哪盘也不能判断是轻还是重。取下c1中的a2到a4三球放一边，将c2中的a5和a6放到c1上，然后将常球a9放到c2上。至此，c1上是a1，a5和a6，c2上是a7，a8和a9。此时又分三中情况：

   1）如果平衡，说明天平上所有的球都是常球，异球在从c1上取下a2到a4中。而且可以断定异球轻重。因为a5到a8都是常球，而第2次称的时候c1是上升的，所以a2到a4里必然有一个轻球。那么第三次称就用来从a2到a4中找到轻球。这很简单，随便拿两球放到c1和c2，平衡则剩余的为要找球，不平衡则哪边低则哪个为要找球；

   2）c1仍然保持上升，则说明要么a1是要找的轻球，要么a7和a8两球中有一个是重球（这步懂吧？好好想想，很简单的。因为a9是常球，而取下的a2到a4肯定也是常球，还可以推出换盘放置的a5和a6也是常球。所以要么a1轻，要么a7或a8重）。至此，还剩一次称的机会。只需把a7和a8放上两盘，平衡则说明a1是要找的偏轻异球，如果不平衡，则哪边高说明哪个是偏重异球；

   3）如果换球称第2次后天平平衡打破，并且c1降低了，这说明异球肯定在换过来的a5和a6两求中，并且异球偏重，否则天平要么平衡要么保持c1上升。确定要找球是偏重之后，将a5和a6放到两盘上称第3次根据哪边高可以判定a5和a6哪个是重球；

B：第1次称后c1是下降的，此时可以将c1看成c2，其实以后的步骤都同A，所以就不必要再重复叙述了。至此，不管情况如何，用且只用三次就能称出12个外观手感一模一样的小球中有质量不同于其他11球的偏常的球。而且在称的过程中可以判定其是偏轻还是偏重。

2.      const 修饰类的数据成员。                                                                const数据成员只在某个对象生存期内是常量，而对于整个类而言却是可变的。因为类可以创建多个对象，不同的对象其const数据成员的值可以不同。所以不能在类声明中初始化const数据成员，因为类的对象未被创建时，编译器不知道const 数据成员的值是什么。 const数据成员的初始化只能在类的构造函数的初始化表中进行。

3.      const修饰指针的情况，见下式：
const int* a = & [1]
int const *a = & [2]
int* const a = & [3]
const int* const a = & [4]
可以参考《Effective c++》Item21上的做法，如果const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于星号的右侧，const就是修饰指针本身，即指针本身是常量。因此，[1]和[2]的情况相同，都是指针所指向的内容为常量，这种情况下不允许对内容进行更改操作，如不能*a = 3 ；[3]为指针本身是常量，而指针所指向的内容不是常量，这种情况下不能对指针本身进行更改操作，如a++是错误的；[4]为指针本身和指向的内容均为常量。

4.      const的初始化
先看一下const变量初始化的情况
1) 非指针const常量初始化的情况：A b;
const A a = b;
2) 指针const常量初始化的情况：
A* d = new A();
const A* c = d;
或者：const A* c = new A();
3）引用const常量初始化的情况：
A f;
const A& e = f; // 这样作e只能访问声明为const的函数，而不能访问一般的成员函数；

5.      const在函数声明中的应用                                                              在函数声明中，const 可以修饰函数的返回值，或某个参数；对于成员函数，还可以修饰是整个函数。1） 修饰参数的const，如 void fun0(const A* a ); void fun1(const A& a);
调用函数的时候，用相应的变量初始化const常量，则在函数体中，按照const所修饰的部分进行常量化，如形参为const A* a，则不能对传递进来的指针的内容进行改变，保护了原指针所指向的内容；如形参为const A& a，则不能对传递进来的引用对象进行改变，保护了原对象的属性。
[注意]：参数const通常用于参数为指针或引用的情况，且只能修饰输入参数;若输入参数采用“值传递”方式，由于函数将自动产生临时变量用于复制该参数，该参数本就不需要保护，所以不用const修饰。
[总结]对于非内部数据类型的输入参数，应该将“值传递”的方式改为“const引用传递”，目的是为了提高效率。例如，将void Func(A a)改为void Func(const A &a)
对于内部数据类型的输入参数，不要将“值传递”的方式改为“const引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如void Func(int x)不应该改为void Func(const int &x)
2） 修饰返回值的const，如const A fun2( ); const A* fun3( );
这样声明了返回值后，const按照"修饰原则"进行修饰，起到相应的保护作用。                   [总结] 1） 一般情况下，函数的返回值为某个对象时，如果将其声明为const时，多用于操作符的重载。通常，不建议用const修饰函数的返回值类型为某个对象或对某个对象引用的情况。2）如果给采用“指针传递”方式的函数返回值加const修饰，那么函数返回值（即指针）的内容不能被修改，该返回值只能被赋给加const 修饰的同类型指针。

6.      类成员函数中const的使用
一般放在函数体后，形如：void fun() const;
任何不会修改数据成员的函数都因该声明为const类型。如果在编写const成员函数时，不慎修改了数据成员，或者调用了其他非const成员函数，编译器将报错，这大大提高了程序的健壮性。

7.        使用const的一些建议
1 要大胆的使用const，这将给你带来无尽的益处，但前提是你必须搞清楚原委；
2 要避免最一般的赋值操作错误，如将const变量赋值，具体可见思考题；
3 在参数中使用const应该使用引用或指针，而不是一般的对象实例，原因同上；
4 const在成员函数中的三种用法（参数、返回值、函数）要很好的使用；
5 不要轻易的将函数的返回值类型定为const;
6除了重载操作符外一般不要将返回值类型定为对某个对象的const引用;

然后希腊字母就可以通过{/Symbol a}输入。例如
gnuplot> set label ‘{/Symbol a}’
<!--[if !supportLineBreakNewLine]-->
<!--[endif]-->
各种希腊字母与特殊符号的输入方法请见安装包中gnuplot-4.0.0/docs/psdoc目录下的ps_guide.ps文件。

另外还可参见：
http://t16web.lanl.gov/Kawano/gnuplot/label-e.html#4.3
 
5、gnuplot中如何插入Angstrom（埃）这个符号(A上面一个小圆圈)
脚本中在插入前先加入
gnuplot>set encoding iso_8859_1
这个命令，然后就可以通过“{\305}”加入了。如横坐标要标上“k(1/?)”：
gnuplot>set xlabel 'k(1/{\305})
 
如果是multiplot模式，则这个命令必须放在
gnuplot>set multiplot
的前面。
 
如果后面还要插入别的转义字符，那么还要在插入字符后加入如下命令：
set encoding default
 
安装包中gnuplot-4.0.0/docs/psdoc/ps_guide.ps文件中的表中的‘E’代表那一列的所有符号都用这个方法输入。
 
6、gnuplot画等高线图
gnuplot>splot  ‘文件名.dat’  u 1:2:3  w  l   %做三维图
gnuplot>set dgrid3d 100,100 %设置三维图表面的网格的数目
gnuplot>replot
gnuplot>set contour    %设置画等高线
gnuplot>set cntrparam  levels  incremental -0.2,0.01,0.2   %设置等高线的疏密和范围，数据从   -0.2到0.2中间每隔0.01画一条线
gnuplot>unset surface   去掉上面的三维图形
最后用鼠标拽动图形，选择合理的角度即可。或者直接设置(0,0)的视角也可以：
gnuplot>set view 0,0
gnuplot>replot
 
这里注意，画三维图的数据文件必须是分块的，也就是x每变换一个值，y在其变化范围内变化一周，这样作为一块，然后再取一个x值，y再变化一周，作为下一数据块，等等。块与块之间用一空行格开。
 
7、如何画漂亮的pm3d图
gnuplot> set pm3d                %设置pm3d模式
gnuplot> set isosamples 50,50       %设置网格点
gnuplot> splot x**2+y**2          ％画三维图
gnuplot> splot x**2+y**2 w pm3d   ％画成pm3d模式，注意比较变化
gnuplot> set view 0,0              ％设置视角，（0，0）将投影到底面上去
gnuplot> splot x**2+y**2 w pm3d   ％重画，注意看变化
gnuplot> unset ztics               %把z轴上的数字给去掉
gnuplot> set isosamples 200,200     ％使网格变细
gnuplot> replot                   ％重画，注意看变化，主要是过渡更光滑
 
8、利用脚本文件避免重复输入
有时候对某个数据文件做好一张图后，下次可能还要利用这个数据文件作图，但某个或某些设置要作些细微变化。这时候，可以把第一次作图时的命令全部写到一个文件里，如a.plt，下次只要将相应的设置做修改后，用下面的命令就会自动运行文件所有的命令而最后得到你要的图：
gnuplot>load ‘a.plt’
作为一个例子，假设文件名为a.plt，里面的内容为：
set pm3d
set view 0,0
unset ztics
set isosamples 200,200
splot x**2+y**2 w pm3d
set term post color
set output ‘a.ps’
replot
 
那么启动gnuplot后，只要运行如下命令就可以了：
gnuplot>load ‘a.plt’
 
如果我们要得到的仅仅是.ps或.eps图，那也可以在linux命令提示符下直接运行如下命令：
[zxh@theory zxh]$gnuplot a.plt
 
9、在gnuplot模式下运行linux命令
在gnuplot提示符下也可以运行linux命令，但必须在相应的命令前面加上 ! 号。例如，假设很多参量都已经设置好了，但需要对某个数据文件a.dat进行修改后再画图，则可以用如下方式
gnuplot>!vi a.dat
通过这种方式，所有的linux命令都可以在gnuplot环境里运行。
 
另外，也可以在gnuplot的提示符后输入shell，暂时性退出gnuplot，进入linux环境，做完要做的事情后，运行exit命令，又回到gnuplot环境下。
gnuplot>shell
[zxh@theory zxh]$vi a.f
[zxh@theory zxh]$f77 a.f
[zxh@theory zxh]$a.out    (假设生成a.dat数据文件)
[zxh@theory zxh]$exit
gnuplot>plot ‘a.dat’ w l
 
如有其它问题，欢迎共同探讨。E-mail：exhzheng@163.com

 原文地址 http://202.127.203.201/jilei/Gnuplot.htm