27、不要忘记给静态成员变量赋初值。不像java,变量可以直接在类中声明处赋值，c++中的变量赋值不能在类中声明处赋初值
#include<iostream>
class Parent
{
public:
Parent（）{}
Parent（int value）{this->value=value;}
~Parent（）{}
Parent（Parent&）{}
int value;
static int num;
};
int Parent::num=0;
28、要将私有成员或函数暴露给另一个类，必须将其声明为友元类，友元关系不能传递，不能继承，也不可交换，将Class1声明为Class2的友元并不能让Class2成为Class1的友元。有时候不想将友元访问权限赋予整个类，为此，可以将成员函数而不是整个类声明为友元。
友元函数：友元函数的声明可以放在类的私有部分，也可以放在公有部分，它们是没有区别的，都说明是该类的一个友元函数
#include<iostream>
class Parent
{
public:
Parent（）{}
Parent（int value）{this->value=value;}
~Parent（）{}
Parent（Parent&）{}
friend void getValue（Parent& p）；
private:
int value;
};
void getValue（Parent& p）//不需要加Parent::,因为友元函数不属于该类
{
std::cout《 p.value《std::endl;
}
void main（）
{
Parent p（2）；
getValue（p）；//友元函数不属于类，直接调用，无需对象表示
}
友元类：一个类能够作另一个类的友元。当一个类作为另一个类的友元时，这就意味着这个类的任何成员函数都是另一个类的友元函数。
以下语句说明类B是类A的友元类：
#include<iostream>
class A
{
public:
A（）{}
A（int value）{this->value=value;}
~A（）{}
A（A&）{}
friend class B;
private:
int value;
};
class B
{
public:
B（）{}
~B（）{}
B（B&）{}
void getValue（A& a）
{
std::cout《a.value《std::endl;
}
};
void main（）
{
A a（2）；
B b;
b.getValue（a）；
}
经过以上说明后，类B的所有成员函数都是类A的友元函数，能存取类A的私有成员和保护成员。
29、函数指针
可以声明指向函数的指针，其实函数名就是指向函数的常量指针，就像数组名是指向数组第一个元素的常量指针一样。
#include<iostream>
void add（int a, int b）
{
std::cout《 a+b 《std::endl;
}
void subtract（int a, int b）
{
std::cout《 a-b 《std::endl;
}
void main（）
{
void （*pFunc） （int, int）；
pFunc=add;//给函数指针赋值，使其指向add函数
pFunc（2,1）；//赋值之后调用
pFunc=subtract;
pFunc（2,1）；
}
30、将函数指针作为参数传递
#include<iostream>
void add（int a, int b）
{
std::cout《 a+b 《std::endl;
}
void subtract（int a, int b）
{
std::cout《 a-b 《std::endl;
}
void printValue（void （*func）（int, int） , int a, int b）//函数指针作为参数
{
func（a,b）；
}
void main（）
{
void （*pFunc） （int, int）；//函数指针声明
pFunc=add;//函数指针赋值
printValue（pFunc,2,1）；//函数指针作为参数传递
pFunc=subtract;
printValue（pFunc,2,1）；
}
31、空指针常量：使用指针时候一定要给它赋值，未初始化的指针可能指向内存的任何位置，这就做野指针。为了避免这种威胁，创建时候应该将空值（0或者NULL）赋给指针。但这会在函数重载的时候造成一定麻烦，比如一个接收字符型指针或整数作为参数：
void func（char *）；
void func（int）；
若调用时候传递一个空指针，则调用void func（int），这不符合设计人员本意。
32、函数模板
#include<iostream>
template<class T>
void swap（T& a, T& b）
{
T tmp;
tmp=a;
a=b;
b=tmp;
}
void main（）
{
int a=1,b=2;
swap（a,b）；
std::cout《"a="《a《", b="《b《std::endl;
}
33、类模板
#include<iostream>
template<class T>
class A
{
public:
A（T value）
{
this->value=value;
}
T getValue（）
{
return value;
}
private:
T value;
};
void main（）
{
A<int> a（2）；
std::cout《a.getValue（）《std::endl;
}