题一:
1、int a=5,则 ++(a++)的值是()
A、5 B、 6 C、7 D、逻辑错误
a++返回的是一个临时变量,这里是右值,不能再前面++了
2、下面的代码输出什么?(取地址运算符比+运算符的优先级要高)
- int main(void)
- {
- int a[5] = {1, 2, 3, 4, 5};
- int *ptr = (int *)(&a+1);
- printf("%d %d",*(a+1),*(ptr-1));
- return 0;
- }
&a是一个指向数组的指针(行指针),a的步长就是数组的长度。也就是说执行a+1时,a要跨过n个整型数据的长度,输出*ptr就会发现越界了,是一个随机值,那么ptr-1的值就是数组的最后一个值了。
&a+1不是首地址+1, 系统会认为加一个a数组的偏移, 是偏移了一个数组的大小(本例是5个int )
int *ptr = (int *)(&a+1);
则ptr实际上是&(a[5]),也就是a+5
原因如下:
&a 是数组指针, 其类型为int (*)[5];
而指针加1要根据指针类型加上一定的值, 不同类型的指针+1之后增加的大小不同。
a 是长度为5的int数组指针,所以要加5*sizeof(int)
所以,ptr实际是ptr[5]
但是ptr与(&a+1)类型时不一样的(这点很重要)
所以ptr-1只会减去sizeof(int *)
a, &a的地址是一样的,但是意思不一样
a是数组首地址,也就是a[0]的地址,&a是对象(数组)首地址
a+1是数组下一元素的地址,即a[1], &a+1是下一个对象的地址,即a[5].
3、以下三条输出语句分别输出什么?
- char str1[] = "abc";
- char str2[] = "abc";
- const char str3[] = "abc";
- const char str4[] = "abc";
- const char* str5 = "abc";
- const char* str6 = "abc";
- cout << boolalpha << ( str1==str2 ) << endl; // 输出什么?
- cout << boolalpha << ( str3==str4 ) << endl; // 输出什么?
- cout << boolalpha << ( str5==str6 ) << endl; // 输出什么?
答:分别输出false,false,true。str1和str2都是字符数组,每个都有其自己的存储区,它们的值则是各存储区首地址,不等;str3和str4同上,只是按const语义,它们所指向的数据区不能修改。str5和str6并非数组而是字符指针,并不分配存储区,其后的“abc”以常量形式存于静态数据区,而它们自己仅是指向该区首地址的指针,所以相等。
4、下面代码的输出是什么?
- float a = 1.0f;
- cout<< (int)a <<endl;
- cout<< (int&)a <<endl;
- cout << boolalpha << ( (int)a==(int&)a ) << endl; // 输出什么?
- float b = 0.0f;
- cout<< (int)b <<endl;
- cout<< (int&)b <<endl;
- cout << boolalpha << ( (int)b==(int&)b ) << endl; // 输出什么?
浮点数的 1.0f 在内存里是这样表示的:
0011 1111 1000 0000 00000000 00000000
这个32位二进制数被当作整数输出就是:
1065353216
而整数的 1 在内存里是这样表示的:
0000 0000 0000 0000 00000000 00000001
所以 (int)a != (int&)a
浮点的0和整数的0 在内存里都是:
0000 0000 0000 0000 00000000 00000000
所以 (int)b == (int&)b
5、以下代码中的两个sizeof用法有问题吗?
- void UpperCase( char str[] ) // 将str 中的小写字母转换成大写字母
- {
- for( size_t i=0; i<sizeof(str)/sizeof(str[0]); ++i )
- {
- if( 'a'<=str[i] && str[i]<='z' )
- {
- str[i] -= ('a'-'A' );
- }
- }
- }
- int main(void)
- {
- char str[] = "aBcDe";
- cout << "str字符长度为: " << sizeof(str)/sizeof(str[0]) << endl;
- UpperCase( str );
- cout << str << endl;
- return 0;
- }
7、以下代码有什么问题?
- struct Test
- {
- Test(int ) { }
- Test() { }
- void fun() { }
- };
- int main(void)
- {
- Test a(1);
- a.fun();
- Test b();
- b.fun();
- return 0;
- }
- cout<< (true?1:"0") <<endl;
9、以下代码能够编译通过吗,为什么?
- int main(void)
- {
- unsigned int const size1 = 2;
- char str1[ size1 ];
- unsigned int temp = 0;
- cin >> temp;
- unsigned int const size2 = temp;
- char str2[ size2 ];
- return 0;
- }
- int main(void)
- {
- vector array;
- array.push_back( 1 );
- array.push_back( 2 );
- array.push_back( 3 );
- for( vector::size_type i=array.size()-1; i>=0; --i ) // 反向遍历array数组
- {
- cout << array[i] << endl;
- }
- return 0;
- }
11、以下代码中的输出语句输出吗,为什么?
- struct CLS
- {
- int m_i;
- CLS(int i): m_i( i ) { }
- CLS()
- {
- CLS( 0 );
- }
- };
- int main(void)
- {
- CLS obj;
- cout << obj.m_i << endl;
- return 0;
- }
13、 以下代码有什么问题吗?
- int main(void)
- {
- typedef vector IntArray;
- IntArray array;
- array.push_back( 1 );
- array.push_back( 2 );
- array.push_back( 2 );
- array.push_back( 3 );
- // 删除array数组中所有的2
- for( IntArray::iterator itor=array.begin(); itor!=array.end(); ++itor )
- {
- if( 2 == *itor )
- {
- array.erase( itor );
- }
- }
- return 0;
- }
答案:
4、分别输出false和true。注意转换的应用。(int)a实际上是以浮点数a为参数构造了一个整型数,该整数的值是,(int&)a则是告诉编译器将a当作整数看(并没有做任何实质上的转换)。因为以整数形式存放和以浮点形式存放其内存数据是不一样的,因此两者不等。对b的两种转换意义同上,但是的整数形式和浮点形式其内存数据是一样的,因此在这种特殊情形下,两者相等(仅仅在数值意义上)。
注意,程序的输出会显示(int&)a=1065353216,这个值是怎么来的呢?前面已经说了,以浮点数形式存放在内存中,按ieee754规定,其内容为x0000803F(已考虑字节反序)。这也就是a这个变量所占据的内存单元的值。当(int&)a出现时,它相当于告诉它的上下文:“把这块地址当做整数看待!不要管它原来是什么。”这样,内容x0000803F按整数解释,其值正好就是(十进制数)。
通过查看汇编代码可以证实“(int)a相当于重新构造了一个值等于a的整型数”之说,而(int&)的作用则仅仅是表达了一个类型信息,意义在于为cout<<及==选择正确的重载版本。
5、答:函数内的sizeof有问题。根据语法,sizeof如用于数组,只能测出静态数组的大小,无法检测动态分配的或外部数组大小。函数外的str是一个静态定义的数组,因此其大小为,函数内的str实际只是一个指向字符串的指针,没有任何额外的与数组相关的信息,因此sizeof作用于上只将其当指针看,一个指针为个字节,因此返回。
6、答:
a. class B : public A { ……} // B公有继承自A,可以是间接继承的
b. class B { operator A( ); } // B实现了隐式转化为A的转化
c. class A { A( const B& ); } // A实现了non-explicit的参数为B(可以有其他带默认值的参数)构造函数
d. A& operator= ( const A& ); // 赋值操作,虽不是正宗的隐式类型转换,但也勉强算一个
7、答:变量b定义出错。按默认构造函数定义对象,不需要加括号。
8、答:三元表达式“?:”问号后面的两个操作数必须为同一类型。
9、答:str2定义出错,size2非编译器期间常量,而数组定义要求长度必须为编译期常量。
10、答:首先数组定义有误,应加上类型参数:vector<int> array。其次vector::size_type被定义为unsigned int,即无符号数,这样作为循环变量的i为0时再减就会变成最大的整数,导致循环失去控制。
- int main(void)
- {
- vector<int> array;
- array.push_back(1);
- array.push_back(2);
- array.push_back(3);
- for(int i = array.size() - 1 ; i >= 0 ; --i)
- cout<<array[i]<<endl;
- return 0;
- }
12、
- class Empty
- {
- public:
- Empty(); //缺省构造函数
- Empty(const Empty &); //拷贝构造函数
- ~Empty(); //析构函数
- Empty & operator=(const Empty &); //赋值运算符
- Empty* operator&(); //取址运算符
- const Empty* operator&() const; //取址运算符const
- };
- int main(void)
- {
- typedef vector<int> IntArray;
- IntArray array;
- array.push_back( 1 );
- array.push_back( 2 );
- array.push_back( 2 );
- array.push_back( 3 );
- // 删除array数组中所有的2
- for( IntArray::iterator itor=array.begin(); itor!=array.end(); ++itor )
- {
- if( 2 == *itor )
- {
- itor = array.erase( itor );
- itor--;
- }
- }
- return 0;
- }
14、
- // 功能:由src所指内存区域复制count个字节到dest所指内存区域。
- // 说明:src和dest所指内存区域可以重叠,但复制后dest内容会被更改。函数返回指向dest的指针
- void *memmove(void *dest , const void *src , size_t count)
- {
- assert( (dest != NULL) && (src != NULL)); //安全检查
- assert( count > 0 );
- char *psrc = (char *) src;
- char *pdest = (char *) dest;
- //检查是否有重叠问题
- if( pdest < psrc )
- {
- //正向拷贝
- while( count-- )
- *pdest++ = *psrc++;
- }
- else if( psrc < pdest )
- {
- //反向拷贝
- psrc = psrc + count - 1;
- pdest = pdest + count - 1;
- while( count-- )
- *pdest-- = *psrc--;
- }
- return dest;
- }
- // 功能:由src指向地址为起始地址的连续n个字节的数据复制到以dest指向地址为起始地址的空间内。
- // 说明:src和dest所指内存区域不能重叠,函数返回指向dest的指针
- void *memmcpy(void *dest , const void *src , size_t count)
- {
- assert( (dest != NULL) && (src != NULL)); //安全检查
- assert( count > 0 );
- char *psrc = (char *) src;
- char *pdest = (char *) dest;
- while( count-- )
- *pdest++ = *psrc++;
- return dest;
- }