Question

几个简单的C++问题

1.已知：char ss[][6]={"while","for","else","break"}; 输出显示"reak"字符串的表达式

为什么答案是 ss[3]+1 数组可以这样表示么？

2.为什么cout<<~4<<endl;的值是-5 ?

3. 为什么cout<<(5<<2)+(5>>2)<<endl;的值是21 (5>>2)的值为什么是1不是1.01?

4.#include <iostream.h>
int a=8;
void main()
{
int b=6;
double d=1.5;
d+=a+b;
cout<<(a<0?a:b<0?a++:b++);
}

的值为什么为2， 解释下过程。

5.int a[]={5,4,3,2,1};
int*p=&a[2];

为什么指针可以这样定义，这样不是指向地址了？

6.#include <iostream.h>
int a[]={10,9,6,5,4,2,1};
void main()
{
int n(7),i(7),x(7);
while(x>*(a+i))
{
*(a+i+1)=*(a+i);
i--;
}
*(a+i+1)=x;
for(i=0;i<n;i++)
cout<<*(a+i)<<',';
cout<<a[i]<<endl;

}

为什么可以执行*(a+7) ? 不是数组在初始化的时候已经定义只有7位了么？

7.#include <iostream.h>
class A
{
public:
A(int i)
{a=i;}
A()
{
a=0;
cout<<"调用缺省构造函数."<<a<<endl;
}
~A()
{
cout<<"调用析构函数."<<a<<endl;
}
void print()
{ cout<<a<<endl;}
private:
int a;

};

void main()
{
A a[4],*p;
int n=1;
p=a;
for(int i=0;i<4;i++)
a[i]=A(++n);
for(i=0;i<4;i++)
(p+i)->print();
}

输出结果为：

调用缺省构造函数.0
调用缺省构造函数.0
调用缺省构造函数.0
调用缺省构造函数.0
调用析构函数.2
调用析构函数.3
调用析构函数.4
调用析构函数.5
2
3
4
5
调用析构函数.5
调用析构函数.4
调用析构函数.3
调用析构函数.2

第一次调用析构函数是在什么时候调用的，调用的原因是因为a[4]被释放了么？
为什么调用的次序是正向的；不是先赋值后析构么？

Answer 1

1.已知：char ss[][6]={"while","for","else","break"}; 输出显示"reak"字符串的表达式

为什么答案是 ss[3]+1 数组可以这样表示么？

-----------------------------------------------------------------------
ss[3]表示第4个一维数组"break";ss[3][1]=ss[3]+1表示第四个一维数组的第2个地址"r";按%s输出遇到'\0'结束，于是
输出reak;
-----------------------------------------------------------------------
2.为什么cout<<~4<<endl;的值是-5 ?
-----------------------------------------------------------------------
~ 在C叫按为取反：2进制位取反（1得到0，0得到1)
4=00000100
~4=11111011(补码)=11111010(反码)=10000101(原码)[首为是符号不管]=-5
------------------------------------------------------------------------

3. 为什么cout<<(5<<2)+(5>>2)<<endl;的值是21 (5>>2)的值为什么是1不是1.01?
-----------------------------------------------------------------------
(5<<2)+(5>>2)=(00000101<<2)+(00000101>>2)=5*2*2+5/2/2=20+1=21(按位没有小数出现，右移出界的位直接删除)
-----------------------------------------------------------------------

4.#include <iostream.h>
int a=8;
void main()
{
int b=6;
double d=1.5;
d+=a+b;
cout<<(a<0?a:b<0?a++:b++);
}

的值为什么为2， 解释下过程。
-----------------------------------------------------------------------
int a=8;
int b=6;
double d=1.5;
d+=a+b;
后：a=8,b=6,d=15.5;
(a<0?a:b<0?a++:b++) :从右边的三目运算开始 (a<0?a:6)[为什么不是7?因为先取值在加1],于是这个表达式=6,你答案错了

---------------------------------------------------------------------------
5.int a[]={5,4,3,2,1};
int*p=&a[2];

为什么指针可以这样定义，这样不是指向地址了？
--------------------------------------------------------------------------
指针本就是指向地址的变量 int * p=a;表示指向数组开始，等同与int * p=&a[0];
--------------------------------------------------------------------------

6.#include <iostream.h>
int a[]={10,9,6,5,4,2,1};
void main()
{
int n(7),i(7),x(7);
while(x>*(a+i))
{
*(a+i+1)=*(a+i);
i--;
}
*(a+i+1)=x;
for(i=0;i<n;i++)
cout<<*(a+i)<<',';
cout<<a[i]<<endl;

}

为什么可以执行*(a+7) ? 不是数组在初始化的时候已经定义只有7位了么？
-----------------------------------------------------------------------------
数组不能下标越界，但是指针可随便使用，没有界限：
int i[2]={1,2},*p=i;
*(p+5)=10;
printf("%d\n",*(p+5));
同样OK!但是不建议这样
-----------------------------------------------------------------------------

7.#include <iostream.h>
class A
{
public:
A(int i)
{a=i;}
A()
{
a=0;
cout<<"调用缺省构造函数."<<a<<endl;
}
~A()
{
cout<<"调用析构函数."<<a<<endl;
}
void print()
{ cout<<a<<endl;}
private:
int a;

};

void main()
{
A a[4],*p;
int n=1;
p=a;
for(int i=0;i<4;i++)
a[i]=A(++n);
for(i=0;i<4;i++)
(p+i)->print();
}

输出结果为：

调用缺省构造函数.0
调用缺省构造函数.0
调用缺省构造函数.0
调用缺省构造函数.0
调用析构函数.2
调用析构函数.3
调用析构函数.4
调用析构函数.5
2
3
4
5
调用析构函数.5
调用析构函数.4
调用析构函数.3
调用析构函数.2

第一次调用析构函数是在什么时候调用的，调用的原因是因为a[4]被释放了么？
为什么调用的次序是正向的；不是先赋值后析构么？
----------------------------------------------------------------------------------------------
首先A a[4];调用缺省构造输出 "调用缺省构造函数.0 "
再是for(...) a[i]=A(++n); 调用参数构造输出 "调用析构函数.2"
然后for(...) printf(); 调用print()输出 2 3 4 5
最后析构，因为数组释放从高到底于是从a[3]开始析构
------------------------------------------------------------------------------------------------1.已知：char ss[][6]={"while","for","else","break"}; 输出显示"reak"字符串的表达式

为什么答案是 ss[3]+1 数组可以这样表示么？

-----------------------------------------------------------------------
ss[3]表示第4个一维数组"break";ss[3][1]=ss[3]+1表示第四个一维数组的第2个地址"r";按%s输出遇到'\0'结束，于是
输出reak;
-----------------------------------------------------------------------
2.为什么cout<<~4<<endl;的值是-5 ?
-----------------------------------------------------------------------
~ 在C叫按为取反：2进制位取反（1得到0，0得到1)
4=00000100
~4=11111011(补码)=11111010(反码)=10000101(原码)[首为是符号不管]=-5
------------------------------------------------------------------------

3. 为什么cout<<(5<<2)+(5>>2)<<endl;的值是21 (5>>2)的值为什么是1不是1.01?
-----------------------------------------------------------------------
(5<<2)+(5>>2)=(00000101<<2)+(00000101>>2)=5*2*2+5/2/2=20+1=21(按位没有小数出现，右移出界的位直接删除)
-----------------------------------------------------------------------

4.#include <iostream.h>
int a=8;
void main()
{
int b=6;
double d=1.5;
d+=a+b;
cout<<(a<0?a:b<0?a++:b++);
}

的值为什么为2， 解释下过程。
-----------------------------------------------------------------------
int a=8;
int b=6;
double d=1.5;
d+=a+b;
后：a=8,b=6,d=15.5;
(a<0?a:b<0?a++:b++) :从右边的三目运算开始 (a<0?a:6)[为什么不是7?因为先取值在加1],于是这个表达式=6,你答案错了

---------------------------------------------------------------------------
5.int a[]={5,4,3,2,1};
int*p=&a[2];

为什么指针可以这样定义，这样不是指向地址了？
--------------------------------------------------------------------------
指针本就是指向地址的变量 int * p=a;表示指向数组开始，等同与int * p=&a[0];
--------------------------------------------------------------------------

6.#include <iostream.h>
int a[]={10,9,6,5,4,2,1};
void main()
{
int n(7),i(7),x(7);
while(x>*(a+i))
{
*(a+i+1)=*(a+i);
i--;
}
*(a+i+1)=x;
for(i=0;i<n;i++)
cout<<*(a+i)<<',';
cout<<a[i]<<endl;

}

为什么可以执行*(a+7) ? 不是数组在初始化的时候已经定义只有7位了么？
-----------------------------------------------------------------------------
数组不能下标越界，但是指针可随便使用，没有界限：
int i[2]={1,2},*p=i;
*(p+5)=10;
printf("%d\n",*(p+5));
同样OK!但是不建议这样
-----------------------------------------------------------------------------

7.#include <iostream.h>
class A
{
public:
A(int i)
{a=i;}
A()
{
a=0;
cout<<"调用缺省构造函数."<<a<<endl;
}
~A()
{
cout<<"调用析构函数."<<a<<endl;
}
void print()
{ cout<<a<<endl;}
private:
int a;

};

void main()
{
A a[4],*p;
int n=1;
p=a;
for(int i=0;i<4;i++)
a[i]=A(++n);
for(i=0;i<4;i++)
(p+i)->print();
}

输出结果为：

调用缺省构造函数.0
调用缺省构造函数.0
调用缺省构造函数.0
调用缺省构造函数.0
调用析构函数.2
调用析构函数.3
调用析构函数.4
调用析构函数.5
2
3
4
5
调用析构函数.5
调用析构函数.4
调用析构函数.3
调用析构函数.2

第一次调用析构函数是在什么时候调用的，调用的原因是因为a[4]被释放了么？
为什么调用的次序是正向的；不是先赋值后析构么？
----------------------------------------------------------------------------------------------
首先A a[4];调用缺省构造输出 "调用缺省构造函数.0 "
再是for(...) a[i]=A(++n); 调用参数构造输出 "调用析构函数.2"
然后for(...) printf(); 调用print()输出 2 3 4 5
最后析构，因为数组释放从高到底于是从a[3]开始析构
------------------------------------------------------------------------------------------------

Answer 2

1.已知：char ss[][6]={"while","for","else","break"}; 输出显示"reak"字符串的表达式

为什么答案是 ss[3]+1 数组可以这样表示么？
答：这个表达式的值是 地址，所以符合题意。

2.为什么cout<<~4<<endl;的值是-5 ?
答：不懂

3. 为什么cout<<(5<<2)+(5>>2)<<endl;的值是21 (5>>2)的值为什么是1不是1.01?
答：5 对应的二进制式：0101 ，5>>2 对应 0001 [01]被移掉
所以答案是 5*4+1 = 21.

4.#include <iostream.h>
int a=8;
void main()
{
int b=6;
double d=1.5;
d+=a+b;
cout<<(a<0?a:b<0?a++:b++);
}

的值为什么为2， 解释下过程。
答：应该是 6 ，要么题写错了。

5.int a[]={5,4,3,2,1};
int* p = &a[2];

为什么指针可以这样定义，这样不是指向地址了？
答：这是把地址赋给指针，不是指向地址，记住，要看指针指向什么类型的值，取决于地址对应的内存中存储的什么类型的值(仅限于指针定义)

6.#include <iostream.h>
int a[]={10,9,6,5,4,2,1};
void main()
{
int n(7),i(7),x(7);
while(x>*(a+i))
{
*(a+i+1)=*(a+i);
i--;
}
*(a+i+1)=x;
for(i=0;i<n;i++)
cout<<*(a+i)<<',';
cout<<a[i]<<endl;

}

为什么可以执行*(a+7) ? 不是数组在初始化的时候已经定义只有7位了么？
答：可以执行，但是是不可预料的。

7.#include <iostream.h>
class A
{
public:
A(int i)
{a=i;}
A()
{
a=0;
cout<<"调用缺省构造函数."<<a<<endl;
}
~A()
{
cout<<"调用析构函数."<<a<<endl;
}
void print()
{ cout<<a<<endl;}
private:
int a;

};

void main()
{
A a[4],*p;
int n=1;
p=a;
for(int i=0;i<4;i++)
a[i]=A(++n);
for(i=0;i<4;i++)
(p+i)->print();
}

输出结果为：

调用缺省构造函数.0
调用缺省构造函数.0
调用缺省构造函数.0
调用缺省构造函数.0
调用析构函数.2
调用析构函数.3
调用析构函数.4
调用析构函数.5
2
3
4
5
调用析构函数.5
调用析构函数.4
调用析构函数.3
调用析构函数.2

第一次调用析构函数是在什么时候调用的，调用的原因是因为a[4]被释放了么？
为什么调用的次序是正向的；不是先赋值后析构么？
答：

A a[4];//定义4个A对象，调用4次类A的默认构造函数。
于是有以下输出：
调用缺省构造函数.0
调用缺省构造函数.0
调用缺省构造函数.0
调用缺省构造函数.0

for(int i=0;i<4;i++)
a[i]=A(++n);
//每一次循环定义一个临时A对象，调用类A的 带参构造函数，同时每一次循环结束时，临时对象销毁，调用类A的析构函数。
于是有以下输出：
调用析构函数.2
调用析构函数.3
调用析构函数.4
调用析构函数.5

for(i=0;i<4;i++)
(p+i)->print();
调用每一个数组元素的成员函数，由于初始化值不同，所以输出不同。
于是有以下输出：
2
3
4
5

最后，在这个程序结束是时，系统销毁A对象数组 a[4]，每一个对象的销毁都调用类A的析构函数。
于是有了以下输出：
调用析构函数.5
调用析构函数.4
调用析构函数.3
调用析构函数.2

注意：这段析构对应的是第一段输出的构造，并不是中间的那一段，中间的那一段析构有对应的构造，只不过它没有输出什么(只是对类A的数据成员 a 赋值)，所以你看不出来。

Answer 3

第一个问题记住就可以了，至于为什么会输出字符串，我想应该清楚吧。
第二个问题，~是按位取反运算，用补码表示的，你自己算一下就明白了。
第三个问题，移位运算，低位向右移时，原来低位已不存在了，哪还有0.01。
第四个问题，结果应该是6，而不是2.过程为先算b<0?a++:b++;
显然b<0不成立，所以去b++。此时得到6，（运算完后b才变为7），
然后算a<0?a:6,显然答案为6.
第五个问题,a[2]表示第三个数，&a[2]就是地址。当然也可以写成int *p=a+2；
第六个问题，根本就没有执行*(a+7)。(i<7)。
最后一个问题，析构函数的调用是正向的？？？

Answer 4

1.ss[3]+1表示数组ss的第4个元素的、第二个字符开始计起的字符串，二位数组可以理解为存储为：
0 1 2 3 4
0 w h i l e
1 f o r
2 e l s e
3 b r e a k
ss[3]+1则表示3行1类开始的字符串，即reak

2.~4是表示对4的二进制代码取反，也就是-5

3.(5<<2)表示将5的二进制码左移2位，00000101左移后变为00010100，即20，(5>>2)表示将5的二进制码右移2位，高位补0，00000101右移后变为00000001，即1 ，所以(5<<2)+(5>>2)结果为21

4.那个代码我没怎么看懂，cout<<(a<0?a:b<0?a++:b++); 是选择语句吗？

5.把数组的元素赋值给指针变量的时候就是要这么定义的，要对元素取地址再传递给指针，如果是把数组赋值格指针时，可以直接把数组名或者数组的首元素赋给指针变量

6.*(a+7) 是达不到的，上面for语句的循环条件设置为i<n，n=7，所以i的最大值为6，所以达不到*(a+7)，最多达到.*(a+6)，所以没有超出数组边界

7.在声明A类型变量时，调用4次缺省构造函数，来对数组初始化，然后再对数组变量重新赋值的时候，调用析构函数，每次a的值都先改变后析构，亿就是说a被改变一个，析构一个，再调用带参数的构造函数。所以输出为2345，然后由for(i=0;i<4;i++)
(p+i)->print();
正向调用print()，输出为2345
在最后主函数结束，析构时与构造相反，为逆向5432

Answer 5

十万个为什么?