4道C++程序题,高人来

程序一:
#include
#include
int x=1; //全局变量
void f(int x,int &y)
//x是用值传递的形式，y是用引用传递的形式，故
//当函数返回时，x的值将没有变化，而y的值却变
//化了。注：值传递其实是复制了这个对象，一切
//操作在拷贝上进行，而引用是别名，也就是在本
//身对象上进行操作
//这是这个地方最需要注意的。
{
//交换两个数的操作，就是交换x的拷贝和y的值
int z;
z=x;
x=y;
y=z;
//输出的x拷贝变化后的值，和y的值
cout<<"x="<}
void main()
{
int x=2,y=1;//掩盖了全局的x
{
//掩盖了{}外的x，{}表示的是一个块
int x=3;
//这里x=3而不是x==3，前者是赋值后者是比较，
//需要注意，而y在这里看似进行了重新赋值，但
//其实它位于if所在的块，当if语句结束时，它也
//消失了，所以跳出后y仍为1
if(x=3) int y=x/2;
if(x=2) int y=x*2; //x赋值为2
//通过以上的分析，知道，输出为（x=2
//y=1），之间宽为8
cout<<"x="<}
f(x,y);//输出（x=1 y=2）
//由上面对f的分析，知道，输出为（x=2 y=2）
cout<<"x="<//::x为全局x,故输出为（x=1）
cout<<"x="<<::x<}
程序二:
//这道题我认为关键在于认识几个知识点
//1.case语句后没有break，则连续执行几个case
//语句，直到遇到break为止
//2.goto语句，直接跳到其标识符的地方
//3.x++,++x，前者是先返回x，再++，后者是直接
//++，若是需要返回则返回的是++后的值
//4.这里第一行定义的x，y作用域是在整个main中
//故得到以下输出，列在注释中
#include
#include
void main()
{
int x=2,y=2;
11: switch(x)
{
case 2:
x%=y++; //x=x%y y=y+1
//输出：（x=0 y=3）
cout<<"x="<case 3:
x=y; //x=3
y=++x; //x=x+1=4 y=x=4
//输出：（x=4 y=4）
cout<<"x="<goto 11;//跳转到switch语句
case 4:
x++;
y--;
//输出：（x=5 y=3）
cout<<"x="<case 5:
if(x>5)x++;
if(y<3)y--;
//输出：（x=5 y=3）
cout<<"x="<default:
x/=y%4; //y%4=3 x=x/3=1
}
//输出：（x=1 y=3）
cout<<"x="<}
程序三:
//这道题，我认为要注意的是以下几点：
//1.static变量：它针对不是独立的对象，而是针
//对类型，故所有的对象都是用同一个count，只
//有一份
//2.局部变量的析构，在退出某个块的时候，在该
//块中声明定义的那几个对象要被析购，调用析购
//函数
#include
class widget
{
public:
widget()
{
count++;
}
~widget()
{
--count;
}
static int num()
{
return count;
}
private:
static int count;
};
int widget::count=0;
int main()
{
//两个对象，都要调用其构造函数，count=2
widget x,y;
//输出（The Num.is 2）
cout<<"The Num.is"<if(widget::num()>1)
{
//再生成三个对象
widget x,y,z;
//输出（The Num.is 5）
cout<<"The Num.is"<//三个对象被析构，调用析购函数
}
//这是count=2
//再生成一个对象count++
widget z;
//输出：（The Num.is 3）
cout<<"The Num.is"<//剩下的3个对象被析构
}

//这道题我觉得应该注意以下几个问题：
//1.直接初始化与拷贝初始化，直接初始化一般形
//式为为 ClassType c()，是直接使用构造函数
//拷贝构造函数看上去像是赋值，其实它是先生成
//一个指定值的零时对象再拷贝到正要生成的对象
//就像main函数的a，b那样
//2.隐式类类型转换，由单个实参的构造函数实现，
//若要抑制它，在该构造函数前加explicit，但这
//里没有这么定义，所以可以转换
//3.这里对操作符进行了重载，如赋值操作符改变
//了它本身的意义，其实它的意义和+=一样了，而
//+操作符的意义和-的一样了，同时还对输出
//操作符进行了重载，但这里和一般的输出是
//没什么意义上的区别的
//4.这里用到了friend，表示这个函数是类的友元
//函数，友元函数可以访问类的私有成员，如这里
//的x
//5.输出操作符一般不作为成员函数

程序四:
#include
class ol_int{
private:
int x;
public:
ol_int(){
x=0;
}
ol_int(int v){
x=v;
}
ol_int&operator=(int i){
x+=i;
return(*this);
}
int operator+(ol_int&o){
return(x-o.x);
}
friend ostream & operator<<(ostream &,const ol_int&);
};

ostream & operator<<(ostream & o,const ol_int&v){
o<return(o);
}
int main(void){
//调用拷贝构造函数，隐式类型转换
ol_int a=5;
//调用拷贝构造函数，隐式类型转换
ol_int b=11;
//调用默认构造函数
ol_int c;
//输出：（A is 5）
cout<<"A is"<//输出：（C is 11）
cout<<"C is"<//+其实是-的操作，=其实是+=，这里先进行-，再进行+=
c=a+b;
//输出：（C is -6）
cout<<"C is"<//=其实是+=的操作
c=6;
//输出：（C is 0 ）
cout<<"C is"<}

程序一:
#include
#include
int x=1; //x为全局变量
void f(int x,int &y)
{
int z;
z=x; //把传入的参数x赋给z
x=y; //把传入的参数y赋给x
y=z; //又把z的值赋给y

cout<<"x="<//输出x的值，setw()是设置输出格式的函数
}
void main()
{
int x=2,y=1;
{
int x=3;
if(x=3) int y=x/2;
if(x=2) int y=x*2;
cout<<"x="<}
f(x,y);
cout<<"x="<cout<<"x="<<::x<//x前面加::是说明它是全局变量
}

程序二:
#include
#include
void main()
{
int x=2,y=2;
11: switch(x)
//11：是用来表明表达式，为goto关键字准备的，不过不推荐用goto
{
case 2:
x%=y++;
//如果x的值为2,就把x%y的值给x,然后y加1
cout<<"x="<case 3:
x=y;
y=++x;
//x等于3的时候，把y赋给x，然后x加1以后赋给y
cout<<"x="<goto 11; //调转到标志的语句11
case 4:
x++;
y--;
//x和y都自加一次
cout<<"x="<case 5:
if(x>5)x++;
if(y<3)y--;
cout<<"x="<default:
x/=y%4;
}
cout<<"x="<}