编程语言基础

2.1 定义一个空的类型，里面没有任何成员变量和成员函数。对该类型求sizeof，得到的结果是多少？

答：1.

 

#include <stdio.h>

class A{

 

};

int main(){

A a;

printf("%d",sizeof a );

return 0;

}

 

结果：1

 

#include <stdio.h>

class A{

};

int main(){

// A a;

printf("%d",sizeof(A) );

return 0;

}

 

结果：1

 

 

如果在该类型中添加一个构造函数和析构函数，再对该类型求sizeof;得到的结果是多少？

 

#include <stdio.h>

class A{

A();

~A();

};

int main(){

// A a;

printf("%d",sizeof(A) );

return 0;

}

 

答案：1

 

调用构造函数和析构函数只需要知道函数的地址即可，而这些函数的地址只与类型相关，而与类型的实例无关，而与类型的实例无关，编译器也不会因为这两个函数而在实例内添加任何额外的信息。

 

那如果把析构函数标记为虚函数呢？

 

#include <stdio.h>

class A{

A();

virtual ~A();

};

int main(){

// A a;

printf("%d",sizeof(A) );

return 0;

}

 

答案：4

 

C++编译器一旦发现一个类型中有虚拟函数，就会为该类型生成虚函数表，并在该类型的每一个实例中添加一个指向虚函数表的指针。一个指针占4个字节的空间，因此求sizeof的带4；如果是64位的机器，一个指针占8个字节，因此求sizeof则得到8.

 

 

 

2.2 分析以下程序的编译结果：A 编译错误 B 编译成功，运行时程序崩溃  C 编译运行正常。

#include <iostream>

using namespace std;

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 main(int argc,char *argv[]){

A a = 10;

A b = a;

b.Print();

return 0;

}

 

答案：error: invalid constructor; you probably meant 'A (const A&)'

 

 

正确程序

 

#include <iostream>

using namespace std;

class A{

private:

int value;

public:

A(int n){ value = n; }

A(const A &other){ value = other.value; }

void Print(){ std::cout << value << std::endl; }

};

int main(int argc,char *argv[]){

A a = 10;

A b = a;

b.Print();

return 0;

}

 

 

2-3 （赋值运算符函数）如下为类型CMyString的声明，请为该类型添加赋值运算符函数。

 

class CMyString{

        public:

                CMyString(char *pData = NULL);

                CMyString(const CMyString &str);

                ~CMyString(void);

        private:

                char *m_pData;

}

 

解析：

（1）是否把返回值的类型声明为该类型的引用，并在函数结束前返回实例的自身的引用（即*this）。只有返回一个引用，才可以允许连续赋值。否则如果函数的返回值是void，应用该赋值运算符将不能做连续赋值。假设有3个CMyString的对象：str1、str2和str3，在程序中语句str1 = str2 = str3 将不能通过编译。

（2）是否把传入的参数的类型声明为常量引用。如果传入的参数不是引用而是实

例，那么从形参到实参会调用一次复制的构造函数。把参数声明为引用可以避免这样的 无谓消耗，能提高代码的效率。同时，我们的赋值运算符函数内不会改变传入的实例状 态，因此应该为传入的引用参数加上const关键字。

（3）是否释放实例自身已有的内存。如果我们忘记在分配新内存之前释放自身已有的空间，程序将出现内存泄露。

（4）是否判断传入的参数和当前的实例（*this）是不是同一实例。如果是同一个，则不进行赋值操作，直接返回。如果事先不判断就进行赋值，那么在释放实例自身的内存的时候就会导致严重的问题：当*this和传入的参数是同一个实例时，那么一旦释放了自身的内存，传入的参数的内存也同时被释放了，因此再也找不到需要赋值的内容了。

#include <iostream>

#include <cstring>

using namespace std;

 

class CMyString{

public:

CMyString(char * pData = NULL){ this->m_pData = pData;};

//CMyString(const CMyString &str);

//~CMyString(void);

CMyString& operator =(const CMyString &str){

if(this == &str)

return *this;

delete []m_pData;

m_pData = NULL;

m_pData = new char[strlen(str.m_pData) + 1];

strcpy(m_pData, str.m_pData);

 

return *this;

}

void print(){

cout << m_pData << endl;

}

private:

char *m_pData;

};

 

int main(){

 

CMyString str1("hello world!");

    CMyString str2, str3;

str2 = str3 = str1;

str1.print();

str2.print();

str3.print();

return 0;

}

结果： hello world!

hello world!

hello world!

 

 

解法2（高级，异常安全性）：

CMyString& CMyString::operator= (const CMyString &str){

 

if(this != &str){

CMyString strTemp(str);

 

char* pTemp = strTemp.m_pData;

strTemp.m_pData = m_pData;

m_pData = ptemp;

}

return *this;

}

 

在这个函数中，我们先创建一个临时实例strTemp，接着把strTemp.m_pData和实例自身的m_pData做交换。由于strTemp是一个局部变量，但程序运行到if的外面时也就出了该变量的作用域，就会自动调用strTemp的析构函数，把strTemp.m_pData所指向的内存释放掉。由于strTemp.m_pData指向的内存就是实例之前m_pData的内存，这就相当于自动调用析构函数释放实例的内存。

在新的代码中，我们在CMyString的构造函数里用new分配内存。如果由于内存不足抛出诸如bad_alloc等异常，我们还没有修改原来实例的状态，因此实例的状态还是有效的，这就保证了异常安全性。

 

测试用例：

（1）把一个CMyString的实例赋值给另一个实例。

（2）把一个CMyString的实例赋值给自己。

（3）连续赋值。

 

考点：

（1）考察对C++的基础语法的理解，如运算符函数、常量引用等。

（2）考查对内存泄露的理解。

（3）对高级C++程序员，面试官还将考查应聘者对代码异常安全性的理解。

 

 

 

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