1.定义结构体时，编译程序并未给它分配内存空间。

一个结构体类型可以由多个成员（域）的成分组成。


重载运算符保持原运算符的优先级和结合性不变、


2.以上代码编译时需要声明标准？

class foo {
foo(){};
};
Class boo:publicfoo() {
boo() : foo() {};
};

分析：foo()是私有函数，在boo中不能调用。


委托构造函数就是在一个构造函数中调用了另外一个构造函数。

C++真正正式公布的标准就三个：
C++98、C++03、C++11。
其中C++98是第一个正式C++标准，C++03是在C++98上面进行了小幅度的修订，C++11则是一次全面的大进化（C++0x是C++11标准成为正式标准之前的草案临时名字）


3. 

#include<iostream>
#include<string.h>
using namespacestd;
int main() {
   char *p1="hello";
   char *p2="world";
   char *p3="a piece of cake";
   char *str[]={p1,p2,p3};
   cout<<sizeof(*str[0])<<""<<*(str[0]+1)<<endl;
   cout<<sizeof(*&str[0])<<""<<*(&str[0]+1)<<endl;
   cout<<sizeof(*str)<<""<<*(str+1)<<endl;
   cout<<sizeof(*&str)<<""<<*(&str+1)<<endl;
}


4. 面向对象有三种特性：封装、继承、多态
其中多态性有两种，一种是依靠函数重载实现的静态绑定，一种是依靠虚函数实现的动态绑定。

动态绑定是面向对象程序设计语言的一种机制。这种机制实现了方法的定义与具体的对象无关，而对方法的调用则可以关联于具体的对象。


5.友元函数是一种能够访问类中的私有成员的非成员函数，一个类的友元函数对类成员的访问能力等同于类的成员函数，即能访问类的所有成员。


6. C语言中 printf("%d\n",sizeof(void));输出结果为1


解析：这取决于编译程序。因为不能定义void类型的变量，所以它也就不占空间，理论上应该sizeof(void)是0，在VC中的确也是0，而gcc把它定为1。 如果是C++的话， sizeof(void)根本是编译通不过的。 随便说一下，C++中一个空的结构或类: struct EMPTY{}; sizeof( struct EMPTY ); 也是返回1。 但如果是C语言，gcc中就会返回0。而VC中根本不允许空的结构。



7.两个线程并发执行以下代码，假设a是全局变量，初始值为1，那么以下输出中(ABCD)是可能的？

void foo() {
   ++a;
printf(“%d”,a);
}

A 3_2_    B 2_3_    C3_3_    D 2_2_


8.函数参数传递机制问题在本质上是调用函数（过程）和被调用函数（过程）在调用发生时进行通信的方法问题。基本的参数传递机制有两种：值传递和引用传递。以下讨论称调用其他函数的函数为主调函数，被调用的函数为被调函数。

　　值传递（passl-by-value）过程中，被调函数的形式参数作为被调函数的局部变量处理，即在堆栈中开辟了内存空间以存放由主调函数放进来的实参的值，从而成为了实参的一个副本。值传递的特点是被调函数对形式参数的任何操作都是作为局部变量进行，不会影响主调函数的实参变量的值。

引用传递(pass-by-reference)过程中，被调函数的形式参数虽然也作为局部变量在堆栈中开辟了内存空间，但是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址，即通过堆栈中存放的地址访问主调函数中的实参变量。正因为如此，被调函数对形参做的任何操作都影响了主调函数中的 实参变量。


补充：c++中传递指针和引用都可以，但是传引用更加安全。指针和应用都是地址，所以C++语言的参数传递机制包括传值和传地址两种


9.字符串数组，是指数组中的每个元素都是一个存放字符串的一维数组。

10.

#include<iostream>
#include<string.h>
using namespace std;
class A{
   public:
   A() {
     cout<<"a"<<endl;
   }
   ~A() {
     cout<<"dea";
   }
};
 
class B {
   public:
     B(){
        cout<<"c"<<endl;
     }
     ~B(){
        cout<<"deb"<<endl;
     }
};
class C:public A,public B {
   public:
     C(){
        cout<<"c"<<endl;
     }
     ~C(){
        cout<<"dec"<<endl;
     }
};
int main() {
   A*a=new C();
   deletea;
   return0;
}

 如果按题中所说 加入virtual，那么输出的顺序是ABC deCdeB deA。由于析构函数是虚函数，动态调用，那么会调用C的析构函数，由于C继承与A和B，所以先调用A B的析构，最后调用自己的。

如果A的析构函数不是虚函数，那么只会调用A的析构函数。


11.

#include<iostream>
#include<string.h>
using namespace std;
struct s1{
   charch,*ptr;
   union{
     shorta,b;
     unsignedint c:2,d:1;
   };
   structs1 *next;
};
int main() {
   cout<<sizeof(s1);
   return0;
}

分析：

1）.char ch,占一个字节，由于4字节对其，所以其占4个字节；

2）.*ptr指针占4个字节

3）.重点研究union

1）修改结构体为：

struct s1 {
union {
short a, b;
};
};

运行发现 此时 结构体为占用2个字节

2） 

struct s1 {
union {
unsigned int c:32,d:1;
};
};

运行发现此时结构体占4个字节

综上分析：实际为只有short a ,b其大小为2个字节，占用的是short类型的大小

当引入unsigned int此时联合体的大小为4个字节，不管定义了几个这样类型的变量，只要它占用的位数为1-32，会使得它的贡献的字节数为4个字节，即最大变量类型的大小

综上可得题目中的union的大小为4个字节

结构体指针占用4个字节

于是该结构体的字节数为16。


12.关于new delete与malloc free的联系与区别：

都是在堆上进行动态的内存操作；

用malloc函数需要指定内存分配的字节数并且不能初始化对象，new会自动调用对象的构造函数；

delete会调用对象destructor，而free不会调用对象的destructor；


13.（1）传递引用给函数与传递指针的效果是一样的。这时，被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用，所以在被调函数中对形参变量的操作就是对其相应的目标对象（在主调函数中）的操作。

  （2）使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作；而使用一般变量传递函数的参数，当发生函数调用时，需要给形参分配存储单元，形参变量是实参变量的副本；如果传递的是对象，还将调用拷贝构造函数。因此，当参数传递的数据较大时，用引用比用一般变量传递参数的效率和所占空间都好。

  （3）使用指针作为函数的参数虽然也能达到与使用引用的效果，但是，在被调函数中同样要给形参分配存储单元，且需要重复使用"*指针变量名"的形式进行运算，这很容易产生错误且程序的阅读性较差；另一方面，在主调函数的调用点处，必须用变量的地址作为实参。而引用更容易使用，更清晰。