选哪个？？为什么？

[suffocater]

*. 32位平台下，以下代码

class Base
{
public:
Base (){};
~ Base (){};
};

class CDemo
{
public:
CDemo() {}
virtual ~CDemo() {}
protected:
static int m_siObjCnt;
Base m_ob;
};
void main()
{
CDemo ob;
cout<<sizeof(ob)<<endl;
}
的输出是:（ ）

A) 4
B) 5
C) 8
D) 12


*. 下面关于C++的说法中，错误的是:（ ）
A) static用来修饰类的成员函数，可以不用实例化通过类名，直接调用该函数
B) const常常用来修饰函数参数、常量对象等，以防止其被改变，所以const变量的值不可能被改变
C) 标准C++中，一个类可以有多个父类
D) STL是C++标准的一部分


*. 下列运算符中不能被重载的是:（ ）
A) &&
B) ！=
C) ：？
D) ++



*. 有两个类的定义如下：
class Base
{
public:
virtual void f( int iParam){
cout << "Base::f(int)" << endl;
};
virtual void f( double dParam){
cout << "Base::f(double)" << endl;
};
virtual void g( int i = 10 ){
cout << i << endl;
};
};

class Derived: public Base
{
public:
void f( complex<double> Param){
cout << "Derived::f(complex)" << endl;
};
void g( int i = 20 ){
cout << "Derived::g() " << i << endl;
};
};
则下面的程序的输出结果为：( )
int main() {
Base b;
Derived d;
Base* pb = new Derived;
b.f(1.0);
d.f(1.0);
pb->f(1.0);
delete pb;
return 0;
}
A) Base::f(double)
Derived::f(complex)
Derived::f(complex)
B) Base::f(double)
Derived::f(complex)
Base::f(double)
C) Base::f(int)
Derived::f(complex)
Base::f(double)
D) Base::f(double)
Base::f(double)
Base::f(double)

*. 类的定义与上题相同，则下面的程序的输出结果为：( )
int main() {
Base b;
Derived d;
Base* pb = new Derived;
b.g();
d.g();
pb->g();
delete pb;
return 0；
}

A) 10
Derived::g() 20
Derived::g() 20
B) 10
10
Derived::g() 20
C) 10
Derived::g() 10
Derived::g() 10
D) 10
Derived::g() 20
Derived::g() 10

[九桔猫]

有些是类的指针之类的内容，详细的可以看下《深度探索C++对象模型》

[mengde007]

帮顶了；

[帅得不敢出门]

*. 下列运算符中不能被重载的是:（ C ）

[lingyin55]

1、c
类的大小+子类个non-static成员变量的大小，这里成员变量是会被字节对齐的。
如果有虚函数，类的大小+4个字节。（用来存放vptr)

2、b
C++提供const关键字，不是为了保证一个变量不被修改，而是为了方便编译程序和维护人员弄清楚一个实体在程序中是否被修改了。如果函数接口中声明参数为const，我们就认为这个参数不会改变，如果没有声明为const，就认为这个参数一定被改变了，而不管函数到底有没有改变这个参数。

3、c
下面这些操作符不能重载
"&&" ,"||" , "," , "." , ".*" , "::" , "?:"

[liliangbao]

1.C
2.B
3.C
4.B
5.A
原因等高手解释~

[nuoshueihe]

第一个选C 8
cout<<sizeof(Base)<<endl;为1；
static int m_siObjCnt; sizeof()为4
Base m_ob; sizeof（）为1，但是在struct /class中要结构体对齐，故占用4个字节
所以为4+4=8了

[jinling4388]

4.B繼承在創建時是先調自己的構造，再調父類構造
5.A 虛函數按實際類型調用，考的是多態

[koulongfei]

作业题些，自己看书去

[suffocater]

问一下7楼，第4题和构造函数有什么关系呀？

问一下9楼，看什么书？

[bbb332]

[Quote=引用 4 楼 lingyin55 的回复:]
1、c
类的大小+子类个non-static成员变量的大小，这里成员变量是会被字节对齐的。
如果有虚函数，类的大小+4个字节。（用来存放vptr)

2、b
C++提供const关键字，不是为了保证一个变量不被修改，而是为了方便编译程序和维护人员弄清楚一个实体在程序中是否被修改了。如果函数接口中声明参数为const，我们就认为这个参数不会改变，如果没有声明为const，就认为这个参数一定被改变了，而不管函数到底有没有改变这个参数。…
[/Quote]
学习了

[hityct1]

1）C. 8
类最小size为1.所以sizeof(Base)为1
CDemo有虚函数，所以要有个指向虚函数表的指针，sizeof(指针)=4
static int m_siObjCnt;不依存于对象而独自存在（实际上就是访问受限的全局变量），所以忽略不计。

最后:size =1 + 4，对齐后为8

[garymao8888]

[Quote=引用 8 楼 se7venhigh 的回复:]
第1题，不太清楚内存分配的细节，学习之
第2题，之所以用const来修饰函数参数，主要是为了让常量（如字符串"string"等）也能传递给函数，并不是要让参数不能改变....
第3题........
第4、5题，继承的老问题了
我觉得第4题应该选A啊....难道我的编译工具有错？而且为什么要用个complex模板呢？
[/Quote]

4题是B，因为pb是基类的指针，只是申请的子类的空间大小，类型并没有转换。

[sanguomi]

[Quote=引用 6 楼 nuoshueihe 的回复:]
第一个选C 8
cout < <sizeof(Base) < <endl;为1；
static int m_siObjCnt; sizeof()为4
Base m_ob; sizeof（）为1，但是在struct /class中要结构体对齐，故占用4个字节
所以为4+4=8了
[/Quote]

和 static int m_siObjCnt; 完全无关,关键是它里有个虚函数,virtual ~CDemo() {}
然后字节对奇 ,结果就是8了

[crst_zh]

1.C 基类是空的，大小为1，子类有虚表，考虑对齐 8
2.B 还是可以变得，volatile关键字
3.A
45 ：BD 主要就是默认参数和多态搅在一起表现的精神分裂症了，默认参数属于静态编译，编译器决定行为，而多态属于动态编译，在执行器根据对象类型决定行为。

[crst_zh]

重点说第5题吧，表现的很异常
Derived::g() 10

pb指向子类对象，调用子类成员函数，所以是Derived::g()

但是参数确实10，是父类的默认参数，这就是因为默认参数是编译期决定的，Base× pb，就决定了的。
参考：effective c++ Item37：
绝不重新定义集成而来的缺省参数值

主要就是默认参数和多态搅在一起表现的精神分裂症了，默认参数属于静态编译，编译器决定行为，而多态属于动态编译，在执行器根据对象类型决定行为。

[hityct1]

2）A static也可修饰变量。至于B，疑问中。
3）C不知为何物
4）B 多态必须是函数名和参数都相同。
5）我觉为A，但vs2008运行结果为D，疑问中？？？

[hityct1]

[Quote=引用 4 楼 lingyin55 的回复:]
下面这些操作符不能重载
"&&" ,"||" , "," , "." , ".*" , "::" , "?:"
[/Quote]

"&&" ,"||" , "," 可以重载（可惜没用过）。

[crst_zh]

这个帖子第5题很值得研究

[wangyangkobe]

很好

[hityct1]

[Quote=引用 18 楼 crst_zh 的回复:]
重点说第5题吧，表现的很异常
Derived::g() 10

pb指向子类对象，调用子类成员函数，所以是Derived::g()

但是参数确实10，是父类的默认参数，这就是因为默认参数是编译期决定的，Base× pb，就决定了的。
参考：effective c++ Item37：
绝不重新定义集成而来的缺省参数值

主要就是默认参数和多态搅在一起表现的精神分裂症了，默认参数属于静态编译，编译器决定行为，而多态属于动态编译，在执行器根据对象类型决…
[/Quote]
原来如此！！！