最近几天的收获,内容比较杂

对于在表达是中的两个整数相除，结果仍然是整数。
在c语言中，没有引用。可以使用指针来代替。
使new 这里是常量.一般写成const char* ="abc";
字符串常量类型可以理解为const char[7] :"abcdef";
类string的设计:
class String
{
public:
String(const char *str=NULL);
String(const String &other);
~String(void);
String & operate= (const String &other);
private:
char *m_data;
};

构造函数初始化表使用规则:
1.如果类存在继承关系,派生类必须在其初始化表里调用嗯.
2.类的const常量只能在初始化表中初始化.
引发NoMen异常
class NoMem{
public:
NoMem(){}
};
void my_new_handler()
{
throw Nomem();
}
new_handler Old_Handler_=set_new_handler(my_new_handler);

_set_new_handler在MSDN中的声明是:
_PNH _set_new_handler(_PNH pNewHandler);
如果new操作分配内存失败,则转向_set_new_handler所 指定的错误处理机制中去处理.
typedef int (__cdecl * _PNH)(size_t);
链表遍历器类:有两个共享成员Initialize和Next,Initialize返回一个指针,指向第一个链表节点中所包含的数据,同时把私有变量location设置为指向链表的第一个节点.成员Next用来调整location,使其指向链表中的下一个节点.
友元类
template<class T> class b;
template<class T>
class a
{
friend class b<T>;
...
};
template<class T>
class b{}...
在编写链表程序时,主要注意指针是否为空,交换的是指针的值,还是指针所指向的值.

间接寻址:
采用索引来访问每个元素,并且在插入和删除操作时,不用对元素移动.

采用一个节点数组以及对改数组进行索引的模拟指针.
P3-29

多态性 ---vptr和vtable http://blog.csdn.net/dongfengsun/archive/2007/02/05/1502916.aspx #include<iostream>
using namespace std;
typedef void (*fun)();

class Base
{
int a;
public:
virtual void fun1(){cout<<"Base::fun1()"<<endl;}
virtual void fun2(){cout<<"Base::fun2()"<<endl;}
virtual void fun3(){cout<<"Base::fun3()"<<endl;}
};
class A:public Base
{
int a;
public:
void fun1(){cout<<"A::fun1()"<<endl;}
void fun2(){cout<<"A::fun2()"<<endl;}
};
void *getp(void *p)
{
return (void*)*(unsigned long *)p;
}
fun getfun(Base *obj,unsigned long off)
{
void *vptr=getp(obj);
unsigned char *p=(unsigned char *)vptr;
p+=sizeof(void*)*off;//???
return (fun)getp(p);

}
void foo(Base &obj)
{
obj.fun1();
obj.fun2();
obj.fun3();
}
int main()
{
Base *p= new Base;
fun f=getfun(p,0);
(*f)();
f=getfun(p,1);
(*f)();
f=getfun(p,2);
(*f)();
delete p;
}
使用该函数可以了解的多态更透彻
可以修改Base *p=new A;
A *p=new Base;
查看结果,最后一个属于向下转型,是不可靠的.在G++编译器中会显示该错误但是在VC6.0就不知道了.

函数指针与int * 或double *定义指针不同,函数指针必须同时指出输入参数,标明这是一个函数指针,int (*fun) (int x,int y);

使用typedef定义函数指针
typedef char(*PTRFUN)(int);
PTRFUN pFun;
char glFun(int a){return ;}
pFun=glFun;
(*pFun)(2);

在C++中,不能把构造和析构函数定义为默认的private.并且全局函数在调用main之前初始化,在推出main之后析构.在MFC中又体现.theWinApp??

有关#define的用法
1.简单定义
#define MAXTIME 1000
2.define定义函数
#define max(x,y) (x)>(y)?(x):(y);
3.宏的单行定义
#define A(x) T_##x A(1) -------> T_1
#define B(x) #@x B(1) --------> '1'

4define 的多行定义
#define MACRO(arg1, arg2) do { /
/* declarations */ /
stmt1; /
stmt2; /
/* ... */ /
} while(0) /* (no trailing ; ) */

C++ 中内存分配的方法:
栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清除的变量的存储区。里面的变量通常是局部变量、函数参数等。

　　堆，就是那些由new分配的内存块，它们的释放编译器不管，而是由程序员自己去控制，一般一个new就要对应一个delete。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。

　　自由存储区，就是那些由malloc等分配的内存块，它和堆是十分相似的，不过它是用free来结束自己的生命的。

　　全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。

　　常量存储区，这是一块比较特殊的存储区，它们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改，而且方法很多.
http://blog.csdn.net/dongfengsun/archive/2007/04/01/1548301.aspx 堆是向着内存地址增加的方向,栈相反.

对于语句char str[]="abc";编译器解释成:char str[4]={'a',b','c','/0'};
"abc/0"存储在栈上.
对于char* ptr="abc"; 这里是常量.一般写成const char* ="abc";
字符串常量类型可以理解为const char[7] :"abcdef";
类string的设计:
class String
{
public:
String(const char *str=NULL);
String(const String &other);
~String(void);
String & operate= (const String &other);
private:
char *m_data;
};

构造函数初始化表使用规则:
1.如果类存在继承关系,派生类必须在其初始化表里调用嗯.
2.类的const常量只能在初始化表中初始化.