1.设x、y、z和k都是int型变量,则执行表达式:x=(y=4,z=16,k=32)后,x的值为(32);
? ? ? ? x=(y=4,z=16,k=32),x的值为32
理解逗号运算符在c语言中的工作方式:逗号运算符从左到右执行其操作数,并返回最右边的操作数作为结果
2.?2、对于一个正常运行和正常退出的C程序,程序从main函数第一条可执行语句开始执行,在main函数结束!
3.设x和y均为int型变量,则以下语句:x+=y;y=x-y;x-=y;的功能是:交换x和y中的值;
x+=y? ? ? ? 相当于把x与y的和重新赋值给x
y=x-y? ? ? ?相当于把x-y的值为x赋值给y
x-=y? ? ? ? ?相当于把x-y的值为y赋值给x
所以x与y的值交换!
?4.假定有以下变量定义:? int k=7,x=12;则能使值为3的表达式是:(x%=k)-(k%=5)
1.%=是取模和赋值运算符:先进行取模运算,然后将结果赋值给左边的变量
2.- 是减法运算符
?5.以下程序的输出结果是:12 13
????????????????main( )
{ int a=12,b=12;
printf(“%d %d\n”,a--,++b);
}
a--这是一个后缀递减操作,首先返回a的当前值,然后a的值再减少1
++b这是一个前缀递增操作,首先增加b的值,然后返回增加后的值
?6.设有声明语句“int a=1,b=0;”,则执行以下语句后输出为:**0****2**
?????? switch(a)
?????? {
????????? case? 1:
???????????? switch(b)
?????????????? {case? 0: printf(“**0**”); break;
??????????????? case? 1: printf(“**1**”);break;
??????????????? }
????????? case?? 2: printf(“**2**”);break;
???????? }
首先:我们来看这个嵌套的switch-case结构
外层switch语句判断条件是a
1.当a的值为1时,进入第一个case:1的代码块
? ? ? ? 在这个代码块中,有一个内层的switch语句,其判断条件是b;
? ? ? ? 因此b的值为0,所以执行case 0:的代码块,输出**0**;
此时,由于case 0 :后面有break语句,所以跳出内层的switch语句。
但是,由于外层switch语句的case 1:后面没有break语句,程序会继续执行下一个case,也就是case 2:的代码块,输出**2**;
因此,结果为**0****2**
7.以下程序输出结果是? 6
main( )
{ int m=5;
if(m++>5)printf(“%d\n”,m);
else printf(“%d\n”,m--);}
if(m++>5):这是一个后自增加操作。首先,比较m此时为5是否大于5,然后m自增加1.因此,判断条件为假。
因为条件为佳,所以执行else语句:printf("%d\n",m--); 这是一个后自减操作。首先打印m的值再自减1;
所以输出结果为:6
在C++和许多其他编程语言中,i++
和++i
都是对变量i
进行自增操作,但它们的使用方式和效果略有不同。
i++
: 这是后置自增操作。它首先返回i
的当前值,然后将i
的值加1。例如,如果i
是5,那么执行j = i++
后,j
的值将是5,而i
的值将变为6。++i
: 这是前置自增操作。它首先将i
的值加1,然后返回新的值。例如,如果i
是5,那么执行j = ++i
后,j
的值将是6,而i
的值也将是6。这两种操作在大多数情况下可以互换使用,但它们在某些特定场景下可能会有细微的差别。例如,当与复杂的表达式或函数一起使用时,前置和后置自增操作的顺序可能会影响结果。因此,选择使用前置自增还是后置自增应根据具体的需求和上下文来决定。
8.当执行以下程序段时:循环体将执行一次
????????x=-1;
do { x=x*x;}
while(!x);
循环体执行的次数是由循环条件绝对的:
? ? ? ? 在这个程序中,循环条件是!x,只要这个条件为真,循环就会继续执行。但是在第一次循环迭代中,x的值从-1变为1(x=x*x);然后!x的值为0(假),所以循环终止了,因此,循环体只执行了一次!
9.?在函数调用过程中,如果函数funA中又调用了函数 funA,则:称为函数的直接递归调用
直接调用是指一个函数的函数体中含有调用自身的语句。这种情况下,函数funA在其定义中直接调用了自身!
间接调用是指一个函数在函数体里面有调用了其它函数,而其它函数反过来调用了该函数的情况。在这种情况下,函数funAbing没有在其定义中调用了其它函数,而是直接调用了自身。
直接调用:调用了自身语句
间接调用:调用了其他函数
递归函数:
? ? ? ? 是指一个函数的函数体中直接或间接调用了该函数自身的函数。在上述情况中,由于funA在其定义中直接调用了自身,所以它是一个递归函数。
10、以下程序运行后,输出结果是:8,17
func(int a,int b)
{ static int m=0,i=2;
i+=m+1;
m=i+a+b
return(m);
}
main()
{ int k=4,m=1,p;
p=func(k,m);printf(“%d,”,p);
p=func(k,m);printf(“%d\n”,p);
}
分析:
? ? ? ? 第一个func函数体里面?初始化m为0,i为2;
????????????????i+=m+1相当于i=i+m+1;? ? ? ? i值为3;
????????????????m=i+a+b相当于m=3+a+b;????????
? ? ? ? main函数
????????????????把k=4,m=1,值传给func函数
? ? ? ? 第一个p为:
? ? ? ? ? ? ? ? i=i+m+1=2+0+1;??
? ? ? ? ? ? ? ? m=i+a+b=3+4+1=8
? ? ? ? 第二个p为:
? ? ? ? ? ? ? ?i=i+m+1=3+8+1=12
? ? ? ? ? ? ? ?m=i+a+b=12+4+1=17
? ? ? ?
`static` 是C、C++、Java、C#等许多编程语言中的一个关键字,它具有多种用途。以下是`static`的一些主要含义和用途:
1. **静态变量**:当一个变量前有`static`关键字时,这意味着这个变量的生命周期是整个程序的执行期间,而不是它所在的代码块。此外,静态变量只会被初始化一次,且其值在程序的整个生命周期中保持不变。
static int x = 0; ?// 只在程序开始时初始化一次
2. **静态方法**:当一个方法前有`static`关键字时,这意味着这个方法不需要类的实例就可以调用。静态方法只能访问静态变量或其他静态方法。
static void myStaticMethod() {
?
}
3. **静态类**:在C#中,整个类都可以被声明为`static`。这样的类不能被实例化,并且只能包含静态成员。
public static class MyStaticClass {
}
4. **静态成员的访问**:静态成员可以通过类名直接访问,而不需要创建类的实例。
MyClass.myStaticMethod(); ?// 访问静态方法
5. **局部变量**:在C和C++中,`static`关键字也可以用于局部变量,这意味着这个变量的生命周期是整个程序执行期间,而不是它所在的代码块。这与全局变量类似,但它的作用范围被限制在其声明所在的代码块内。
6. **其他用途**:在C++中,`static`还可以用于声明静态指针、静态数组等。在Java中,它可以用于声明静态块等。理解并正确使用`static`关键字对于编写高效的、可维护的代码是非常重要的。但也要注意,过度使用或不恰当使用`static`可能会导致代码难以理解和维护。