若1秒内对同一个用户产生大量的推送请求，会造成该用户接收正常速度的消息时前总是收到之前已经推送过的消息，这所谓重复消息。 经过测试发现，即便provider产生大量推送请求，apns推送给iPhone的时间间隔大约为3s。那么应该在provider端设计一种算法，使得 对同一个用户大量并发的请求以3秒间隔地推送。实践结果，果然。

C_Class B
{            //B继承了A
 C_Class B *B_this;     //顺序很重要
 void (*Foo)(C_Class B *Bthis);   //虚函数
 int a;
 int b;
 
 int c;
};
//////////////////////////////////////////////////////////////////////////
//成员函数
//////////////////////////////////////////////////////////////////////////
void A_Foo(C_Class A *Athis)
{
 printf("It is A.a=%d\ ",Athis->a);
}

void B_Foo(C_Class B *Bthis)
{
 printf("It is B.c=%d\ ",Bthis->c);
}

//////////////////////////////////////////////////////////////////////////
//构造函数
//////////////////////////////////////////////////////////////////////////
void A_Creat(struct A* p)
{
 p->Foo=A_Foo;
 p->a=1;
 p->b=2;
 p->A_this=p;
}

void B_Creat(struct B* p)
{
 p->Foo=B_Foo;
 p->a=11;
 p->b=12;     
 p->c=13;
 p->B_this=p;
}
//////////////////////////////////////////////////////////////////////////
//函数入口
//////////////////////////////////////////////////////////////////////////
int main(int argc, char* argv[])
{
 C_Class A *ma,a;
 C_Class B *mb,b;
 
 A_Creat(&a);//实例化
 B_Creat(&b);
   
 mb=&b;
 ma=&a;
   
 ma=(C_Class A*)mb;//引入多态指针
 printf("%d\ ",ma->a);//可惜的就是 函数变量没有private
 ma->Foo(ma);//多态
 a.Foo(&a);//不是多态了
 return 0;
}

① 定义了四个操作符：static_cast，const_cast，dynamic_cast和reinterpret_cast。

② static_cast：可以被用于强制类型转换（例如，non-const对象转换为const对象，int转换为double，等等），它还可以用于很多这样的转换的反向转换（例如，void*指针转换为有类型指针，基类指针转换为派生类指针）。但是它不能将一个const对象转换为一个non-const对象（只有const-cast能做到）。它最接近于C-style的转换。

③const_cast：一般用于强制消除对象的常量性。它是唯一能做到这一点的C++风格的强制类型。

④dynamic_cast：主要用于执行“安全的向下转型”。也就是说，要确定一个对象是否是一个继承体系中的一个特定类型。它是唯一不能用旧风格语法执行的强制类型转换，也是唯一可能有重大运行时代价的强制转换。

2、 C++ 定义了哪些访问控制关键字？分别有什么作用？

简单可以归为以下两种描述：

1）一个类友元（包含友元函数或者友元类的成员函数或者友元类的所有成员函数）可以访问该类的任何成员（包括成员变量及成员方法）。

3、 类的继承方式和区别？

派生类继承方式的影响

类的继承方式有三种：private、protected、public。

1）private属性不能被继承。

2）

4、 在什么情形下调用虚函数不会有多态性？为什么？

由虚函数实现的动态多态性的方法：

1.      在基类用virtual声明成员函数为虚函数。

2.      在派生类中重新定义此函数。

3.      定义一个指向基类对象的指针变量，并使它指向同一类族中需要调用该函数的对象。

4.      通过该指针变量调用此虚函数，此时调用的就是指针变量指向的对象的同名函数。

因此，总结如下：

1、基类函数未使用virtual声明而子类中使用virtual关键字声明时调用虚函数不会有多态性；

2、基类使用virtual而子类未重新实现该虚函数则不会有多态性；

3、  使用子类创建的对象转换成基类类型调用虚函数不会有多态性；

5.      构造函数调用顺序。

class Y {...}
class X : public Y {...}
X one;

构造函数的调用顺序是下面的顺序：

Y(); // 基类的构造函数
X(); // 继承类的构造函数

对于多基类的情况，下面是一个例子：

class X : public Y, public Z
X one;

构造函数以声明的次序调用。

Y(); // 基类构造函数首先被调用
Z();
X();

虚基类的构造函数在任何非虚基类构造函数前调用。如果构造中包括多个虚基类，它们的调用顺序以声明顺序为准。..

如果虚类是由非虚类派生而来，那非虚类的构造函数要先被调用。下面是一个例子：

class X : public Y, virtual public Z
X one;

调用顺序如下：

Z(); // 虚基类初始化
Y(); // 非虚基类
X(); // 继承类

下面是一个复杂的例子：

class base;
class base2;
class level1 : public base2, virtual public base;
class level2 : public base2, virtual public base;
class toplevel : public level1, virtual public level2;
toplevel view;

构造函数调用顺序如下：

base(); // 虚基类仅被构造一次
base2();
level2(); // 虚基类
base2();
level1();
toplevel();

如果类继承中包括多个虚基类的实例，基类只被初始化一次。

1、如果类里面有成员类，成员类的构造函数优先被调用；

2、创建派生类的对象，基类的构造函数函数优先被调用（也优先于派生类里的成员类）；

3、 基类构造函数如果有多个基类则构造函数的调用顺序是某类在类派生表中出现的顺序而不是它们在成员初始化表中的顺序；
4、成员类对象构造函数如果有多个成员类对象则构造函数的调用顺序是对象在类中被声明的顺序而不是它们出现在成员初始化表中的顺序；
5、派生类构造函数
作为一般规则派生类构造函数应该不能直接向一个基类数据成员赋值而是把值传递给适当的基类构造函数否则两个类的实现变成紧耦合的（tightly coupled）将更加难于正确地修改或扩展基类的实现。（基类设计者的责任是提供一组适当的基类构造函数）

6. RTTI是什么，怎么实现的？举个例子。

RTTI即运行时类型识别，通过它程序能够使用基类的指针或引用来检查这些指针或引用所指的对象的实际派生类型。

RTTI提供了一下两个非常有用的操作符：

1、typeid操作符，返回指针和引用所指的实际类型

2、dynamic_cast操作符，将基类类型的指针或引用安全地转换为派生类型的指针或引用。

资源来自网络，感谢原创者
   
   前阵子被问及一个在C中如何调用C++函数的问题，当时简单回答是将函数用extern "C"声明，当被问及如何将类内成员函数声明时，一时语塞，后来网上查了下，网上有一翻译C++之父的文章可以作为解答，遂拿来Mark一下。

将 C++ 函数声明为``extern "C"''（在你的 C++ 代码里做这个声明），然后调用它（在你的 C 或者 C++ 代码里调用）。例如：

// C++ code:

extern "C" void f(int);

void f(int i)

{

     // ...

}

然后，你可以这样使用 f()：

/* C code: */

void f(int);

void cc(int i)

{

    f(i);

   /* ... */

   }

当然，这招只适用于非成员函数。如果你想要在 C 里调用成员函数（包括虚函数），则需要提供一个简单的包装（wrapper）。例如：

// C++ code:

class C

{

  // ...

  virtual double f(int);

};

extern "C" double call_C_f(C* p, int i) // wrapper function

{

  return p->f(i);

}

然后，你就可以这样调用 C::f()：

/* C code: */

double call_C_f(struct C* p, int i);

void ccc(struct C* p, int i)

{

  double d = call_C_f(p,i);

  /* ... */

}

如果你想在 C 里调用重载函数，则必须提供不同名字的包装，这样才能被 C 代码调用。例如：

// C++ code:

void f(int);

void f(double);

extern "C" void f_i(int i) { f(i); }

extern "C" void f_d(double d) { f(d); }

然后，你可以这样使用每个重载的 f()：

/* C code: */

void f_i(int);

void f_d(double);

void cccc(int i,double d)

{

  f_i(i);

  f_d(d);

  /* ... */

}

注意，这些技巧也适用于在 C 里调用 C++ 类库，即使你不能（或者不想）修改 C++ 头文件