2281人阅读
【笔试、面试2012备战】（29）
重拾C++经典笔试30题（1-10）
1.&&&&&/*----------------统计10进制转化为2进制1的个数-----------------
int total2Cnts(int x)
int count = 0;
x = x&(x-1);
int main()
int num = 9999;
for( int i = 0; i & 100; i++)
cout && i &&&中1的个数为:& &&total2Cnts(i) &&
------------------------------------------------------------*/
2.&&&&&/*---------------浮点转换---------------------------------
int main()
float a = 1.0f;
cout && (int)a &&
cout && &a &&
cout && (int&)a &&
cout && boolalpha && ((int)a == (int&)a ) && //false
float b = 0.0f;
cout && (int)b &&
cout && &b &&
cout && (int&)b &&
cout && boolalpha && ((int)b == (int&)b ) && //true
---------------------------------------------------------*/
问题1：(int&)a中(int&)的确切含义是什么？(int&)a 等价于*(int*)&a;
问题2：浮点数的内存和整数的存储方式不同；int(&a) 相当于该浮点地址开始的sizeof(int)个字节当成int型的数据输出，这取决于float型数据在内存中的存储方式(这是关键)，而不是经过int(&a)显示转换的结果1。
3.&&&&&/*---------------位运算--------------------------------
#include&iostream&
char a = 'a';
char b = ~a;
cout&&sizeof(a)&&
cout && typeid(a).name() &&
cout&&sizeof(b)&&
cout && typeid(a).name() &&
cout&&sizeof(~a)&&
cout && typeid(~a).name() &&
cout&&sizeof(a&b)&&
cout && typeid(a&b).name()&&
---------------------------------------------------------*/
4.&&&&&/*------------------输入输出流与printf在多线程中的区别和影响--------------
unsignedint _stdcall ThreadProc1(PVOID lpParameter)
printf(&subThreadis running! g_cnt = %d\n&,g_cnt);
cout && &subThread is running!g_cnt = & && g_cnt && //此处和printf打印在多线程操作中的区别？
int main()
g_cnt = 0;
const int nThreadNum = 5;
HANDLE hThread1[nThreadNum];
//Caution...!
for( int i=0; i & nThreadN i++)
hThread1[i]=(HANDLE)_beginthreadex(NULL,0,ThreadProc1,NULL,0,NULL);
WaitForMultipleObjects(nThreadNum,hThread1,true,INFINITE);
_endthreadex(0);
-------------------------------------------------------------------*/
问题：写多线程上述操作最基本实例的时候，发现了用printf能正常逐行打印输出，而用cout&&输出流则出现并行输出的现象。
原因：一个是C库(printf)，一个是C++库(cout)。两者的缓冲方式有所不同，而且使用相互独立的缓冲区。printf是传统的行缓冲，cout则是基于字符的缓冲。注意同一个程序中不要混合两种输出方式，有可能导致输出混乱。
5.&&&&&位运算
X&Y指取出X与Y的相同位；
X异或Y取出X与Y的不同位；
X右移1等价于X除以2。
X左移1等价于X乘以2.
//取出a,b中较大者。
intmaxFun(int a, int b)
return (((a+b) + abs(a-b))/2);
上式简化为：若a&b,((a+b)+(a-b))/2= 若a&b,((a+b)-(a-b))/2=b.显然才有了绝对值一说。
//a,b交换操作
voidexchange(int& a, int& b)
6.&&&&&求解结构体偏移量的方法？
#define FIND(STRUC, e)(size_t)&(((STRUC*)0)-&e)
structstudent
char b[20];
cout && FIND(student,a) && //0
cout && FIND(student,b) && //4
cout && FIND(student,c) && //24
cout && sizeof(student) && //32
#define FIND(STRUC, e)(size_t)&(((STRUC*)0)-&e)
第一步，((TRUC*)0)将0转化为STRUC*指针所指向的地址；
第二步，&(((STRUC*)0)-&e)结构体指针成员e的地址，由于结构体的首地址为0，&(((STRUC*)0)-&e)即为e距离结构体成员的偏移量。
第三步，强制类型转换，最终求的是偏移值，最好定义为无符号数据。size_t 等价于 unsigned int
7.&&&&&注意以下的表示方法！
#define SECONDS_PER_YEAR 365UL*24UL*3600UL用法值得商榷！
#defineMIN(a,b) ((a)&=(b) ? (a):(b))
8.&&&&&&const与define对比？
1． 是否具有类型？
2． 是否进行安全检查？
编译器有安全检查
仅是字符替换
3.&&&&&&& 是否可调试？
内联函数与define宏定义对比？
缺点及注意点
Define宏定义
1.提高了运行效率
1.不可调试，无法进行安全检查（类型）
2.可能出现边际效应导致出错。
3.不能操作类的私有数据成员。
1提高效率及安全性；
2编译器可以用上下文优化技术继续对结果代码优化。
1每一次内联处都要拷贝代码，使程序总工作量大；
2.短小、 简单函数设为内联（重复调用，无switch、for、while）等语句；
3.不要将构造、析构函数设置为内联函数。
9.&&&&&不常用的mutalbe关键字
[MSDN]mutable
C++Specific —&mutable member-variable-
Thiskeyword can only be applied to non-static and non-const data members of aclass. If a data member is declared mutable, then it is legal to assign a valueto this data member from a const member function.
解读：mutable成员变量的声明,这个关键字只能应用于类的非静态与非const数据成员。如果一个数据成员声明为mutable，那么通过const成员函数给数据成员分派一个值是合法的。
[作用]：加mutable关键字的成员变量，修饰为const的成员函数就可以修改它了。
不加mutable，会报错：l-value specifies const object。
classmutClS
mutClS(int nx):m_x(nx) {}
~mutClS(){}
void increase( int incx) const
void decrease(int decx) const
void display()
cout && m_x &&
mutable int m_x; //注意此处！
mutClS objA(35);
objA.increase(5);
objA.display();
objA.decrease(5);
objA.display();
10.&&C++对象的内存布局
先看一下以下程序占用内存的大小，即：sizeof(simpleClass)=？
class simpleClass
simpleClass(){}
virtual ~simpleClass() {}
int getValue(){}
virtual void fool(){}
static void addCount(){}
static int nC
该simpleClass类中含有构造、析构、静态成员函数、虚函数、普通成员函数；静态成员变量、普通成员变量。
占内存情况
static int nC
全局/静态存储区
不作为对象占据内存的一部分
非静态数据成员
根据地址对齐，二者占用8字节空间。
static void addCount(){}
C++编译器采用普通与C函数类似的方式进行编译，只不过对函数进行了名字修饰（name mangling），用来支持重载；并且在参数列增加了一个this指针，用来表明哪一个对象调用的该函数。
静态和非静态成员函数的多少对对象的大小没有影响。
int getValue(){}
构造、析构函数、拷贝构造
virtual void fool(){}
C++编译器在碰到虚函数的类时，会分配一个指针指向一个函数地址表，叫做“虚函数表”。
占4个字节，虚函数表指针占据的4个字节。
看下面注释的结果值，再分析：
int main()
simpleClass aS
cout && &Object startaddress:\t& && &aSimple && //0012FF68
cout && &nValueaddress:\t& && &aSimple.nValue && //0012FF6C
printf(&c address: %x\n&,&aSimple.c); //0012FF70
cout && &size: &&& sizeof(simpleClass) && //12
&aSimple= 0012FF68；即虚函数表指针占据的一个对象开始的4个字节。
结论如下：
（1）非静态数据成员是影响对象占据内存的主要因素，随着对象数目的增多，非静态数据成员占据的内存也会相应增加。
（2）所有的对象共享一份静态数据成员，所以静态数据成员占据的内存的数量不会随着对象数目的增加而增加。
（3）静态成员函数和非静态成员函数不会影响对象内存的大小，虽然其实现会占据相应的内存空间，同样也不会随着对象数目的增加而增加。
（4）如果对象中包含虚函数，会增加4个字节的空间，不论有多少个虚函数。
——摘自《C++应用程序性能优化》（第2版）P25
扩展一：如果在simpleClass的基础上增加继承类，如下：继承类所占内存大小是多少？
class derivedClass :public simpleClass
derivedClass(){}
~derivedClass(){}
答案：16个字节，派生类derivedClass与其基类simpleClass使用的是同一个虚函数表。或者说派生类在构造时，不再创建一个新的虚函数表，而应该是在基类的虚函数表中增加或修改。
扩展二：空类的大小，以及单继承、多继承，虚拟继承后的空类大小。
class C : public
class D : virtualpublic
class E : public
A, public B
int main()
cout && sizeof(A) && //1
cout && sizeof(B) && //1
cout && sizeof(C) && //1
cout && sizeof(D) && //4[涉及虚拟继承（虚指针）]
cout && sizeof(E) && //1
扩展三：为了避免出现菱形问题，用使用虚拟继承后的子类大小。示例如下：
class baseClass
virtual void fool(void) {}
class midClass1 : virtualpublic baseClass
virtual void setVal(){}
int nMidValue1;
class midClass2 : virtualpublic baseClass
virtual void setVal(){}
int nMidValue2;
class derivedClass :
public midClass1,
public midClass2
virtual void foo2(){}
int main()
cout && sizeof(baseClass) && //12
cout && sizeof(midClass1) && //24
cout && sizeof(midClass2) && //24
cout && sizeof(derivedClass) && //48
已经知道的，对于baseClass类的大小，考虑地址对齐为4(c)+4(nvalue)+4(虚拟函数指针)共12个字节；
如果去掉虚拟继承，为如下形式：
class midClass1 : publicbaseClass //仅是增加了nMidValue1，扩展为16字节
class midClass2 : publicbaseClass //仅是增加了nMidValue2，扩展为16字节
classderivedClass :& public midClass1,& public midClass2 //在继承midclass1，midclass2基础上仅是增加了subVal，为16+16+4=36字节。
不理解点：为什么加了虚拟继承，sizeof(midClass1)= 24；sizeof(midClass2)=24；sizeof(derivedClass)48；
主要原因，VisualC++添加了了虚拟基类表指针来实现虚拟继承，类中只要有visual函数就会产生这个vtb 虚函数表和一个vptr虚函数指针,它们都会占内存的。
具体为什么增加了8个字节，希望与大家探讨！
【已解决】主要原因，VisualC++添加了了虚拟基类表指针来实现虚拟继承，因此，空间变大？实际怎么多了8个字节。。
& & & 解读：baseClass类包含1个虚函数表指针（4个字节）、1个int型数据成员（4个字节）、1个char型数据（对齐后4个字节）成员，共12个字节。
& & & midClass1同midClass2一致，需要在baseClass类的基础上，多了1个虚函数表指针（4个字节）、1个指向虚基类表的指针（4个字节）、一个整形数据成员（4个字节），合计共12+12 =24个字节。
derivedClass 在上述的基础上，包含baseClass(12个字节)、midClass1(新增12个字节)、midClass2(新增12个字节)、derivedClass的1个整形数据成员（4个字节），合计共40个字节。注意derivedClass是继承而非虚拟继承自两个父类，所以没有指向虚基类表的指针。
& & & 扩展，如果将上述继承该为：class derivedClass : virtual public midClass1, virtual public midClass2.上述大小会变为48个字节（多了两个指向虚基类表的指针（每个4个字节））。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：519529次
积分：7682
积分：7682
排名：第1725名
原创：181篇
转载：29篇
评论：505条
(1)(8)(10)(5)(7)(2)(1)(4)(3)(1)(1)(3)(3)(4)(2)(2)(1)(1)(9)(3)(2)(1)(1)(1)(1)(1)(1)(2)(1)(1)(3)(2)(7)(1)(2)(3)(1)(2)(1)(3)(6)(2)(5)(6)(8)(15)(13)(13)(13)(1)(12)(3)(5)君，已阅读到文档的结尾了呢~~
第五章题库答案,编译原理第五章..
扫扫二维码，随身浏览文档
手机或平板扫扫即可继续访问
第五章题库答案
举报该文档为侵权文档。
举报该文档含有违规或不良信息。
反馈该文档无法正常浏览。
举报该文档为重复文档。
推荐理由：
将文档分享至：
分享完整地址
文档地址：
粘贴到BBS或博客
flash地址：
支持嵌入FLASH地址的网站使用
html代码：
&embed src='/DocinViewer--144.swf' width='100%' height='600' type=application/x-shockwave-flash ALLOWFULLSCREEN='true' ALLOWSCRIPTACCESS='always'&&/embed&
450px*300px480px*400px650px*490px
支持嵌入HTML代码的网站使用
您的内容已经提交成功
您所提交的内容需要审核后才能发布，请您等待！
3秒自动关闭窗口3061人阅读
源代码（33）
Object-C（5）
1.关键字命名：为了避免与已有的c，C++关键字冲突，ObjectC关键字都有@开始：
如：@classs，@interface，@private，@try，@catch，@protocol等。&
2.oc类分为2个文件，一个是.h文件，一个是.m文件：
.h文件：存放类，函数的申明；类申明使用关键字@interface @end来申明；
.m文件：存放类的具体实现；类实现使用关键字@implementation @end来实现；&
3.对象的方法和类的方法：
+表示类的方法；
-表示对象的方法&
4.类的申明 Dog.h：
#import&Foundation/Foundation.h&
@interface Dog:NSObject{
5.类的实现 Dog.m：
#import &Dog.h&
@implementation Dog&
6.创建和销毁OC对象：
创建对象：Dog *dog=[Dog alloc];//申明对象必须要带*号，即代表指针，也代表引用
初始化：[dog init]；
销毁对象：[dog release];&
7.类中的字段和函数：
@interface Dog:NSObject
& &//字段定义在此&
//函数定义在此：OC的函数全部是public类型的，可以用其他方式实现私有函数
-(void)setAge:(int)newA
8.完整实例：
//Dog.h 类申明文件
#import&Foundation/Foundation.h&
@interface Dog:NSObject{
-(id)initWidthAge:(int)newA
-(int)getA
-(void)setAge:(int)newA
//Dog.m 类的实现
#import &Dog.h&
@implementation Dog
-(id)init{
return [self initWithAge:10];
-(id)initWithAge:(int)newAge{
self=[super init];
-(int)getAge{
-(void)setAge:(int)newAge{
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：1260766次
积分：14677
积分：14677
排名：第485名
原创：380篇
转载：116篇
译文：21篇
评论：210条
(1)(4)(3)(6)(2)(2)(3)(8)(2)(7)(7)(2)(3)(2)(4)(3)(3)(8)(2)(3)(2)(5)(1)(3)(12)(6)(4)(11)(6)(1)(3)(3)(5)(3)(3)(8)(13)(23)(8)(6)(5)(15)(6)(4)(1)(6)(22)(6)(10)(2)(5)(12)(5)(12)(3)(5)(3)(2)(16)(7)(7)(4)(1)(5)(6)(7)(7)(4)(3)(10)(14)(7)(1)(2)(6)(18)(2)(27)(35)(1)(2)梦幻天空号
不是太专业, 是分太少…
问题1还好,
问题2就有操作符重载了
问题3是继承
您的举报已经提交成功，我们将尽快处理，谢谢！
int situ1[13];
int situ2[13]...
哪里不懂你Q我吧我在告诉你
你想要的是这样的吗：
#include&iostream&
大家还关注
if(x>1),y=x;
else if(1<=x=10),y=3x-11;
cout <c++ if 语句 这里哪里出错了？
(window.slotbydup=window.slotbydup || []).push({
id: '2081942',
container: s,
size: '1000,60',
display: 'inlay-fix'C++复习题4
本大题共20小题，每小题1分，共20分)在每小题列出的四个备选项中
1. 时，该函数在该类的所有派生类中（）
C. 时才是虚函数
在基类声明为virtual的函数为虚函数，在派生类中只要有相同的函数（函数名相
说明，也都是虚函数。
2. 本身，又要禁止修改p所指向的数据，这样的指针应定义为（）
说明禁止通过p修改所指向的数据。char *
const p则说明不能修改
的地址。因此const
char * const p=“ABCD”；它禁止修改指针p本身，又禁止修改p所指
3. 中所含实参的个数为（）
、(exp3,exp4,exp5)表示是两个逗号表达式，值是最后一个值，相当于两个
D. ”,”CD”);
x,Q y)可知形参和函数返回值都是同一种数据类型。A、B、C三项都正确
项用字符串作为实参，字符串的操作与数值类型不同，要用特殊方法进行字符串的连接和
5. 是类A的公有派生类，类A和类B中都定义了虚函数func(),p是一个指向类A对象的指针
A. 中的函数func()
B. 中的函数func()
C. 所指的对象类型而确定调用类A中或类B中的函数func()
D. 中函数，也调用类B中的函数
指向类成员指针的使用，A::func()是明确调用A类的func函数，所以不管p指向基
和p-&fun();进行区分。如果使用p-
指向派生类对象，由动态多态性可知要调用派生类的虚函数。
面向过程的和面向对象都具有、函数、文件和过程这些概念，而面向对象程序才有
7. 和f2是同一类的两个成员函数，但f1不能直接调用f2，这说明（）
A. 都是静态函数
B. 是静态函数
C. 不是静态函数
D. 都不是静态函数
普通成员函数可以调用静态函数，相反静态函数不能调用普通成员函数，这与普通
类是相同类型事物的抽象，具有不同的操作。而模板是不同类型的事物，具体相同
9. 编译指令，以下叙述正确的是（）
C. 或//开始
D. 后的常量表达式是否为真，该部分都需要编译
编译指令以＃作为开头，只能一行写一条，＃if有选择进行编译，所以选择B项。
10. 中不返回任何类型的函数应该说明为（）
来声明，int char
double分别是整型、字符型和实型。
11. 类中的一个成员函数说明如下：
的含义是（）
A. 的名为a的指针
B. 的对象引用，用来作函数Set（）的形参
C. 的地址赋给变量Set
D. 与a按位与的结果作为函数Set的参数
成员函数使用对象的引用作为形参。该函数的功能是将已知对象的所有数据成员的
静态成员属于类的即所有对象所共享的，只能在外部进行初始化。使用时可以使用
静态成员或者对象.静态成员。所以选择D项。
条件编译，＃include文件包含，＃error错误处理。
删除对象或结束程序时，自动调用析构函数。
15. 运算符的下列描述中，错误的是（）
静态成员的特性是静态成员只有一个拷贝（副本），这个副本被所有属于这个类的
开始，包括静态数据成员和静态成员
关键字，以免与一般静态变量或对象混淆。
限定它所属的
16. 被说明成类B的友元，则（）
A. 不一定是类A的友元
B. 的成员即类A的成员
C. 的成员即类B的成员
D. 的成员函数不得访问类B的成员
友元关系不能被继承，友元关系是单向的，友元关系不具有传递性。但是友元函数
17. ，则执行A x(4,5);语句
和x.b的值分别为（）
执行构造函数将数据成员进行赋值，aa++是后加，先赋值a＝4，++bb,bb变量值先自
，再与a相乘，所以b＝24。
18. 语言中不能重载的是（）
除了类属关系运算符"."、成员指针运算符".*"、作用域运算符"::"、sizeof运算
以外，C++中的所有运算符都可以重载。
类族即同一个类派生出来的类，各个类是兄弟或父子关系。
20. 语言中，数据封装要解决的问题是（）
封装是指把对象属性和操作结合在一起，构成独立的单元，它的内部信息对外界是
本大题共20小题，每小题1分，共20分)请在每小题的空格中填上正确答案
1. 类，需要引入的头文件是___。
2. 保留字修饰时，则表示该函数表为内联函数。
3. 方法返回向量中的第一个对象。
返回向量中的第1个对象。back（）：返回向量中的最
［］(size_type,n):返回向量中的第n＋1个对象（下标为n的向量元素
，即增加派生类的性质。
5. 、优先级和结合性不变。
除了类属关系运算符“.”、成员指针运算符“.*”、作用域运算符“::”、sizeof运算符
”以外，C++中的所有运算符都可以重载。
重载运算符限制在C++语言中已有的运算符范围内的允许重载的运算符之中，不能创建新的
重载之后的运算符不能改变运算符的优先级和结合性，也不能改变运算符操作数的个数及
6. 函数实现。
文件包含＃include和条件编译#if等。
9. 是设置域宽的。要求给出函数名和参数类型）。
用来设置n输出宽度。
10. ，另一部分是自己定义的新成员。
从基类继承的成员
11. 的直接基类___。
和ostream的直接基类是ios。
12. 方法返回向量中的最后一个对象。
返回向量中的第1个对象。back（）：返回向量中的最后一个对象。
返回向量中的第n＋1个对象（下标为n的向量元素）。
14. 中有两种参数传递方式即值传递和___传递。
15. 为int数组动态分配10个存储空间是___。
动态开辟空间和删除空间。new
int［10］，注意不要写成new
），使用小括号只能开辟一个空间，使用10来初始化该值。
修饰的函数就是虚函数。但不是所有成员函数都可以定义为虚
”&&oct&&34;
表示八进制，hex表示十六进制，但它们只能输出整型的数据。
19. 中要创建一个文件输入流对象fin，同时该对象打开文件“Test.txt”用于输入，则
“Test.txt”)；
用于文件的输入，可以调用它的构造函数与要打开的文件进行关联
本大题共5小题，每小题2分，共10分)下面的类定义中有一处错误，请用下
初始化列表格式错误。
保护类型的成员，不能在类外访问。
成员函数作为友元函数，要加friend。
采用默认的访问权限即私有的，在外部无法访问。
［］="hi";
［］="Hello",s2［］="hi";使用Swap(s1,s2)调用交换的是地址。字符指针作实
本大题共5小题，每小题4分，共20分)
定义构造函数，使参数i和j的默认值为0
初始化a，用j初始化b
指向的动态对象
和b成员分别被初始化为4和5
，使用new运算符动态分配对象空间，同时初始对象成员值
，cout&&x&&"+"&&y&&"="&&x+y&&
，取得下标为i的元素的值。
5. 并使程序的输出为:
］={B(10,11),B(12,13)};
，b［i］.show();
，后b，所以对a＝j，b=i;在循环中
本大题共4小题，每小题5分，共20分)
，先调用基类构造函数，在b构造函数中使用的是A(i)，注意大小写，不
也就是说调用基类的构造函数时没有实参值，所以采用默认值；在初始化类成员A，即
＝5，所以输入为a:5；最后是b类的构造函数，x=5,来自基类x＝10，输出b:5,10。
］={{5,5},{3,3},{1,1},{2,2},{4,4}};
］.init(7,3);
［3］元素的值，又使用指针修改指针所指向的
［0］和A［3］元素的值。
］={1,2,3,4,5,6,7};
指向对象x2，x2.getA()+5该值为8 即x2.a＝8;10+x1.getA()为10，x1.a＝10。
本大题共1小题，共10分)
实现这个类；（2）定义并实现一个小车类car，是它的公有派生类，小车本身的私有
设置车轮数，重量和载人数），getpassenger(获取载人数
（打印车轮数，重量和载人数）。
重量："&&weight&&}
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。