一、指针函数
当一个函数声明其返回值为一个指针时，实际上就是返回一个地址给调用函数，以用于需要指针或地址的表达式中。
类型说明符*函数名(参数)
当然了，由于返回的是一个地址，所以类型说明符一般都是int。
int*GetDate();
int*aaa(int,int);
函数返回的是一个地址值，经常使用在返回数组的某一元素地址上。
int*GetDate(intwk,intdy);
printf("Enterweek(1-5)day(1-7)\n");
scanf("%d%d",&wk,&dy);
while(wk&1||wk&5||dy&1||dy&7);
printf("%d\n",*GetDate(wk,dy));
int*GetDate(intwk,intdy)
staticintcalendar[5][7]=
{1,2,3,4,5,6,7},
{8,9,10,11,12,13,14},
{15,16,17,18,19,20,21},
{22,23,24,25,26,27,28},
{29,30,31,-1}
return&calendar[wk-1][dy-1];
程序应该是很好理解的，子函数返回的是数组某元素的地址。输出的是这个地址里的值。
二、函数指针
指向函数的指针包含了函数的地址，可以通过它来调用函数。声明格式如下：
类型说明符(*函数名)(参数)
其实这里不能称为函数名，应该叫做指针的变量名。这个特殊的指针指向一个返回整型值的函数。指针的声明笔削和它指向函数的声明保持一致。
指针名和指针运算符外面的括号改变了默认的运算符优先级。如果没有圆括号，就变成了一个返回整型指针的函数的原型声明。
void(*fptr)();
把函数的地址赋值给函数指针，可以采用下面两种形式：
取地址运算符&不是必需的，因为单单一个函数标识符就标号表示了它的地址，如果是函数调用，还必须包含一个圆括号括起来的参数表。
可以采用如下两种方式来通过指针调用函数：
x=(*fptr)();
第二种格式看上去和函数调用无异。但是有些程序员倾向于使用第一种格式，因为它明确指出是通过指针而非函数名来调用函数的。下面举一个例子：
void(*funcp)();
voidFileFunc(),EditFunc();
funcp=FileF
(*funcp)();
funcp=EditF
(*funcp)();
voidFileFunc()
printf("FileFunc\n");
voidEditFunc()
printf("EditFunc\n");
程序输出为：
三、指针的指针
指针的指针看上去有些令人费解。它们的声明有两个星号。例如：
如果有三个星号，那就是指针的指针的指针，四个星号就是指针的指针的指针的指针，依次类推。当你熟悉了简单的例子以后，就可以应付复杂的情况了。当然，实际程序中，一般也只用到二级指针，三个星号不常见，更别说四个星号了。
指针的指针需要用到指针的地址。
charc='A';
char*p=&c;
char**cp=&p;
通过指针的指针，不仅可以访问它指向的指针，还可以访问它指向的指针所指向的数据。下面就是几个这样的例子：
你可能想知道这样的结构有什么用。利用指针的指针可以允许被调用函数修改局部指针变量和处理指针数组。
voidFindCredit(int**);
intvals[]={7,6,5,-4,3,2,1,0};
FindCredit(&fp);
printf("%d\n",*fp);
voidFindCredit(int**fpp)
while(**fpp!=0)
if(**fpp&0)
else(*fpp)++;
首先用一个数组的地址初始化指针fp，然后把该指针的地址作为实参传递给函数FindCredit()。FindCredit()函数通过表达式**fpp间接地得到数组中的数据。为遍历数组以找到一个负值，FindCredit()函数进行自增运算的对象是调用者的指向数组的指针，而不是它自己的指向调用者指针的指针。语句(*fpp)++就是对形参指针指向的指针进行自增运算的。但是因为*运算符高于++运算符，所以圆括号在这里是必须的，如果没有圆括号，那么++运算符将作用于二重指针fpp上。
四、指向指针数组的指针
指针的指针另一用法旧处理指针数组。有些程序员喜欢用指针数组来代替多维数组，一个常见的用法就是处理字符串。
char*Names[]=
"Charles",
char**nm=N
while(*nm!=0)printf("%s\n",*nm++);
先用字符型指针数组Names的地址来初始化指针nm。每次printf()的调用都首先传递指针nm指向的字符型指针，然后对nm进行自增运算使其指向数组的下一个元素(还是指针)。注意完成上述认为的语法为*nm++，它首先取得指针指向的内容，然后使指针自增。
注意数组中的最后一个元素被初始化为0，while循环以次来判断是否到了数组末尾。具有零值的指针常常被用做循环数组的终止符。程序员称零值指针为空指针(NULL)。采用空指针作为终止符，在树种增删元素时，就不必改动遍历数组的代码，因为此时数组仍然以空指针作为结束。
在你的程序加上下面三个函数：
void AddTaskbarIcon()
NOTIFYICONDATA
nid.cbSize =sizeof(NOTIFYICONDATA);
nid.hWnd =GetSafeHwnd();
nid.uID =0;
nid.uFlags =NIF_MESSAGE;
nid.uCallbackMessage=WM_COMMAND;
Shell_NotifyIcon(NIM_ADD,&nid);
SetTaskbarIcon();
void DeleteTaskbarIcon()
NOTIFYICONDATA
nid.cbSize =sizeof(NOTIFYICONDATA);
nid.hWnd =GetSafeHwnd();
nid.uID =0;
nid.uFlags =NULL;
Shell_NotifyIcon(NIM_DELETE,&nid);
void SetTaskbarIcon()
NOTIFYICONDATA
nid.cbSize =sizeof(NOTIFYICONDATA);
nid.hWnd =GetSafeHwnd();
nid.uID =0;
nid.uFlags =NIF_ICON|NIF_TIP;
nid.hIcon =(HICON)LoadImage(AfxGetInstanceHandle(),
MAKEINTRESOURCE(IDR_MAINFRAME),IMAGE_ICON,16,16,NULL);
//IDR_MAINFRAME是你要加的图标
lstrcpy(nid.szTip,"双击显示主界面");
Shell_NotifyIcon(NIM_MODIFY,&nid);
这里有篇详细一点的文章：
Windows 95/Windows NT任务栏的右边是一状态区,Windows95/Wi
ndowsNT在其上显示时间和一些小图标,这些图标代表着特定的功能或
程序,用鼠标单击、右击或双击这些图标,就会弹出功能菜单或程序窗
口等。你也许想把自己的程序图标也放在任务栏的状态区上,很简单,
VC++ 5.0提供了一个函数,让你很容易地实现该功能。
Shell_NotifyIcon()函数
该函数发送消息给系统在任务栏的状态区,增加、删除或修改图
标。Shell_NotifyI con()有两个参数:
1. DWORD dwMessage
消息标志值,为以下三个中之一:
在任务栏状态区增加图标
NIM_DELETE 从任务栏状态区删除图标
NIM_MODITY 修改任务栏状态区的图标
2. PNOTIFYICONDATA pnid
指向NOTIFYICONDATA结构的指针。NOTIFYICONDATA结构如下:
typedef struct _NOTIFYICONDATA { // nid
DWORD cbS // NOTIFYICONDATA 结构的大小
HWND hW //接收回调消息的窗口句柄
UINT uID; //自定义的图标标志值
UINT uF //标志后面的三个数据成员哪个有效,
//可由NIF_ICON,NIF_MESSAGE和
　 NIF_TIP组合。
UINT uCallbackM //回调消息
HICON hI //图标句柄
char szTip[64]; //提示字符。当把鼠标移到任务栏
//状态区该图标上时,系统显示该字符
} NOTIFYICONDATA, *PNOTIFYICONDATA;
如何在任务栏状态区实现程序图标及其功能
1. 首先生成一个单文档的工程文件。
2. 在StdAfx.h 添加自定义的消息:
//回调消息
#define MYWM_NOTIFYICON WM_USER+1
//在任务栏状态区显示图标的消息
#define MYWM_SHOWAPPICONIC WM_USER+2
3. 在MainFrm.h 里添加定义消息处理函数说明,该部分看起来如
protected:
//{{AFX_MSG(CMainFrame)
afx_msg void OnSysCommand(UINT nID, LPARAM lParam); //手
afx_msg void OnMyIconNotify(WPARAM wParam, LPARAM lParam
); //手工加
afx_msg void OnShowAppIconic(WPARAM wParam, LPARAM lPara
m); //手工加
afx_msg void OnClose(); //系统生成
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
另外,需在MainFrm.h定义一开关值,记录程序窗口是打开或关闭
BOOL boolWndHadS
4. 在MainFrm.cpp里实现消息映射和消息处理函数。消息映射部
分看起来如下:
BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
　//{{AFX_MSG_MAP(CMainFrame)
ON_MESSAGE(MYWM_NOTIFYICON, OnMyIconNotify)
　ON_MESSAGE(MYWM_SHOWAPPICONIC,　OnShowAppIconic)
　ON_WM_SYSCOMMAND()
　ON_WM_CLOSE()
　//}}AFX_MSG_MAP
END_MESSAGE_MAP()
消息处理及相关函数如下所示:
//在任务栏状态区添加图标
BOOL MyTaskBarAddIcon(HWND hwnd, UINT uID, HICON hicon,
LPSTR lpszTip)
NOTIFYICONDATA
tnid.cbSize = sizeof(NOTIFYICONDATA);
tnid.hWnd =
tnid.uID = uID;
tnid.uFlags = NIF_ICON | NIF_TIP | NIF_MESSAGE;
tnid.uCallbackMessage = MYWM_NOTIFYICON;
tnid.hIcon =
if (lpszTip)
lstrcpyn(tnid.szTip, lpszTip, sizeof(tnid.szTip));
tnid.szTip[0]=‘\0';
res=shell_NotifyIco n(NIM_ADD, &tnid);
if (hicon)
DestroyIcon(hicon);
//从任务栏状态区删除图标
BOOL MyTaskBarDeleteIcon(HWND hwnd, UINT uID)
NOTIFYICONDATA
tnid.cbSize = sizeof(NOTIFYICONDATA);
tnid.hWnd =
tnid.uID = uID;
res = Shell_NotifyIcon(NIM_DELETE, &tnid);
//处理图标回调消息MYWM_NOTIFYICON
void CMainFrame::OnMyIconNotify( WPARAM wParam, LPARAM l
UINT uMouseM
nID = (UINT)wP
uMouseMsg = (UINT) lP
if(uMouseMsg == WM_LBUTTONDOWN)
　//点击图标
if( boolWndHadShow ) //如果窗口已打开,隐藏窗口
ShowWindow(SW_HIDE );
　//否则,显示窗口
ShowWindow(SW_SHOWNORMAL );
boolWndHadShow = ～boolWndHadS
//消息MYWM_SHOWAPPICONIC处理函数,在任务栏显示图标并隐藏
void CMainFrame::OnShowAppIconic(WPARAM wParam, LPARAM l
HICON theIcon = LoadIcon(AfxGetInstance-Handle(),MAKEINT
RESOURCE(IDR_MAI NFRAME) );
MyTaskBarAddIcon(GetSafeHwnd(), 100, theIcon, _T("示范程
ShowWindow(SW_HIDE );
boolWndHadShow = FALSE;
当程序关闭时,需把图标从任务样状态区删除,你可以添加一个处
理WM_CLOSE消息的函数来删除图标。通过ClassWizard来添加处理WM_
CLOSE的函数OnClose(),该函数如下:
void CMainFrame::OnClose()
// TODO: Add your message handler code here and/or call
MyTaskBarDeleteIcon( GetSafeHwnd(), 100 );
CFrameWnd::OnClose();
当用户把窗口最小化时,你应隐藏整个窗口,所以要处理ON_SYSCO
MMAND消息。首先在MainFrm.h添加函数说明,如第三步所示;然后在Ma
inFrm.cpp里说明消息映射和实现函数。消息映射如前面所示,函数实
void CMainFrame::OnSysCommand(UINT nID, LPARAM lParam )
if (nID==SC_MINIMIZE )
ShowWindow(SW_HIDE );
boolWndHadShow=FALSE;
CWnd::OnSysCommand(nID, lParam );
5. 在InitInstance()函数返回前,添加一语句
m_pMainWnd-&PostMessage( MYWM_SHOWAP- PICONIC );
它是发送一个自定义的消息MYWM_SHOWAP- PICONIC使程序启动后
隐藏程序窗口并在任务栏状态区显示小图标。
6. 现在,你可编译和运行该程序了。程序运行后,点击任务栏状
态区该程序的图标, 系统会弹出程序窗口,再点击一下,又隐藏了。
46. 重载针对数组分配的操作符new[]()和delete[]()的重载。new[]()操作符，返回类型是void *，并且第一个参数类型是size_t。如 void *operator new[](size_t); 当调用如下代码时：Screen *ps = new Screen[10];操作符new[]()的size_t参数被自动初始化，其值等于存放10个Screen对象的数组所需内存的字节大小。通用可以定义定位的new和delete操作符。如void *operator new(size_t, Screen *);
47.用户自定义转换函数可以在类类型和转换函数中指定的类型之间的转换。如：operator int();关键字operator之后的名字不一定必须是内置类型的名字，可以使用typedef定义的名字或者类名称等，但是不能为数组或者函数类型。注意，没有返回值。
48. 在一个类的构造函数中，凡只带一个参数的构造函数，都定义了一组隐式转换，把构造函数的参数类型转换为该类的类型。可以使用关键字explicit来阻止编译器使用该构造函数进行隐式类型转换，但是该函数还是可以被用来执行类型转换，只要显式以强制转换。如类Number定义这样一个构造函数 Number(const SmallInt &); 有这样的函数void func(Number); 则代码在未使用explicit下可以使用SmallI func(si); 在使用explicit后可以使用func(Number(si))或者func(static_cast&Number&(si));
49.类模板参数也可以是一个非类型模板参数，绑定给非类型模板参数的表达式必须是一个常量表达式，即它能在编译时被计算。非const对象的值不是一个常量表达式，不能被用作非类型参数的实参，但是名字空间中任何对象的地址是一个常量表达式。如int i = 5;中i不能用作非类型模板参数，但是&i可以。
50.被定义在类模板定义之外的成员函数必须使用特殊的语法，来指明它是一个类模板的函数。如类Queue类的构造函数：template &typename Type& Queue &Type&::Queue() {…}。类模板的成员函数本身也是一个模板，标准C++要求这样的成员函数只有在被调用或者取地址时才被实例化，当类模板被实例化时，类模板的成员函数并不自动被实例化。
51. 有三种友元声明可以出现在类模板中：(1)非模板友元函数或者友元类；(2)绑定的友元类模板或者函数模板。如有模板函数和模板类如下：
template &typename Type& class foobar {…}
template &typename Type& void foo(QueueItem&Type&);
template &typename Type& class Queue { void bar(); … }
在类QueueItem增加以上的友元声明:
template &typename Type& class QueueItem {
friend class foobar&Type&;
friend void foo&Type&(QueueItem&Type&);
friend void Queue&Type&::bar(); …}
(3)非绑定的友元类模板或者函数模板。如下代码：
template &typename Type&class QueueItem {
template &typename T&
template &typename T& friend void foo(QueueItem&T&);
template &typename T& friend void Queue&T&::bar(); … }
52.模板类成员也可以声明静态成员变量，类模板的每个实例都有自己的一组静态数据成员，静态数据成员的模板定义必须出现在类模板定义之外，定义语法类似与类模板定义外的成员函数定义语法。只有当程序使用静态数据成员时，它才从模板定义中被真正实例化。类模板的静态成员本身就是一个模板，静态数据成员的模板定义不会引起任何内存被分配，只有对静态数据成员的某个特定的实例才会分配内存。
53. 类模板的嵌套类型，当外围类被实例化时，它的嵌套类不会自动被实例化，只有当上下文环境缺省需要嵌套类的完整类型时，嵌套类才会被实例化。
54. 函数模板或者类模板可以是一个普通类的成员，也可以是一个类模板的成员，成员模板的定义类似与一般模板的定义。而一个成员模板的定义在模板外部时，如：
template &class T& class Queue {
template &class Iter& void assign(Iter first, Iter last); … }
template &class T& template &class Iter& void Queue&T&::assign(Iter first, Iter last) {…}
55. 模板类的显式实例声明，实例代码如下：
template &typename Type& class Queue {…}
template class Queue &int&; // 显式实例了int类型的Queue
模板类的特化，类似与函数模板的特化，为指定类型的做特别的处理，如
template&& class Queue&int& {…}
模板类的特化，支持部分特化，即，如果类模板有一个以上的模板参数，指定其中一个或者几个(非全部)的参数，称为部分特化。如：
template &int hi, int wid& class Screen {…};
template &int hi& class Screen&hi, 80& {…}
56. 当基类成员名在派生类中被重用时，基类的成员将被隐藏，因为基类的成员属于基类的域。对于成员函数，可以使用using声明来导入基类的成员以构成函数重载。另外一个注意事项是，派生类可以访问其基类的protected的成员，但是不能访问其他的基类成员。如代码 bool NameQuery::compare(const Query *pquery); 该函数可以访问自己基类的成员，但是无法访问pquery的protected的成员，这种形式的访问限制不适用于自己类的其他对象，也就是bool NameQuery::compare(const NameQuery *pquery)中可以访问pquery的protected成员。
57. 派生类由一个或多个基类子对象以及派生类部分构成。派生类的构造函数次序永远是(1)基类构造函数；(2)成员类对象构造函数；(3)派生类构造函数。这个次序跟构造函数初始化列表中的顺序无关。析构函数的次序正好与构造函数次序相反。
58. 当用类域操作符调用虚拟函数时，改变了虚拟机制，使得虚拟函数在编译时刻被静态解析。如Query是基类，NameQuery是派生类，代码：Query *pquery = new NameQuery(); pquery-&isA(); pquery-&Query::isA(); 则两个isA函数调用不同，前一个使用虚拟机制调用NameQuery的函数isA，而后一个直接调用基类的函数。有定义的纯虚拟函数也支持被静态调用。
59. 如果通过基类指针或引用调用派生类实例，则传递给它的缺省实参由基类指定的。
60. 如果用基类的指针来删除一个派生类的对象，为了能正确执行，必须把基类的析构函数设置为virtual的。
61. 虽然不能把new操作符声明为虚拟的，但是可以提供一个代理new操作符，来负责对象分配并拷贝到空闲存储区，通常成为clone，以下是一个例子：virtual Query *clone() {return new NameQuery(*this); }
62. 派生类的赋值操作符operator =调用基类的赋值操作符，可以有两个语法：(1) this-&Query::operator =(rhs); (2)(*static_cast&Query *&(this))=
63. 多继承中，基类构造函数被调用的顺序以类派生表中被声明的顺序为准。析构函数的调用顺序总是与构造函数顺序相反。
64. public派生被称为类型继承，派生类是基类的子类型，派生类反应了一种is-a关系；private派生被成为实现继承，派生类不直接支持基类的接口，它把基类的整个共有接口在派生类中变成private，但是它希望重用基类的实现。Protected派生把基类的所有公有成员变成protected。可以通过using指示符来还原基类的访问等级，但是不能比基类中原定的级别更严格或者更不严格。组合是一种has-a的关系，在只是简单重用实现时，可以按引用(使用一个指针)来组合，组合分为按值组合(通过类的实际对象被声明为一个成员)和按引用组合(通过类对象的引用或者指针成员)。
65. 虚拟继承是一种可替代“按引用组合”的继承机制(普通继承是按值组合)，在虚拟继承下只有一个共享的基类。通过用关键字virtual修改一个基类的声明可以将它指定为被虚拟派生。
66. 在非虚拟派生中，派生类只能显式初始化其直接基类；而在虚拟派生中，只有最终派生类可以直接调用其虚拟基类的构造函数，中间派生类对基类构造函数的调用被自动抑制了，必须由最终派生类提供。构造函数顺序上，虚拟基类在所有非虚拟基类构造前被构造。在虚拟派生下，对于虚拟基类成员的继承比“该成员后来重新定义的实例(即中间派生类重载了该成员)”的权值小，所以中间派生类的成员优先，而在非虚拟派生下则产生二义性。
67. 当一个类模板被用作基类时，必须用它完整的参数表对其进行修饰，如代码：template &class Type& class derived : public Base&type& {…}
68. RTTI（运行时刻类型识别），有两个操作符，dynamic_cast操作符：容许在运行时刻进行类型转换，它可以把一个类类型对象的指针转换成同一类层次结构中的其他类的指针，如果指针转换失败则结果为0，如果引用转换失败则抛出异常；typeid操作符，指出了指针或引用指向对象的实际派生类型。
69. dynamic_cast操作符一次执行两个操作，它检验所请求的转换是否有效，只有有效时才进行转换，而检验过程是发生在运行时刻。它被用来执行从基类指针到派生类指针的安全转换，是一种安全的向下转换。当用于引用时，它抛出std::bad_cast异常。
70. typeid操作符用于获取一个表达式的类型，它必须与表达式或者类型一起使用，可以是内置的类型或者类类型。可以对typeid的结果进行比较，它区分指针和对象，如class A; A typeid(&a)和typeid(a)不同，前者是一个指针，判断指针是typeid(A *)，后者是类对象。它其实返回一个类型为type_info的类对象，该类型定义在&typeinfo&。该类的构造函数都是private，无法自己创建该类的对象，只能通过typeid操作符。该类的实现依赖于编译器。
71. 抛出异常：throw popOnFull(value);执行的步骤：(1)throw表达式通过调用类类型pushOnFull的构造函数创建一个该类的临时对象；(2)创建一个pushOnFull类型的异常，并传递给异常处理代码，该异常对象是第一步throw表达式创建的临时对象的拷贝；(3)在开始查找异常处理代码之前，第一步中的临时对象被销毁。
72. 派生类中虚拟函数的异常规范必须与基类的对应的虚拟函数的异常规范一样或者更严格。
73.通常情况下，在“被抛出的异常的类型”和“异常规范中指定的类型”之间不容许进行类型转换；但是，当异常规范指定一个类类型或者类类型的指针时，则可以抛出“从该类公有继承的类类型”。
74. C++标准库中的异常层次的根类为exception，包含在头文件&exception&。它包含一个what虚拟成员函数。C++标准库将错误分为两大类，逻辑错误和运行时刻错误，并提供了一些从exception继承的类。通过new分配错误会抛出bad_alloc异常。
75. 输出操作符&&默认对C风格的字符串(即类型const char *)做了特殊处理，如果想输出字符串的地址，必须进行强制转换。ostream_iterator和istream_iterator会简化操作。
76. 其它几种常用的输入/输出操作符：(1)get(char &ch)从输入流中提前提取一个字符，包括空白字符，它返回被应用的istream对象。对应的ostream提供了put()，写入一个字符。(2)get的第二个版本和第一个版本功能一样，只是返回值不同，它返回字符值，返回类型是int因为可能返回文件尾标志，该标志通常为-1。(3)get的第三个版本get(char *sink, streamsize size, char delimiter=’\n’); 读取size个字符，除非遇到字符delimiter或者遇到文件尾。该函数不把delimiter字符读入，而是将该字符继续留在流中，所以必须使用ignore来丢弃该字符。(4)getline函数类似与get的第三个版本，除了它自动丢弃了delimiter字符。想确定读入了多少字符，使用gcount函数。(5)istream的read函数和ostream的write函数读取指定长度的字符，除非遇到文件尾。
77.由于不正确的格式而导致失败，istream应该把状态标志为false，is.setstate(ios_base::fallbit);对于错误状态的iostream，提取和插入操作没有影响，但是对它的测试将为false。
78. 通过seekg和seekp函数，可以对fstream类对象重新定位(g表示为了getting字符而定位，而p表示为了putting而定义)。类似的，tellp和tellg获取当前的输出和输入流的位置。
79. 每个流对象都维护了一组条件标志，通过这些条件标志，可以监视当前流的状态：(1)当一个流遇到文件结尾，eof返回true；(2)如果试图做一个无效操作，如seek的操作超出文件尾，则bad返回true；(3)如果操作不成功，比如打开文件流对象失败或者遇到无效的输入格式，则fail返回true；(4)如果其他条件都不为true，则good()为true。显式修改流对象的条件状态有两种方式：(1)clear函数，可以把条件状态复位到一个显式的值；(2)使用setstate函数在现有的条件状态再增加一个条件。可用的条件值是ios_base::badbit, ios_base::eofbit, ios_base::failbit, ios_base::goodbit。同时rdstate函数可以读取当前状态值，返回类型是ios_base::iostate。
C++基本语法(中) 0. 类型转换中的提示实际上就是内置数据类型的提升，如char转换为int，bool转换为int，float转换为double等。 1. 类型转换中的标准转换有五种类型：(1)整值类型转换(不包括提升)；(2)浮点转换；(3)浮点-整值转换；(4)指针转换和(5)bool转换。前三种转换是有潜在危险的转换。所有的标准转换都是等价的。一些注意点：0可以被转换为任何指针类型，这样创建的指针称为空指针值，同时0也可以是任何整型常量表达式。常量表达式0L及0x00都属于整值类型因此能够被转换为int *的空指针值。指针转换允许任何指针类型的实参转换成void *，但是函数指针不能用标准转换为void *。 2. 对于引用参数来说，如果实参是该引用的有效初始值，则为精确匹配，否则为不匹配。 3. 模板非类型参数代表了一个常量表达式，由一个普通的参数声明构成，表示该参数名代表了模板定义种的一个常量。在实例化时，该常量会被一个编译时已知的常量值代替。 4. 在模板中，为了支持类型表达式，必须使用typename；如typename Param::name *p;定义了一个指针p；如果不使用typename则该表达式为乘法。另外，模板函数也可以被声明为inline或extern，必须把指示符放在参数模板后。如template inline T fun1(){…} 5. 函数实参的推演中三种类型转换是允许的：(1)左值转换；(2)限定转换(const和volatile指示符)；(3)到一个基类的转换：如果实参是一个类，它有一个从被指定为函数参数的类模板实例化而来的基类；如下面的代码：template class Array {}; template T min(Array &array) {…}； 6. 可以使用显式指定模板参数，模板参数被显式指定在逗号分隔的列表中，紧跟在函数模板实例的名字后面；如min(a, b);代码强行指定模板参数以unsigned int转换。模板显式指定参数类似于默认参数，只能省略后面的参数。 7. C++支持两种模板编译模式：包含模式和分离模式。包含模式下，在每个模板被实例化的文件中包含函数模板的定义，并且往往把定义放在头文件中；分离模式下，函数模板的声明被放在头文件中，它的定义放在另外一个实现文件中，函数模板在实现文件中的定义必须使用关键字export。 8. C++支持模板的显式实例化，在显式实例化声明所在的文件中，函数模板的定义必须被给出。如template T f(T t); 显式实例化为int *类型，template int *f(int *); 9. C++支持模板的显式特化定义，如：template T max(T t1, T t2){…}显式特化const char *类型的定义：template && const char *max(const char *c1, const char *c2);显式特化隐藏了通用模板对于该类型的实例。如果模板实参可以从函数参数中推演出来，则模板实参的显式特化可以从其中取消。如上面的例子: template && const char *max(const char *, const char *);其省略与显式指定模板参数一样。 10. 抛出异常可通过throw表达式来实现。如抛出一个popOnEmpty(类对象)的异常，表达式为throw popOnEmpty();同时在catch子句中，为了防止大型类对象的复制，可以将catch子句的异常声明改为引用。 11. 在查找用来处理被抛出异常的catch子句时，因为异常而退出复合语句和函数定义，这个过程称为栈展开。C++保证，随着栈的展开，尽管局部类对象的生命期是因为抛出异常而结束，但是所有的析构函数将被调用。要重新抛出接受到的异常，使用语句重新抛出的过程中希望对接受到的异常对象进行修改，必须将catch子句的异常声明改为引用。 12. 异常规范跟随在函数参数表之后，用throw指定，后面是异常类型表。如void pop(int &value) throw(popOnEmpty);异常规范保证不会抛出任何没有出现在异常类型表中的异常。如果在运行时抛出一个没有出现在异常类型表中的异常，则系统调用C++标准库中定义的函数unexpected，该函数直接调用了terminate函数结束程序。空的异常规范不会抛出任何异常。 13. 异常规范可以在函数声明中指出，当有异常规范的指针被初始化时，被用作右值的指针异常规范必须比用作左值的指针规范一样或者更严格，当然，参数类型表必须相同。 14. 使用函数指针来使得template适应更多的场合。内置的函数指针声明的模板定义，代码如下: template& typename Type, bool (*Comp)(const Type&, const Type &)& const Type& min(const Type *p, Comp comp)；该方案的主要缺点是函数调用使它无法内联。使用函数对象来替代函数指针，函数对象是类实现，它重载了调用操作符，即operaotr ()函数。有两个优点：(1)如果被重载的调用操作符是inline，则编译器能执行内联编译；(2)函数对象可以拥有任意数目的额外数据来缓冲结果。改写模板使之能同时接受函数指针和函数对象(缺点是没有任何的原型检查)，template min(const Type *p, Comp comp); 15. 函数对象一般有三个来源，(1)系统预定义的算术、关系和逻辑函数对象，包含头文件；(2)预定义的函数适配器，它容许对预定义的函数对象进行特殊化或者扩展；(3)自定义的函数对象。 16. 标准库提供的函数适配器分为两类：(1)绑定器(binder)，通过把二元函数对象的一个实参绑定到一个特殊的值上，将其转换为一元函数对象，有两种绑定器，bind1st和bind2nd，分别将值绑定到第一个参数和第二个参数上；如下代码: count_if(vec.begin(), vec.end(), bind2nd(less_equal(), 10));(2)取反器(negator)，将一个函数的值翻转的适配器，标准库提供了两个not1和not2。 17. 函数对象类定义的简单形式是包含一个被重载的函数调用操作符。如 class less_equal_ten { public: bool operator() (int val) {return val &= 10;} } 扩展该类，使之容许提供一个遇每个元素比较的值。如: class less_equal_value { public: less_equal_value(int val) : _val(val) {} bool operator() (int val) { return val &= _ } private: int _ } 使用上面这个类：count_if(vec.begin(), vec.end(), less_equal_value(25)); 另外一种拓展该类的方法，不使用构造函数，它根据被比较值对类参数化，如: template class less_equal_value2 { public: bool operator() (int val) { return val &= _ } } 使用该模板类: count_if(vec.begin(), vec.end(), less_equal_value2&25&()); 18. 标准库提供了一组(一共是三个)插入iterator的适配器函数，它们返回特定的插入iterator：(1)back_inserter，使用容器的push_back方法替代赋值操作符；(2)front_inserter，使用容易的push_front方法替代赋值操作符；(3)inserter，使用容器的insert替代赋值操作符，它需要两个实参，容器本身以及它的一个iterator指示起始插入位置。 19. 标准库为输入和输出iostream的iterator提供支持。类istream_iterator类支持在一个istream或其派生类上的iterator操作，同理ostream_iterator支持ostream及其派生类。使用头文件。 20. 标准库定义了五种iterator: (1)InputIterator，用来读取元素，不保证支持写入操作；(2)OutputIterator，用来写入元素，但不保证读入；(3)ForwardIterator，用来以某一个遍历方向向容器读或写；(4)BidirectionIterator，从两个方向读或写一个容器；(5)RandomAccessIterator，出来支持BidirectionIterator所有功能外，还提供在常数时间内访问容器的任意位置。其中(1)和(2)是最基本的两个iterator，需要这两个iterator的地方可以使用(3)(4)(5)的iterator作为替代；需要(3)的可以使用(4)(5)；能够替代(4)的只有(5)。需要(3)的常用GA有：adjacent_find(),swap_range()和replace()等；需要(4)的GA有inplace_merge(), next_permutation()和reverse()；需要(5)的GA有binary_search(),sort_heap()和nth_element()。map,set和list维护了一个(4)类型iterator，所以它们不能使用需要(5)的GA中。而vector和queue维护了(5)类型的iterator，可以使用于所有的GA。 21. 所有泛型算法的前两个实参都是一对iterator，通常成为first和last，标志出要操作容器或者内置数组中的元素范围。一些算法支持多个版本，一个用内置操作符，而第二个接受函数对象或函数指针，通常在函数名称后加上_if，比如count_if()；对修改所操作容器的算法，一般有两个版本，一个替换版本，它改变被应用的容器，另外一个返回带有这些变化的容器复本，是拷贝版本，通常在函数名称后加上_copy，如replace_copy()。头文件是，在使用下列4个算术函数adjacenet_difference, accumulate, inner_product和partial_sum，必须使用头文件。 22. 泛型算法的一些限制：(1)关联容器(map或set等)在内部维护了元素的排序关系，不容许在关联容器上应用重新排序的泛型算法，如sort和partition等。(2)list不支持随机访问，所以merge, remove, reverse, sort和unique等算法最好不要使用在list上。list提供了上述这些泛型算法的成员函数。 23. 在类体外定义inline函数，可以显式在类体的声明中使用关键字inline，或者在类体外的函数定义上显式使用关键字inline，或者两者都有。但是内联函数必须在调用它的每个文本文件中被定义，所以在类体外被定义的内联函数也必须被放在类定义出现的头文件中。 24. 只有被声明为const的成员函数才能被一个const类对象调用。关键字const被放在成员函数的参数表和函数体之间，必须在声明和定义中同时指定const关键字。const函数不能修改类数据成员，但如果类中含有指针，则const函数能修改指针指向的内容。const函数可以被相同参数表的非const函数重载。volatile关键字类似于const。 25. 为了允许修改一个类的数据成员，即使是const对象的数据成员，可以吧数据成员声明为mutable。 26. 类的静态数据成员对每个类类型都只有一个拷贝，由该类类型的所有对象共享访问；它比全局对象有两个优点：(1)静态数据成员没有进入全局名字空间；(2)可以实施数据隐藏，比如设置为private的，而全局变量则不行。一般而言，静态数据成员在该类定义之外被初始化，静态成员的名字必须被其类名限定修饰，如int Account::a=90;和全局变量一样，静态数据成员也只能提供一个定义，也就是初始化不能放在头文件中。特别的是，有序型的const静态数据成员可以在类体中用常量值初始化。如 static const int Account::nameSize = 5;用常量值初始化的静态数据成员是一个常量表达式，同时该成员还必须在类定义之外被定义，即nameSize要起作用，必须在类定义再定义，可以不赋值。数组类型不属于有序，不能再类体中初始化。访问静态成员可以通过类对象使用成员访问操作符或者用被类名修饰的名字直接访问(Account::nameSize)。 27. 静态数据成员的一些独特方式的使用：(1)静态数据成员的类型可以是其所属类，而非static的数据成员只能声明为类对象的指针或者引用。如： class A { public: static Bar mem1; // 合法的。 Bar *pMem2; // 合法的 Bar mem3; // 错误 } (2)静态数据成员可以被作为类成员函数的缺省实参，而非static成员不能。 28. 静态成员函数的声明除了在类体中的函数声明前加上关键字static，以及不能声明为const或volatile之外，与非static成员函数相同。静态成员函数没有this指针。 29. 函数指针不能被赋值为成员函数的地址，即使返回类型和参数表完全匹配。成员函数指针的声明需要扩展的语法，如int (Account::*test)();声明了一个Account类，返回int的无输入参数的成员函数指针。类成员的指针必须总是通过特定的对象或指向该类类型的对象的指针来访问。如类的指针对象pobj调用test函数(pobj-&*test)();或者类对象obj调用test函数(obj.*test)();调用中必须有括号；同理，类成员的指针也必须使用特殊的语法，如typedef int Account::* member=&Account::其中member就是Account类中size的指针，使用它也必须使用指针对象或者类对象。 30. 指向类的静态成员的指针是普通的指针，包括函数指针。 31. 联合是一种特殊的类，一个联合中的数据成员在内存中的存储是相互重叠的，每个数据成员都在相同的内存地址开始，分配给联合的存储区数量是“要包含它最大的数据成员”所需的内存数。默认情况下，联合中所有数据都是public的。union不能有静态数据成员或引用成员，如果一个类类型定义了构造函数、析购函数或拷贝赋值操作符，则它不能成为union的成员类型。 32. 使用union的风险是通过一个不恰当的数据成员意外的获取到当前存储在union中的值，一般的解决方法是定义一个额外对象，来跟踪当前被存储在union中的值的类型，成为union的判别式(discriminet)。一个比较好的经验是为所有union数据类型提供一组访问函数。如：union TokenValue { int _iV char _cV } enum TokenKind { ID, Constant }; class Token{ TokenK TokenV }这里的TokenKind就是判别式。union的名字是可选的，特殊的情况下union实例可以没有名字(定义在类体内部)。 33. 位域是一种特殊的类数据成员，它可以被声明用来存放特定数目的位，位域必须是有序数据类型，可以有符号，也可以无符号。位域标志符后面跟一个冒号，然后是一个常量表达式指定位数，如 unsigned int mode : 2; 位域的访问方式和数据成员相同。取地址操作符不能应用在位域上。 34. 嵌套类是指一个类在另一个类中定义。嵌套类可以通过外围类的访问控制关键字进行控制，比如设置为private可以控制嵌套类无法被直接访问。嵌套类也可以定义在外围类之外，比如ListItem的外围类是List，可以定义class List::ListItem {};这样的代码可以保护嵌套类的代码不公开。嵌套类访问外围类的非静态成员必须通过对象或指针，但可以直接访问外围类的静态成员，类型名和枚举值(假定这些成员是公有的)，类型名是一个typedef名字、枚举类型名或者一个类名。 35. 枚举值在定义枚举的域内可以被直接访问，因为枚举定义并不像类定义一样，它没有维护自己相关的域。 36. C风格的显式初始化表有两个注意缺点：(1)它只能被应用到所有数据成员都是公有的类的对象上；(2)它增加了意外和错误的可能性，比如弄错了初始化的顺序。如Data loc = { “aaa”, 0}; // struct Data的定义是 char* 37. 为构造函数指定实参有三种等价形式，(1) Account acct1(“Anna Press”); (2) Account acct2 = Account(“Anna Press”); (3) Account acct3 = “Anna Press”;第三种形式只能被用于指定单个实参的情形，一般推荐使用(1)。代码Account acct4(); 其实声明了一个函数形式。 38. 使用初始化表和在构造函数内使用数据成员的赋值，两种实现的最终结果是一样的，区别取决于数据成员的类型。构造函数可以认为分为两个阶段：(1)显式或隐式的初始化阶段；(2)一般的计算阶段；计算阶段由构造函数内的所有语句构成。初始化阶段是隐式或者显式的取决于是否存在成员初始化表，隐式初始化阶段按照声明的顺序依次调用所有基类的缺省构造函数，然后是所有成员类对象的缺省构造函数。对于内置类型的成员，除了两个例外，初始化表和在构造函数内初始化在结果和性能上是等价的。两个例外是指const和引用数据成员，它们必须在初始化列表中被初始化。每个成员在初始化表中只能出现一次，初始化的顺序不是由名字在初始化表的顺序决定，而是由成员在类中被声明的顺序。如下的初始化列表会导致错误：class X { int I; int J; X(int v) : j(val), i(j){} … }这里i的值将会是未定义。 39. 用一个类对象初始化另一个类对象，称为缺省的按成员初始化。通常发生在下列情况：(1)用一个类对象显式初始化另一个类对象；(2)把一个类对象作为实参传递给一个函数或者作为一个函数的返回值；(3)非空顺序容器类型的定义，如vector svec(5);创建一个临时对象，然后通过string的拷贝构造函数将该临时对象依次拷贝到vector的5个元素中。(4)将一个类对象插入容器中。 40. 由于构造函数分为两个阶段，所以成员类对象的初始化最好在成员初始化表中初始化。如下代码: Account::Account(const Account &rhs) { _name = rhs._ }这里_name是一个类对象，这行代码需要两次重复工作，首选初始化_name，然后用rhs._name来赋值。修正方法是使用初始化表。 41. C++中类对象的初始化总是比赋值更有效率。如Matrix c = a+b; 的效率比M c = a+b; 更有效率。在循环中使用临时对象初始化也更有效率，因为一般情况下不能直接用被返回的局部对象代替赋值的目的对象。 42. 操作符重载，只有在操作数是类类型的对象时，才能将该操作符作为类成员重载。但是同样可以声明非类成员的操作操作符。除此之外，C++要求，赋值(=)，下标([])，调用(())和成员访问(-&)操作符必须定义为类成员操作符。对于内置类型的操作符，不能被重载，也就是只能为类类型和枚举类型的操作数定义重载操作符。 43. 重载的operator()必须被声明为成员函数，它的参数表可以有任意数目的参数。 44. 为了区分前置操作符和后置操作符的声明，重载的递增(++)和递减(--)的后置操作符的声明有一个额外的int类型的参数。如： Screen &operator ++(); // 前置操作符 Screen &operator ++(int); // 后置操作符 45. 如果一个类提供了两个分别称为操作符new()和操作符delete()的成员函数，那么它就可以承接自己的内存管理权。类成员操作符new()的返回类型必须是void *型，并且有个size_t类型的参数。类成员操作符delete()的返回类型必须是void，并且第一个参数的类型是void *。为一个类类型定义的delete操作符，如果它是被delete表达式调用的，则它可以有两个参数，第一个仍然必须是void *,第二个必须是预定义类型size_t，该参数值被自动初始化，其值等于所需内存的字节大小。例如：void operator delete(void *, size_t);操作符new()和delete()是类的静态成员，它们被自动成为静态函数。
编译C++程序时，编译器自动定义了一个预处理名字__cplusplus，而编译标准C时，自动定义名字__STDC__。另外几个比较有用的预定义名字是__LINE__(文件的当前编译行数)，__FILE__(当前被编译的文件名字)，__DATE__(编译日期)和__TIME__(编译时间)。
1.C库头文件的C++名字总是以字母C开头，后面去掉后缀.h的C名字，如&assert.h&在C++库中的名字是&cassert&。两种使用方法：
#include &assert.h&或者
#include &cassert&
2. 静态与动态内存分配的两个主要区别：(1)静态对象是有名字的变量，可以直接进行操作，动态对象是没有名字的变量，可以通过指针间接进行操作；(2)静态对象的分配和释放由编译器自动处理，而动态对象必须由程序员显式的管理，通过new和delete两个表达式来完成。
3. 类的缺省构造函数是不需要用户提供任何参数的构造函数。
4. STL中标准数组-vector(文件&vector&)，两种遍历方式：(1)通过下标操作符；(2)使用迭代器，如vector&int&::可以通过对iterator解引用来直接访问实际的元素*STL提供了作用于容器类型的泛型算法，头文件&algorithm&。
5. 文字常量是不可寻址的。
6.常用的几个转义序列：
newline(换行符) \n \14
horizontal tab(水平制表符) \t
vertical tab(垂直制表符) \v
backspace(退格符) \b
carriage return(回车键) \r
formfeed(进纸键) \f
alert (bell)(响铃符) \a \7
7. 变量和文字常量都有存储区，区别在于变量是可寻址的，对于每个变量，都有两个值与之关联：数据值，称为对象的右值，是被读取的值，文字常量和变量都可以用作右值；地址值，被称为变量的左值，是位置值，文字变量不用被用作左值。
8.每个指针都有一个相关的类型。不同数据类型的指针之间的区别在于指针所指的对象的类型上。如果我们需要的仅仅是持有地址值，C++提供了一种特殊的指针类型：空(void *)类型指针，它可以被任何数据指针类型的地址值赋值，除了函数指针。不能操作空类型指针所指向的对象，只能传送该地址值或将它与其他地址值做比较。
9. C风格的算法循环：
while(*p++){…}
10.正确定义引用，如下：
const int ival = 1024;
const int *&pi_ref = & // 错误，pi_ref是一个引用，它指向定义为const的int型对象的一个指针，引用不是指向常量，而是指向了一个非常量指针
const int *const &pi_ref = & // OK
11. 指针和引用有两个主要区别，引用必须总是指向一个变量；如果一个引用给另外一个引用赋值，那么改变的是被引用对象而不是引用本身。
12. 布尔类型对象虽然也被看作整数类型的对象，但是它不能被声明为signed，unsigned，short或long。
13. 一个数组不能被另外一个数组初始化，也不能被赋值给另外一个数组，而且，C++不容许声明一个引用数组。
14. 数组标志符代表数组中的第一个元素的地址。它的类型是数组元素类型的指针。
int ia[10];
第一个元素的地址: ia或者是&ia[0]
第二个元素的地址: ia+1或者是&ia[1]
15. STL中vector有两种不同的使用形式：数组习惯，即使用下标操作符，注意只能操作已经存在的成员；STL习惯，使用iterator来操作，对其解引用可以访问实际的对象，也可以通过加减来移动位置。雷同与5。
16. typedef用来为内置的或用户定义的数据类型引入助记符号。
typedef char *
其中cstr的类型是 char *
17. 当一个对象的值可能会在编译器的控制或监制之外被改变时，那么该变量应该声明为volatile，编译器执行的某些例行优化不能应用在已经指定为volatile的对象上。
（注：在多线程编程时会遇到该问题）
18. pair类可以在单个对象内部把相同类型或不同类型的两个值关联起来。我们可以使用成员访问符号来访问pair中的单个元素，他们的名字为first和second。
19.在类体外定义的内联成员函数，应该被包含在含有该类定义的头文件中。
20. setw()是一个预定义的iostream操作符，它读入的字符数最多为传递给它的参数减一。如setw(1024)，则最多读入1023个字符。
21. 标准C++头文件&limits&提供了与内置类型表示有关的信息，另外，还有标准C头文件&climits&和&cfloat&。
22. 对于二元操作符&或者&，左右操作数的计算顺序在标准C和C++中是都是未定义的，因此计算过程必须是与顺序无关的。如ia[index++]&ia[index]就是未定义的。
23. 初始化过程为对象提供初值，而赋值是用一个新值覆盖对象的当前值，一个对象只能被初始化一次，也就是在它被定义的时候，而赋值可以多次。如初始化int ival = 1024;赋值 ival = 1025;赋值操作符的左操作数必须是左值。
24. sizeof操作符的作用是返回一个对象或者类型名的字节长度，返回值类型是size_t，这是一种与机器有关的typedef定义，可以在&cstddef&文件中找到它的定义。
25. 按位非操作符(~)翻转操作数的每一位。移位操作符(&&和&&)将其左边操作数的位向左或者向右移动某些位，移到外面的位被丢弃，左移操作符从右边开始用0填充空位。右移操作符，如果是无符号数从左边开始插入0，否则它或者插入符号位的拷贝或者插入0，这由具体实现定义。按位与(&)对两个操作数的每一位进行与操作(只有两位同时为1时值才为1)。按位异或(^)操作符对两个操作数的每一位进行异或操作(只有两个含有一个1时值才为1，即两位不同值为1)。按位或(|)操作符对两个操作数的每一为进行或操作(只有两位同时为0时值才为0)。如将整数a的第27位设为1：a |= 1 && 27；将第27为设为0：a &= ~(1 && 27) ；测试第27位是否为1：a & (1 && 27)。
26. bitset类，头文件为&bitset&，支持三种构造方式，第一是直接指定向量长度，如bitset &32&第二是显式提供一个无符号参数，如bitset&32& bs(012);将第1和第3位设置为1。第三是传递一个代表1和0集合的字符串参数，还可以标记字符串的范围，如string bitval(“”);bitset&32& bs(bitval, 6, 4);则bs的第1和第5位被初始化为1；如果去掉指定字符串范围的第三个参数，则范围是指定的位置开始一直到字符串的末尾。而函数to_string和to_ulong则把bitset对象转换为字符串和整型表示。
27. 操作符优先级表
28. 隐式转换发生在下列情况下：1.混合类型的算术表达式，即算术转换；2.用一种类型的表达式赋值给另一种类型的对象；3.把一个表达式传递给一个函数调用，表达式的类型和形式参数的类型不相同；4.从一个函数返回一个表达式。
29. 算术转换的两个原则：1.如果必要的话，类型总是提升为较宽的类型；2.所有含有小于整型的整值类型的算术表达式，在计算之前，其类型都会被转换为整型。
30. const_cast转换掉表达式的常量性以及volatile对象的volatile性；如const_cast&char *&ptr；编译器隐式执行的任何类型转换都可以由static_cast显式完成。reinterpret_cast通常对操作数的位模式执行一个比较低层次的重新解释。dynamic_cast支持在运行时刻识别由指针或引用指向的类对象。
31. typename是标准C++中新引入的关键字，用于template中。
32.两个主要的顺序容器是list和vector，另外一个顺序容器是deque；两个主要的关联容器是map和set。
33. 选择顺序容器类型的一些准则：(1)随机访问，vector比list好得多；(2)已知道元素的个数，则vector比list强；(3)如果不只是在容器两端插入和删除元素，则list比vector强很多；(4)除非需要在容器首部插入和删除元素，则vector比deque好。对于小的数据类型，vector的插入大批量数据的性能比list好很多，而大型数据时则相反，解决方案是只保留大型数据的指针。Reserve函数容许将容器的容量设置成一个显式指定的值，resize函数重新设置容器的长度；每个容器支持一组关系操作符；用户定义的类类型必须支持等于操作符，必须支持小于操作符，元素类型必须支持一个缺省值（对类类型，指缺省构造函数）。
34. 除了iterator类型，每个容器还定义了一个const_iterator类型，对遍历const容器是必需的，const_iterator容许以只读方式访问容器的底层元素。Iterator算术运算(是指加法或者减法等算术运算，而不是重载的++操作符)只适用vector或deque，而不适用于list因为list在内存中不是连续存储的。
35. string类的find函数返回一个索引类型string::size_type或者返回string::npos；find_first_of提供了被搜索字符串中任意一个字符相匹配的第一次出现，并返回它的索引位置，substr函数生成现有string对象的子串的一个拷贝，第一个参数指明开始的位置，第二个可选的参数指明子串的长度。rfind，查找最后的指定子串的出现；find_first_not_of查找第一个不与要搜索字符串的任意字符相匹配的字符；find_last_of查找与搜索字符串任意元素相匹配的最后一个字符；find_last_not_of查找字符串中的与搜索字符串任意字符全不匹配的最后一个字符。
36. tolower函数接受一个大写字符，并返回与之等价的小写字母，必须包含头文件&ctype.h&，另外一些该文件中的函数，isalpha, isdigit, ispunct, isspace, toupper等。
37. assign对把字符串进行赋值；append则类似于+=操作符；swap交换两个string的值；进行越界检查的at类似于[]操作符；compare函数提供了两个字符串的字典序比较；replace函数提供了十种方式，可以用一个或者多个字符替换字符串中的一个或多个现有的字符。
38. map定义了一个类型value_type，表示相关的键值对，用于insert函数。
39. 关联容器支持以下两个函数：find查找指定key，不存在则返回end()；count返回指定key值的出现的次数。
40. set定义了一个类型difference_type，是两个iterator相减的结果类型；inserter类用来执行插入操作。如:copy(in, eos, inserter(set1, set1.begin());因为copy执行的是赋值操作，所以使用inserter使用插入操作取代赋值操作。
41. multiset和multimap的特殊操作equal_range返回iterator对值，如:pair&iterator, iterator& pos = mp.equal_range(tst);
42. stack类，头文件&stack&，函数top和pop分别是访问栈顶元素和删除栈顶元素。栈类型是容器适配器，因为它把栈抽象施加到底层容器上，缺省情况下栈使用deque实现，可以自定义缺省的底层容器，如使用list构建stack：stack&int, list&int& & intS
43. C++中，数组永远不会按值传递，它总是传递第一个元素(准确的说是第0个)的指针。多维数组被传递为指向第0个元素的指针。如matrix[][10]等同于int (*matrix)[10]，都表示matrix是个二维数组，每行10列。而int *matrix[10]表示一个含有10指向int的指针的数组。
44. UNIX系统函数chmod改变文件的保护级别，它的函数声明在系统头文件&cstdlib&中。
45. 链接指示符的第一种形式由关键字extern后跟一个字符串常量以及一个普通的函数声明构成，如extern “C” void exit();第二种形式是是多个函数声明用大括号包含再链接指示符复合语句中。链接指示符不能出现在函数中，而且放在头文件中更合适。
46. 支持命令行格式的主函数:int main(int argc, char *argv[]);
47. 指向函数的指针，如int (*pFunc)(int, int)；将取地址符作用于函数名上也能产生指向该类型的指针。如已经存在函数定义int f1(int); int (*pf1)(int)=f1; int (*pf2)(int)=&f1;函数调用可以使用pf1(1)格式或者(*pf1)(1)格式。当一个函数名没有被调用操作符修饰时，会被解释为该类型函数的指针，如存在函数定义int f(int)；表达式f被解释为int (*)(int)。
48. 函数指针数组的定义:int (*testCases[10])();使用typedef可以使声明更易读。如typedef int (*PFV)(); PFV testCases[10];声明一个“指向函数指针数组的指针”，如PFV (*pArray)[10];调用其中函数(*pArray)[2]();
49. 函数参数的类型不能是函数类型，函数类型的参数将被自动转换为该函数类型的指针。如存在函数类型typedef int funtype(int);void sort(int, funtype);与函数定义sort(int, int(*)(int));等价。函数指针也可以作为函数返回值的类型，如int (*ff(int))(int *, int);该声明将ff声明一个函数，它有一个int的参数，它的返回值为一个指向函数的指针，类型为int (*)(int *,int)；
50. 指向C函数的指针与指向C++的函数指针类型不同，也就是：int (*fcpp)(int)与extern “C” int (*fpc)(int)类型不同。并且，当链接指示符作用一个声明上时，所有被它声明的函数都受影响，如extern “C” void f1(void (*pfParm)(int));其中pfParm也是C函数指针。因此，要实现一个含有C函数指针作为参数的C++函数，可以使用typedef，如extern “C” typedef void FC(int); C++函数 void f2(FC *pfParam);
51. 关键字extern为声明但不定义提供了一种方法，extern声明不会引起内存被分配。
52. 设计头文件时不应该含有非inline函数和对象的定义。符号常量的定义和inline函数可以被重复定义多次，在编译期间，在可能的情况下，符号常量的值会取代该名字的出现，这个过程为常量折叠。符号常量是任何const类型的对象。但是如下定义不符合 char *const buf = new char[10];因为它的值不能在编译时确定，不能定义在头文件；const char *msg =”Error”;因为msg不是常量，它是指向常量值的非常量指针，必须修改为const char *const msg=””;
53. 有三种局部对象：自动对象，寄存器对象和局部静态对象。在函数中频繁使用的变量可以使用关键字register声明为寄存器对象。
54. delete表达式只能作用于由new表达式从空闲存储区分配的指针上，如果作用于其他内存指针上，可能导致问题，但是作用于值为0的指针上，delete不会指向任何操作。
55. auto_ptr是STL提供的类模板，可以帮助程序员自动管理用new表达式动态分配的单个对象。头文件为&memory&，只有拥有底层对象所有权的对象负责释放内存，但使用Copy constructor和Assignment进行操作时，左边的对象得到所有权，而右边的则被撤销所有权。使用get来测试是否指向一个底层对象，使用reset来重新设置一个底层对象，assignment操作符不支持内存指针。
56. 可以创建动态的const对象，如const int *pci = new const int(1024);不能创建const对象数组，创建的const对象必须初始化。
57. 定位new表达式容许程序员要求将对象创建在已经被分配好的内存中。如：char *buf=new char [1024];Foo *pb = new (buf) F
58. 可以使用未命名的namespace来声明一个局部于某一文件的实体，即该函数只在当前文件中可见。通常在实现文件中使用，这种方法是用来替换C语言中的static函数声明。
59. 重载函数，两个函数的函数名相同，但函数参数表必须不同，参数个数或参数类型不同；识别函数声明并不考虑传值参数类型是const或者volatile，即void f(int)和函数void f(const int)是同一个函数。但是如果是传地址或者传引用时，则需要考虑这两个修饰符。void f(int *)和函数void f(const int *)为不同的函数。
60. 重载函数集合中的所有函数都应该在同一个域中声明。using声明和using指示符可以使得一个名字空间的成员在另外一个名字空间可见，这对重载函数集合产生影响。using声明总是为重载函数的所有函数声明别名，如果引入一个函数在该域中已经存在并且参数表相同，则产生错误。而extern “C”链接指示符只能指定重载函数集中的一个函数。
61. 函数重载解析的三个步骤(1)确定函数调用考虑的重载函数的集合，确定函数调用中实参表的属性；(2)从重载函数集合中选择函数，该函数可以在给定的情况下用实参进行调用；(3)选择与调用最匹配的函数。在第二步中，编译器确定需要进行的参数转换，并划分等级，通常分为精确匹配；与一个类型转换匹配；无匹配。其中类型转换通常分为三组：提升、标准转换和用户定义的转换。
62. 精确匹配细节：即使一个实参必须应用一些最小的类型转换才能将其转换为相应函数参数的类型；这些最小的类型转换包括：左值到右值的转换；从数组到指针；从函数到指针的转换和限定类型转换(通常是const和volatile类型转换)。精确匹配可以使用一个显式强制转换强行执行，这时实参类型就为转换后的类型。
线形表a、b为两个有序升序的线形表，编写一程序，使两个有序线形表合并成一个有序升序线形表h；
答案在 请化大学 严锐敏《数据结构第二版》第二章例题，数据结构当中，这个叫做：两路归并排序
Linklist *unio(Linklist *p,Linklist *q){
linklist *R,*pa,*qa,*
while(pa-&next!=NULL&&qa-&next!=NULL){
if(pa-&data&qa-&data){
if(pa-&next!=NULL)
if(qa-&next!=NULL)
ra-&next==
2、运用四色定理，为N个局域举行配色，颜色为1、2、3、4四种，另有数组adj[][N]，如adj[i][j]=1则表示i区域与j区域相邻，数组color[N]，如color[i]=1,表示i区域的颜色为1号颜色。
3、用递归算法判断数组a[N]是否为一个递增数组。
递归的方法，记录当前最大的，并且判断当前的是否比这个还大，大则继续，否则返回false结束：
bool fun( int a[], int n )
if( n= =1 )
if( n= =2 )
return a[n-1] &= a[n-2];
return fun( a,n-1) && ( a[n-1] &= a[n-2] );
4、编写算法，从10亿个浮点数当中，选出其中最大的10000个。
用外部排序，在《数据结构》书上有
《计算方法导论》在找到第n大的数的算法上加工
5、编写一unix程序，防止僵尸进程的出现.
同学的4道面试题，应聘的职位是搜索引擎工程师，后两道超级难，（希望大家多给一些算发）
1.给两个数组和他们的大小，还有一动态开辟的内存，求交集，把交集放到动态内存dongtai，并且返回交集个数
long jiaoji(long* a[],long b[],long* alength,long blength,long* dongtai[])
2.单连表的建立，把'a'--'z'26个字母插入到连表中，并且倒叙，还要打印！
typedef struct val
{ int date_1;
struct val *
void main(void)
for(c=122;c&=97;c--)
{ p.date=c;
p.next=NULL;
node *p = NULL;
node *q = NULL;
node *head = (node*)malloc(sizeof(node));
head-&data = ' ';head-&next=NULL;
node *first = (node*)malloc(sizeof(node));
first-&data = 'a';first-&next=NULL;head-&next =
int longth = 'z' - 'b';
while ( i&=longth )
node *temp = (node*)malloc(sizeof(node));
temp-&data = 'b'+i;temp-&next=NULL;q=
head-&next = temp-&next=p;p=q;
print(head);
3.可怕的题目终于来了
象搜索的输入信息是一个字符串，统计300万输入信息中的最热门的前十条，我们每次输入的一个字符串为不超过255byte,内存使用只有1G,
请描述思想，写出算发（c语言），空间和时间复杂度，
4.国内的一些帖吧，如baidu,有几十万个主题，假设每一个主题都有上亿的跟帖子，怎么样设计这个系统速度最好，请描述思想，写出算发（c语言），空间和时间复杂度，
#include string.h
main(void)
{ char *src="hello,world";
char *dest=NULL;
dest=(char *)malloc(strlen(src));
int len=strlen(str);
char *s=src[len];
while(len--!=0)
printf("%s",dest);
找出错误！！
#include "string.h"
#include "stdio.h"
#include "malloc.h"
main(void)
char *src="hello,world";
char *dest=NULL;
dest=(char *)malloc(sizeof(char)*(strlen(src)+1));
int len=strlen(src);
char *s=src+len-1;
while(len--!=0)
*d++=*s--;
printf("%s",dest);
1. 简述一个Linux驱动程序的主要流程与功能。
2. 请列举一个软件中时间换空间或者空间换时间的例子。
void swap(int a,int b)
c=a;a=b;b=a;
void swap(int a,int b)
a=a+b;b=a-b;a=a-b;
6. 请问一下程序将输出什么结果？
char *RetMenory(void)
char p[] = “hellow world”;
void Test(void)
char *str = NULL;
str = RetMemory();
printf(str);
RetMenory执行完毕，p资源被回收，指向未知地址。返回地址，str的内容应是不可预测的, 打印的应该是str的地址
写一个函数,它的原形是int continumax(char *outputstr,char *intputstr)
在字符串中找出连续最长的数字串，并把这个串的长度返回，并把这个最长数字串付给其中一个函数参数outputstr所指内存。例如："abcd1ss"的首地址传给intputstr后，函数将返回
9，outputstr所指的值为
int continumax(char *outputstr, char *inputstr)
char *in = inputstr, *out = outputstr, *temp, *
int count = 0, maxlen = 0;
while( *in != '\0' )
if( *in & 47 && *in & 58 )
for(temp = *in & 47 && *in & 58 ; in++ )
if( maxlen & count )
count = 0;
for(int i = 0; i & i++)
*out = '\0';
不用库函数,用C语言实现将一整型数字转化为字符串
int getlen(char *s){
for(n = 0; *s != '\0'; s++)
void reverse(char s[])
int c,i,j;
for(i = 0,j = getlen(s) - 1; i & i++,j--){
s[i] = s[j];
void itoa(int n,char s[])
if((sign = n) & 0)
do{/*以反序生成数字*/
s[i++] = n%10 + '0';/*get next number*/
}while((n /= 10) & 0);/*delete the number*/
if(sign & 0)
s[i++] = '-';
s[i] = '\0';
reverse(s);
#include &iostream&
void itochar(int num);
void itochar(int num)
int i = 0;
char stra[10];
char strb[10];
while ( num )
stra[i++]=num%10+48;
num=num/10;
stra[i] = '\0';
for( j=0; j & j++)
strb[j] = stra[i-j-1];
strb[j] = '\0';
cout&&strb&&
int main()
itochar(num);
前几天面试，有一题想不明白,请教大家！
typedef struct
printf("%d",t.a);
printf("%d",t.b);
printf("%d",t.c);
t.a为01,输出就是1
t.b为11，输出就是－1
t.c为1，输出也是-1
3个都是有符号数int嘛。
这是位扩展问题
编译器进行符号扩展
求组合数： 求n个数（1....n）中k个数的组合....
如：combination(5,3)
要求输出：543，542，541，532，531，521，432，431，421，321，
#include&stdio.h&
int pop(int *);
int push(int );
void combination(int ,int );
int stack[3]={0};
int main()
printf("Input two numbers:\n");
while( (2!=scanf("%d%*c%d",&n,&m)) )
fflush(stdin);
printf("Input error! Again:\n");
combination(n,m);
printf("\n");
void combination(int m,int n)
int temp=m;
push(temp);
if(1==temp)
if(pop(&temp)&&stack[0]==n) //当栈底元素弹出&&为可能取的最小值，循环退出
else if( push(--temp))
printf("%d%d%d ",stack[0],stack[1],stack[2]);//§&¨ì¤@?
pop(&temp);
int push(int i)
stack[++top]=i;
int pop(int *i)
*i=stack[top--];
if(top&=0)
1、用指针的方法，将字符串“ABCD1234efgh”前后对调显示
#include &stdio.h&
#include &string.h&
#include &dos.h&
int main()
char str[] = "ABCD1234efgh";
int length = strlen(str);
char * p1 =
char * p2 = str + length - 1;
while(p1 & p2)
char c = *p1;
*p1 = *p2;
printf("str now is %s\n",str);
system("pause");
2、有一分数序列：1/2,1/4,1/6,1/8……，用函数调用的方法，求此数列前20项的和
#include &stdio.h&
double getValue()
double result = 0;
int i = 2;
while(i & 42)
result += 1.0 ///一定要使用1.0做除数，不能用1，否则结果将自动转化成整数，即0.000000
int main()
printf("result is %f\n", getValue());
system("pause");
有一个数组a[1000]存放0--1000;要求每隔二个数删掉一个数，到末尾时循环至开头继续进行，求最后一个被删掉的数的原始下标位置。
以7个数为例：
{0,1,2,3,4,5,6,7} 0--&1--&2（删除）--&3--&4--&5(删除)--&6--&7--&0（删除），如此循环直到最后一个数被删除。
方法1：数组
#include &iostream&
#define null 1000
int main()
int arr[1000];
for (int i=0;i&1000;++i)
int count=0;
while(count&999)
while(arr[j%1000]==null)
j=(++j)%1000;
j=(++j)%1000;
while(arr[j%1000]==null)
j=(++j)%1000;
j=(++j)%1000;
while(arr[j%1000]==null)
j=(++j)%1000;
while(arr[j]==null)
j=(++j)%1000;
}方法2：链表
#include&iostream&
#define null 0
struct node
int main()
node* head=
head-&data=0;
head-&next=
for(int i=1;i&1000;i++)
node* tmp=
tmp-&data=i;
tmp-&next=
head-&next=
head=head-&
head-&next=p;
while(p!=p-&next)
p-&next-&next=p-&next-&next-&
p=p-&next-&
方法3：通用算法
#include &stdio.h&
#define MAXLINE 1000 //元素个数
MAXLINE 元素个数
a[] 元素数组
R[] 指针场
suffix 下标
index 返回最后的下标序号
values 返回最后的下标对应的值
start 从第几个开始
int find_n(int a[],int R[],int K,int& index,int& values,int s=0) {
int front_node,current_
if(s==0) {
current_node=0;
front_node=MAXLINE-1;
current_node=s;
front_node=s-1;
while(R[front_node]!=front_node) {
printf("%d\n",a[current_node]);
R[front_node]=R[current_node];
if(K==1) {
current_node=R[front_node];
for(int i=0;i&K;i++){
front_node=R[front_node];
current_node=R[front_node];
index=front_
values=a[front_node];
int main(void) {
int a[MAXLINE],R[MAXLINE],suffix,index,values,start,i,K;
suffix=index=values=start=0;
for(i=0;i&MAXLINE;i++) {
find_n(a,R,K,index,values,2);
printf("the value is %d,%d\n",index,values);
void test2()
char string[10], str1[10];
for(i=0; i&10; i++)
str1[i] = 'a';
strcpy( string, str1 );
解答：对试题2，如果面试者指出字符数组str1不能在数组内结束可以给3分；如果面试者指出strcpy(string, str1)调用使得从str1内存起复制到string内存起所复制的字节数具有不确定性可以给7分，在此基础上指出库函数strcpy工作方式的给10分；
str1不能在数组内结束:因为str1的存储为：{a,a,a,a,a,a,a,a,a,a},没有'\0'(字符串结束符)，所以不能结束
strcpy( char *s1,char *s2)他的工作原理是，扫描s2指向的内存，逐个字符付到s1所指向的内存，直到碰到'\0',因为str1结尾没有'\0'，所以具有不确定性，不知道他后面还会付什么东东。
正确应如下
void test2()
char string[10], str1[10];
for(i=0; i&9; i++)
str1[i] = 'a'+i; //把abcdefghi赋值给字符数组
str[i]='\0';//加上结束符
strcpy( string, str1 );
第二个code题是实现strcmp
int StrCmp(const char *str1, const char *str2)
做是做对了，没有抄搞，比较乱
int StrCmp(const char *str1, const char *str2)
assert(str1 && srt2);
while (*str1 && *str2 && *str1 == *str2) {
str1++, str2++;
if (*str1 && *str2)
return (*str1-*str2);
elseif (*str1 && *str2==0)
elseif (*str1 = = 0 && *str2)
return -1;
int StrCmp(const char *str1, const char *str2)
//省略判断空指针(自己保证)
while(*str1 && *str1++ = = *str2++);
return *str1-*str2;
第三个code题是实现子串定位
int FindSubStr(const char *MainStr, const char *SubStr)
做是做对了，没有抄搞，比较乱
int MyStrstr(const char* MainStr, const char* SubStr)
const char *p;
const char *q;
const char * u = MainS
//assert((MainStr!=NULL)&&( SubStr!=NULL));//用断言对输入进行判断
while(*MainStr) //内部进行递增
while(*q && *p && *p++ == *q++);
return MainStr - u +1 ;//MainStr指向当前起始位，u指向
MainStr ++;
return -1;
int arr[] = {6,7,8,9,10};
int *ptr =
*(ptr++)+=123;
printf(“ %d %d ”, *ptr, *(++ptr));
过程：对于*(ptr++)+=123;先做加法6+123，然后++，指针指向7；对于printf(“ %d %d ”, *ptr, *(++ptr));从后往前执行，指针先++，指向8，然后输出8，紧接着再输出8
华为全套完整试题
6、已知一个单向链表的头，请写出删除其某一个结点的算法，要求，先找到此结点，然后删除。
slnodetype *Delete(slnodetype *Head,int key){}中if(Head-&number==key)
Head=Pointer-&
free(Pointer);
Pointer=Pointer-&
if(Pointer-&number==key)
Back-&next=Pointer-&
free(Pointer);
void delete(Node* p)
if(Head = Node)
有一个16位的整数，每4位为一个数，写函数求他们的和。
和 11+0111
感觉应该不难，当时对题理解的不是很清楚，所以写了一个函数，也不知道对不对。
既然是16位的整数，0111是2进制的，那么函数参数怎么定义呢，请大虾指教。
答案：用十进制做参数，计算时按二进制考虑。
/* n就是16位的数，函数返回它的四个部分之和 */
char SumOfQuaters(unsigned short n)
char c = 0;
int i = 4;
c += n & 15;
n = n && 4;
} while (--i);
有1,2,....一直到n的无序数组,求排序算法,并且要求时间复杂度为O(n),空间复杂度O(1),使用交换,而且一次只能交换两个数.（华为）
#include&iostream.h&
int main()
int a[] = {10,6,9,5,2,8,4,7,1,3};
int len = sizeof(a) / sizeof(int);
for(int i = 0; i & )
temp = a[a[i] - 1];
a[a[i] - 1] = a[i];
if ( a[i] == i + 1)
for (int j = 0; j & j++)
cout&&a[j]&&",";
1 写出程序把一个链表中的接点顺序倒排
typedef struct linknode
struct linknode *
//将一个链表逆置
node *reverse(node *head)
node *p,*q,*r;
while(q!=NULL)
q-&next=p;
head-&next=NULL;
2 写出程序删除链表中的所有接点
void del_all(node *head)
while(head!=NULL)
free(head);
cout&&"释放空间成功!"&&
3两个字符串，s,t;把t字符串插入到s字符串中，s字符串有足够的空间存放t字符串
void insert(char *s, char *t, int i)
char *p =s;
if(q == NULL)
while(*p!='\0')
while(*q!=0)
*p = '\0';
分析下面的代码：
char *a = "hello";
char *b = "hello";
printf("YES");
printf("NO");
这个简单的面试题目,我选输出 no(对比的应该是指针地址吧),可在VC是YES 在C是NO
lz的呢，是一个常量字符串。位于静态存储区，它在程序生命期内恒定不变。如果编译器优化的话，会有可能a和b同时指向同一个hello的。则地址相同。如果编译器没有优化，那么就是两个不同的地址，则不同
写一个函数，功能：完成内存之间的拷贝
memcpy source code:
270 void* memcpy( void *dst, const void *src, unsigned int len )
272 register char *d;
273 register char *s;
275 if (len == 0)
278 if (is_overlap(dst, src, len, len))
279 complain3("memcpy", dst, src, len);
281 if ( dst & src ) {
282 d = (char *)dst + len - 1;
283 s = (char *)src + len - 1;
284 while ( len &= 4 ) {
285 *d-- = *s--;
286 *d-- = *s--;
287 *d-- = *s--;
288 *d-- = *s--;
289 len -= 4;
291 while ( len-- ) {
292 *d-- = *s--;
294 } else if ( dst & src ) {
295 d = (char *)
296 s = (char *)
297 while ( len &= 4 ) {
298 *d++ = *s++;
299 *d++ = *s++;
300 *d++ = *s++;
301 *d++ = *s++;
302 len -= 4;
304 while ( len-- ) {
305 *d++ = *s++;
公司考试这种题目主要考你编写的代码是否考虑到各种情况，是否安全（不会溢出）
各种情况包括：
１、参数是指针，检查指针是否有效
２、检查复制的源目标和目的地是否为同一个，若为同一个，则直接跳出
３、读写权限检查
４、安全检查，是否会溢出
memcpy拷贝一块内存，内存的大小你告诉它
strcpy是字符串拷贝，遇到'\0'结束
/* memcpy ─── 拷贝不重叠的内存块 */
void memcpy(void* pvTo, void* pvFrom, size_t size)
void* pbTo = (byte*)pvTo;
void* pbFrom = (byte*)pvF
ASSERT(pvTo != NULL && pvFrom != NULL); //检查输入指针的有效性
ASSERT(pbTo&=pbFrom+size || pbFrom&=pbTo+size);//检查两个指针指向的内存是否重叠
while(size--&0)
*pbTo++ == *pbFrom++;
return(pvTo);
华为面试题：怎么判断链表中是否有环？
bool CircleInList(Link* pHead)
if(pHead = = NULL || pHead-&next = = NULL)//无节点或只有一个节点并且无自环
return (false);
if(pHead-&next = = pHead)//自环
return (true);
Link *pTemp1 = pH//step 1
Link *pTemp = pHead-&//step 2
while(pTemp != pTemp1 && pTemp != NULL && pTemp-&next != NULL)
pTemp1 = pTemp1-&
pTemp = pTemp-&next-&
if(pTemp = = pTemp1)
return (true);
return (false);
两个字符串，s,t;把t字符串插入到s字符串中，s字符串有足够的空间存放t字符串
void insert(char *s, char *t, int i)
memcpy(&s[strlen(t)+i],&s[i],strlen(s)-i);
memcpy(&s[i],t,strlen(t));
s[strlen(s)+strlen(t)]='\0';
1。编写一个 C 函数，该函数在一个字符串中找到可能的最长的子字符串，且该字符串是由同一字符组成的。
char * search(char *cpSource, char ch)
char *cpTemp=NULL, *cpDest=NULL;
int iTemp, iCount=0;
while(*cpSource)
if(*cpSource == ch)
iTemp = 0;
cpTemp = cpS
while(*cpSource == ch)
++iTemp, ++cpS
if(iTemp & iCount)
iCount = iTemp, cpDest = cpT
if(!*cpSource)
return cpD
2。请编写一个 C 函数，该函数在给定的内存区域搜索给定的字符，并返回该字符所在位置索引值。
int search(char *cpSource, int n, char ch)
for(i=0; i&n && *(cpSource+i) != ++i);
一个单向链表，不知道头节点,一个指针指向其中的一个节点，问如何删除这个指针指向的节点？
将这个指针指向的next节点值copy到本节点，将next指向next-&next,并随后删除原next指向的节点。
#include &stdio.h&
void foo(int m, int n)
printf("m=%d, n=%d\n", m, n);
int main()
int b = 3;
foo(b+=3, ++b);
printf("b=%d\n", b);
输出：m=7,n=4,b=7(VC6.0)
这种方式和编译器中得函数调用关系相关即先后入栈顺序。不过不同
编译器得处理不同。也是因为C标准中对这种方式说明为未定义，所以
各个编译器厂商都有自己得理解，所以最后产生得结果完全不同。
因为这样，所以遇见这种函数，我们首先要考虑我们得编译器会如何处理
这样得函数，其次看函数得调用方式，不同得调用方式，可能产生不同得
结果。最后是看编译器优化。
2.写一函数，实现删除字符串str1中含有的字符串str2.
第二个就是利用一个KMP匹配算法找到str2然后删除（用链表实现的话，便捷于数组）
/*雅虎笔试题(字符串操作)
给定字符串A和B,输出A和B中的最大公共子串。
比如A="aocdfe" B="pmcdfa" 则输出"cdf"
//Author: azhen
#include&stdio.h&
#include&stdlib.h&
#include&string.h&
char *commanstring(char shortstring[], char longstring[])
char *substring=malloc(256);
if(strstr(longstring, shortstring)!=NULL) //如果……，那么返回shortstring
for(i=strlen(shortstring)-1;i&0; i--) //否则，开始循环计算
for(j=0; j&=strlen(shortstring)-i; j++){
memcpy(substring, &shortstring[j], i);
substring[i]='\0';
if(strstr(longstring, substring)!=NULL)
return NULL;
char *str1=malloc(256);
char *str2=malloc(256);
char *comman=NULL;
gets(str1);
gets(str2);
if(strlen(str1)&strlen(str2)) //将短的字符串放前面
comman=commanstring(str2, str1);
comman=commanstring(str1, str2);
printf("the longest comman string is: %s\n", comman);
11.写一个函数比较两个字符串str1和str2的大小，若相等返回0，若str1大于
str2返回1，若str1小于str2返回－1
int strcmp ( const char * src,const char * dst)
int ret = 0 ;
while( ! (ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst)
if ( ret & 0 )
ret = -1 ;
else if ( ret & 0 )
return( ret );
3,求1000！的未尾有几个0（用素数相乘的方法来做，如72=2*2*2*3*3）;
求出1-&1000里,能被5整除的数的个数n1,能被25整除的数的个数n2,能被125整除的数的个数n3,
能被625整除的数的个数n4.
1000!末尾的零的个数=n1+n2+n3+n4;
#include&stdio.h&
#define NUM 1000
int find5(int num){
int ret=0;
while(num%5==0){
int main(){
int result=0;
for(i=5;i&=NUM;i+=5)
result+=find5(i);
printf(" the total zero number is %d\n",result);
1. 有双向循环链表结点定义为：
struct node
struct node *front,*
有两个双向循环链表A，B，知道其头指针为：pHeadA,pHeadB，请写一函数将两链表中data值相同的结点删除
BOOL DeteleNode(Node *pHeader, DataType Value)
if (pHeader == NULL)
BOOL bRet = FALSE;
Node *pNode = pH
while (pNode != NULL)
if (pNode-&data == Value)
if (pNode-&front == NULL)
pHeader = pNode-&
pHeader-&front = NULL;
if (pNode-&next != NULL)
pNode-&next-&front = pNode-&
pNode-&front-&next = pNode-&
Node *pNextNode = pNode-&
pNode = pNextN
bRet = TRUE;
//不要break或return, 删除所有
pNode = pNode-&
void DE(Node *pHeadA, Node *pHeadB)
if (pHeadA == NULL || pHeadB == NULL)
Node *pNode = pHeadA;
while (pNode != NULL)
if (DeteleNode(pHeadB, pNode-&data))
if (pNode-&front == NULL)
pHeadA = pNode-&
pHeadA-&front = NULL;
pNode-&front-&next = pNode-&
if (pNode-&next != NULL)
pNode-&next-&front = pNode-&
Node *pNextNode = pNode-&
pNode = pNextN
pNode = pNode-&
2. 编程实现：找出两个字符串中最大公共子字符串,如"abccade","dgcadde"的最大子串为"cad"
int GetCommon(char *s1, char *s2, char **r1, char **r2)
int len1 = strlen(s1);
int len2 = strlen(s2);
int maxlen = 0;
for(int i = 0; i & len1; i++)
for(int j = 0; j & len2; j++)
if(s1[i] == s2[j])
int as = i, bs = j, count = 1;
while(as + 1 & len1 && bs + 1 & len2 && s1[++as] == s2[++bs])
if(count & maxlen)
*r1 = s1 +
*r2 = s2 +
3. 编程实现：把十进制数(long型)分别以二进制和十六进制形式输出，不能使用printf系列库函数
char* test3(long num) {
char* buffer = (char*)malloc(11);
buffer[0] = '0';
buffer[1] = 'x';
buffer[10] = '\0';
char* temp = buffer + 2;
for (int i=0; i & 8; i++) {
temp[i] = (char)(num&&4*i&&28);
temp[i] = temp[i] &= 0 ? temp[i] : temp[i] + 16;
temp[i] = temp[i] & 10 ? temp[i] + 48 : temp[i] + 55;
输入N, 打印 N*N 矩阵
比如 N = 3，打印：
N = 4，打印：
12 13 14 5
11 16 15 6
1 #define N 15
int s[N][N];
void main()
int k = 0, i = 0, j = 0;
int a = 1;
for( ; k & (N+1)/2; k++ )
while( j & N-k ) s[i][j++] = a++; i++; j--;
while( i & N-k ) s[i++][j] = a++; i--; j--;
while( j & k-1 ) s[i][j--] = a++; i--; j++;
while( i & k ) s[i--][j] = a++; i++; j++;
for( i = 0; i & N; i++ )
for( j = 0; j & N; j++ )
cout && s[i][j] && '\t';
2 define MAX_N 100
int matrix[MAX_N][MAX_N];
*（x,y）：第一个元素的坐标
* start：第一个元素的值
* n：矩阵的大小
void SetMatrix(int x, int y, int start, int n) {
if (n &= 0) //递归结束条件
if (n == 1) { //矩阵大小为1时
matrix[x][y] =
for (i = i & x + n-1; i++) //矩阵上部
matrix[y][i] = start++;
for (j = j & y + n-1; j++) //右部
matrix[j][x+n-1] = start++;
for (i = x+n-1; i & i--) //底部
matrix[y+n-1][i] = start++;
for (j = y+n-1; j & j--) //左部
matrix[j][x] = start++;
SetMatrix(x+1, y+1, start, n-2); //递归
void main() {
scanf("%d", &n);
SetMatrix(0, 0, 1, n);
//打印螺旋矩阵
for(i = 0; i & i++) {
for (j = 0; j & j++)
printf("%4d", matrix[i][j]);
printf("\n");
斐波拉契数列递归实现的方法如下：
int Funct( int n )
if(n==0) return 1;
if(n==1) return 1;
retrurn Funct(n-1) + Funct(n-2);
请问，如何不使用递归，来实现上述函数？
请教各位高手！
解答：int Funct( int n ) // n 为非负整数
if(n==0) c=1;
else if(n==1) c=1;
else for(int i=2;i&=n;i++) //应该n从2开始算起
现在大多数系统都是将低字位放在前面，而结构体中位域的申明一般是先声明高位。
100 的二进制是 001 100 100
低位在前 高位在后
所以结果应该是 1
如果先申明的在低位则：
1、原题跟little-endian，big-endian没有关系
2、原题跟位域的存储空间分配有关，到底是从低字节分配还是从高字节分配，从Dev C++和VC7.1上看，都是从低字节开始分配，并且连续分配，中间不空，不像谭的书那样会留空位
3、原题跟编译器有关，编译器在未用堆栈空间的默认值分配上有所不同，Dev C++未用空间分配为
b，VC7.1下为b,所以在Dev C++下的结果为5，在VC7.1下为1。
注：PC一般采用little-endian，即高高低低，但在网络传输上，一般采用big-endian，即高低低高，华为是做网络的，所以可能考虑big-endian模式，这样输出结果可能为4
判断一个字符串是不是回文
int IsReverseStr(char *aStr)
int found=1;
if(aStr==NULL)
return -1;
j=strlen(aStr);
for(i=0;i&j/2;i++)
if(*(aStr+i)!=*(aStr+j-i-1))
Josephu 问题为：设编号为1，2，… n的n个人围坐一圈，约定编号为k（1&=k&=n）的人从1开始报数，数到m 的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。
数组实现：
#include &stdio.h&
#include &malloc.h&
int Josephu(int n, int m)
int flag, i, j = 0;
int *arr = (int *)malloc(n * sizeof(int));
for (i = 0; i & ++i)
arr[i] = 1;
for (i = 1; i & ++i)
while (flag & m)
if (j == n)
if (arr[j])
arr[j - 1] = 0;
printf("第%4d个出局的人是：%4d号\n", i, j);
free(arr);
int main()
scanf("%d%d", &n, &m);
printf("最后胜利的是%d号！\n", Josephu(n, m));
system("pause");
链表实现：
#include &stdio.h&
#include &malloc.h&
typedef struct Node
struct Node *
int Josephu(int n, int m)
JosephuNode *head, *
head = tail = (JosephuNode *)malloc(sizeof(JosephuNode));
for (i = 1; i & ++i)
tail-&index =
tail-&next = (JosephuNode *)malloc(sizeof(JosephuNode));
tail = t