只要基类在定义成员函数时加上了virtual关键字，在子类实现时覆盖了该函数，不管有没有加上virtual关键字，都不影响多态的实现。

隐藏的两种情况：
1.子类的函数与基类的函数同名，但参数不同，不管有没有virtual关键字，基类的函数将被隐藏
2.子类的函数与基类的函数同名且参数相同，但基类函数没有virtual关键字，基类的函数将被隐藏

将字符串逆序输出：
//=========================
#include
#include
//-------------------------
void main(){
     char *a;
     a=(char *)malloc(1024);
     cin>>a;
     cout<}
//=========================

const符号常量：
(1)const char *p
(2)char * const P
(3)const char * const p

如果const在*左边，则const用来修饰指针所指向的变量，即指针指向常量
如果const在*右边，则const用来修饰指针本身，即指针本身是常量

int n;
if (n == 10) // 第一种判断方式
if (10 == n) // 第二种判断方式

第二种判断好，如果少了个=号，编译时就会报错，减少了出错的可能行，可以检测出是否少了=

下面的代码有什么问题:
void DoSomeThing(...)
{
 char* p;
 ...
 p = malloc(1024);     // 分配1K的空间
 if (NULL == p)
    return;
 ...
 p = realloc(p, 2048); // 空间不够，重新分配到2K
 if (NULL == p)
    return;
 ...
}

p = malloc(1024); <====> p = (char *)malloc(1024);
否则重新分配空间时，没有释放先前P的空间，造成内存泄露。

指针类型一律是4个字节，这是毫无疑问的。不论指向的是什么类型。

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；

在不用第三方参数的情况下，交换两个参数的值
#include
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);
}

进程间的通信方式有：共享内存，管道，Socket，消息队列，DDE(动态数据交换)等

struct A
{
unsigned short t:4;
unsigned short k:4;
unsigned short i:8;
unsigned long m;
};
unsigned short 一般占2个字节，unsigned long一般占4个字节，结构体A以4字节对齐，A中成员t、k、i共占4+4+8=16位，由于要内存对齐，实际那三个成员共占32位即4字节，成员m占4字节，因此sizeof(A)=8

位结构定义的一般形式为:
struct 位结构名{
       数据类型 变量名: 整型常数;
       数据类型 变量名: 整型常数;
       } 位结构变量;
其中: 数据类型必须是int(unsigned或signed)。 整型常数必须是非负的整数, 范围是0~15, 表示二进制位的个数, 即表示有多少位。

static变量：在程序运行期内一直有效，如果定义在函数外，则在编译单元内可见，如果在函数内，在定义的块内可见

static函数：在编译单元内可见