C、C++、C#面试总结

1.不可以用static与const同时修饰一个类成员函数或类成员。实现const的成员函数的时候为了确保该函数不能修改类的实例的状态，会在函数中添加一个隐式的参数const this*，但是static修饰的成员函数无this指针。

2.

class A

{

private:

        int m_value;

public:

        A(int value)

        {

                m_value = value;

        }

        void Print1()

        {

                printf("hello world");

        }

        void Print2()

        {

                printf("%d", m_value);

        }

};

int _tmain(int argc, _TCHAR* argv[])

{

        A* pA = NULL;

        pA->Print1();

        pA->Print2();

        return 0;

}

答案是Print1调用正常，打印出hello world，但运行至Print2时，程序崩溃。调用Print1时，并不需要pA的地址，因为Print1的函数地址是固定的。编译器会给Print1传入一个this指针，该指针为NULL，但在Print1中该this指针并没有用到。只要程序运行时没有访问不该访问的内存就不会出错，因此运行正常。在运行print2时，需要this指针才能得到m_value的值。由于此时this指针为NULL，因此程序崩溃了。

3.调用静态成员函数不要实例。但调用虚函数需要从一个实例中指向虚函数表的指针以得到函数的地址，因此调用虚函数需要一个实例。两者相互矛盾。

4.

struct Point3D

{

        int x;

        int y;

        int z;

};

int _tmain(int argc, _TCHAR* argv[])

{

        Point3D* pPoint = NULL;

        int offset = (int)(&(pPoint)->z);

        printf("%d", offset);

        return 0;

}

答案：输出8。由于在pPoint->z的前面加上了取地址符号，运行到此时的时候，会在pPoint的指针地址上加z在类型Point3D中的偏移量8。由于pPoint的地址是0，因此最终offset的值是8。&(pPoint->z)的语意是求pPoint中变量z的地址（pPoint的地址0加z的偏移量8），并不需要访问pPoint指向的内存。只要不访问非法的内存，程序就不会出错。

5.由于在.NET中，String有一个非常特殊的性质：String的实例的状态不能被改变。如果String的成员函数会修改实例的状态，将会返回一个新的String实例。改动只会出现在返回值中，而不会修改原来的实例。

6.在C++中，如果没有标明函数或者变量是的访问权限级别，在struct中，是public的；而在class中，是private的。

   在C#中，如果没有标明函数或者变量的访问权限级别，struct和class中都是private的。struct和class的区别是：struct定义值类型，其实例在栈上分配内存；class定义引用类型，其实例在堆上分配内存。

7.仅在C#中存在静态构造函数，且静态成员变量可以在类中初始化。当类中存在静态构造函数与静态变量时，先执行静态变量的初始化，然后在在执行静态构造函数，然后在执行普通成员变量的初始化，最后在执行构造函数。

8.#include <iostream>

class A

{

private:

        int n1;

        int n2;

public:

        A(): n2(0), n1(n2 + 2)

        {  }

        void Print()

        {

                std::cout << "n1: " << n1 << ", n2: " << n2 << std::endl;

        }

};

 

int _tmain(int argc, _TCHAR* argv[])

{

        A a;

        a.Print();

        return 0;

}

答案：输出n1是一个随机的数字，n2为0。在C++中，成员变量的初始化顺序与变量在类型中的申明顺序相同，而与它们在构造函数的初始化列表中的顺序无关。

9.#include <iostream>

class A

{

private:

        int value;

public:

        A(int n)

        {

      value = n;

        }

        A(A other)

        {

                value = other.value;

        }

        void Print()

        {

                std::cout << value << std::endl;

        }

};

int _tmain(int argc, _TCHAR* argv[])

{

        A a = 10;

        A b = a;

        b.Print();

        return 0;

}

答案：编译错误。在复制构造函数中传入的参数是A的一个实例。由于是传值，把形参拷贝到实参会调用复制构造函数。因此如果允许复制构造函数传值，那么会形成永无休止的递归并造成栈溢出。

10.

#include <iostream>

class A

{

public:

        A()

        {

                std::cout << "A is created." << std::endl;

        }

       ~A()

        {

                std::cout << "A is deleted." << std::endl;

        }

};

class B : public A

{

public:

        B()

        {

                std::cout << "B is created." << std::endl;

        }

 

        ~B()

        {

                std::cout << "B is deleted." << std::endl;

        }

}

int _tmain(int argc, _TCHAR* argv[])

{

        A* pA = new B();

        delete pA;

 

        return 0;

}

答案：输出三行，分别是：A is created. B is created. A is deleted。用new创建B时，回调用B的构造函数。在调用B的构造函数的时候，会先调用A的构造函数。因此先输出A is created. B is created.

接下来运行delete语句时，会调用析构函数。由于pA被声明成类型A的指针，同时基类A的析构函数没有标上virtual，因此只有A的析构函数被调用到，而不会调用B的析构函数。

若基类的析构函数声明为virtual虚函数，则先调用子类的析构函数然后调用父类的析构函数。

11.

class A

{

public:

    virtual void Fun(int number = 10)

    {

        std::cout << "A::Fun with number " << number;

    }

};

class B: public A

{

public:

    virtual void Fun(int number = 20)

    {

        std::cout << "B::Fun with number " << number;

    }

};

int main()

{

    B b;

    A &a = b;

    a.Fun();

}

答案：输出B::Fun with number 10。由于a是一个指向B实例的引用，因此在运行的时候会调用B::Fun。但缺省参数是在编译期决定的。在编译的时候，编译器只知道a是一个类型a的引用，具体指向什么类型在编译期是不能确定的，因此会按照A::Fun的声明把缺省参数number设为10。这一题的关键在于理解确定缺省参数的值是在编译的时候，但确定引用、指针的虚函数调用哪个类型的函数是在运行的时候。

12.常量字符串是一个全局的且唯一的变量，它的生存期为整个程序的生存期。

13.delete会调用对象的析构函数,和new对应free只会释放内存，new调用构造函数。malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。对于非内部数据类型的对象而言，光用maloc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free。因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new，以及一个能完成清理与释放内存工作的运算符delete。注意new/delete不是库函数。

14.int id[sizeof(unsigned long)];这个对吗？为什么？

 答案:正确 这个 sizeof是编译时运算符，编译时就确定了  ,可以看成和机器有关的常量。