20141027

1、volatile关键字

http://www.cnblogs.com/chio/archive/2007/11/24/970632.html

2、所有函数都是inline可以吗？

“全部”函数都inline，意味着最终的结果是实际上只有一个函数。
于是再也没有函数的进入和退出，栈上的一个变量即使用完了，你也无法释放它占用的内存，哪怕你只用了一次。
如果Windows是这样做的，偶不知道1000G的内存够不够。。。。。

3、C函数如何调用C++的函数

     A.cpp中extern “C”int f_A(){}

     B.c中extern int f_A(){}

 

4、面试宝典p110面试题5

#include<iostream>
using namespace std;
class B
{
private:
    int data;
public:
    B(){cout<<"default constructor!e\n";};
    B(int i):data(i)
    {
        cout<<"constructed by parameter "<<data<<endl;
    }
    B(const B &b)
    {
    data=b.data;
    cout<<"拷贝构造函数\n";
    }
    B & operator=(const B &b)
    {
        data=b.data;
        cout<<"赋值构造函数\n";
        return *this;
    }
    ~B()
    {
        cout<<"destructed"<<endl;
    }
};
B play(B b){return b;}
int main()
{
    B tmp = play(5);//5通过隐式类型转换调用了B::B(int i)，将5转换为B类型.这里的等号调用的是拷贝构造函数；
    return 0;
}

5、面试宝典p124面2

#include <iostream>   
using namespace std;   
class A{  
public:  
void virtual f() 
{ cout<< "A"<<endl;}    
void virtual f1() 
{ cout<< "A1"<<endl;}  
}; 
class B : public A {     
public:  
    void virtual f() 
        { cout << "B"<<endl;}    
}; 

int main()
{ 
    int a=1;
    A* pa=new A(); 
    pa->f();        //   输出为A 
    B* pb=(B*)pa;  //转化pa为cdB类型并新建一个指针pb，将pa复制到pb，pb也指向pa 的                     f函数 
    pb->f();        //  输出为A 
    delete pa,pb;    //  删除了pa，pb的所指向的地址，但pa，pb指针并没有删除，悬浮指针 
    pa=new B();     //  pa指针的类型是A，现在重新给pa指向新地址，所指向的位置是B类的 
    pa->f();        //  所以产生一个覆盖 ，输出B pb=(B*)pa;     //  转化pa为B类指针给pb赋值，pa所指向的f函数是B类的f函数，所以pb也指向B类的f函数

   pb=(B*)pa;
    pb->f();        // 输出B   

}

总结：有虚函数和没有虚函数下的函数调用问题

1、有虚函数：根据指针最终指向的对象的类型（答案是：AABB）

如pb指向的是B类型的指针

pa=new B();     //  pa指针的类型是A，现在重新给pa指向新地址，所指向的位置是B类的 
pa->f();        //  所以产生一个覆盖 ，输出B pb=(B*)pa;     //  转化pa为B类指针给pb赋值，pa所指向的f函数是B类的f函数，所以pb也指向B类的f函数

pb=(B*)pa;
 pb->f();        // 输出B

2、没有虚函数： 根据指针的类型来调用对应函函数：答案是ABAB 

#include <iostream>   
using namespace std;   
class A{  
public:  
void  f() 
{ cout<< "A"<<endl;}    
}; 
class B : public A {     
public: 
    void f() 
        { cout << "B"<<endl;}    
}; 

int main()
{ 
    A* pa=new A(); 
    //B* pb=new B();
    pa->f();        //   输出为A 
    B* pb=(B*)pa;  //转化pa为B类型并新建一个指针pb，将pa复制到pb，pb也指向pa 的                     f函数 
    pb->f();        //  输出为A 
    delete pa,pb;    //  删除了pa，pb的所指向的地址，但pa，pb指针并没有删除，悬浮指针 
    pa=new B();     //  pa指针的类型是A，现在重新给pa指向新地址，所指向的位置是B类的 
    pa->f();        //  所以产生一个覆盖 ，输出B pb=(B*)pa;     //  转化pa为B类指针给pb赋值，pa所指向的f函数是B类的f函数，所以pb也指向B类的f函数 
    pb=(B*)pa;
    pb->f();        // 输出B   

}

6、面试宝典P123

#include<iostream>
using namespace std;

class A
{
protected:
    int m_data;
public:
    A(int data=0)
        {m_data=data;}
    int GetData()
        {return doGetData();}
    virtual int doGetData()
        {return m_data;    }
};
class B: public A
{
protected:
    int m_data;
public:
    B(int data=1)
        {m_data=data;}
    int doGetData()
    {return m_data;}
};

class C: public B
{
protected:
    int m_data;
public:
    C(int data=2)
        {m_data=data;}
};

int main()
{
    A a;
    B b;
    C c(10);
    cout<<c.GetData()<<endl;
    cout<<c.A::GetData()<<endl;
    cout<<c.B::GetData()<<endl;
    cout<<c.C::GetData()<<endl;
    cout<<c.doGetData()<<endl;
    cout<<c.A::doGetData()<<endl;
    cout<<c.B::doGetData()<<endl;
    cout<<c.C::doGetData()<<endl;
    system("PAUSE");
    return 1;
}

7、虚继承与普通继承对比

#include<iostream>
#include<memory.h>
using namespace std;
class A
{
    char k[3];
public:
    virtual void aa(){}

};

class B:public virtual A
{
    char j[3];
public:
    virtual void bb(){cout<<1;}
};

class C:  public virtual  B
{
    char i[3];
public:
    virtual void cc(){}
};

int main()
{
    A a;
    B b;
    C c;
    cout<<"sizeof(A):"<<sizeof(A)<<endl;
    cout<<"sizeof(B):"<<sizeof(B)<<endl;
    cout<<"sizeof(C):"<<sizeof(C)<<endl;
    return 0;
}

 

#include<iostream>
#include<memory.h>
using namespace std;
class A
{
    char k[3];
public:
    virtual void aa(){}

};

class B:public  A
{
    char j[3];
public:
    virtual void bb(){cout<<1;}
};

class C:  public B
{
    char i[3];
public:
    virtual void cc(){}
};

int main()
{
    A a;
    B b;
    C c;
    cout<<"sizeof(A):"<<sizeof(A)<<endl;
    cout<<"sizeof(B):"<<sizeof(B)<<endl;
    cout<<"sizeof(C):"<<sizeof(C)<<endl;
    return 0;
}

8、显示调用父类的初始化函数

#include<iostream>
using namespace std;
class A
{
public:
    A(int x):i(x){}  //没有定义没有参数的构造函数，要小心！！！！！！！
public:
    int i;
};

class B:public A
{
public:
    B(int x,int y):i(y),A(x){} //一定要显示的调用父类的构造函数！！！
    void print()
    {
        int total=i+A::i;
        cout<<total;
    }
private:
    int i;
};

int main()
{
    B b(4,3);
    b.print();
}