程序员成长之旅——暑期易错点汇总
1.下列程序运行结果是（4）
int main()
{
int i, j, a = 0;
for (i = 0; i < 2; i++)
{
for (j = 0; j < 4; j++)
{
if (j % 2)
break;
a++;
}
a++;
}
printf("%d\n", a);
}
牢记：for循环中，break是完全结束循环，continue是中指本次循环。
2.宏定义的宏展开是在预处理阶段完成的。
3.& 按位与 | 按位或都是二进制的与和或。
4.test.c文件中包括如下语句：
#define INT_PTR int*//宏定义在编译前进行宏替换
typedef int* int_ptr;//别名
INT_PTR a,b;//int*a,b;
int_ptr c,d;//int* c,* d;
文中中定义的四个变量，那个变量不是指针类型 b
5 .C语言中，函数返回值的类型可以缺省，此时函数返回值的隐含类型是int
6 .以下程序中while循环的循环次数是 无限循环
void main()
{
int i = 0;
while(i < 10)
{
if( i < 1) continue;//跳过本次循环，i永远小于1无限循环
if( i == 5 ) break;
i++;
}
}
7 .下面的程序，输出结果正确的是（0）
int main()
{
int a = 5;
if(a = 0)//给a赋值为0
{
printf("%d",a - 10);
}
else
{
printf("%d",a++);//直接跳这里
}
return 0;
}
8 .include<x.h> 和include"y.h"
" "表示先到源文件所在目录下搜索头文件
< >表示引用的是编译器的类库路径里面的头文件
9 .重载插入运算符<<时，其运算符函数值返回值类型应当是 ostream &
10 .下列程序运行后的输出结果是
#define F(X,Y) ((X)+(Y))
int main()
{
int a = 3, b = 4;
printf("%d\n", F(a++, b++));//3 4
}
11 .执行x=5>1+2&&2||2*4<4-!0后，x的值是（1）
12 x1是从0开始
enum A
{
X1,//0
Y1,//1
Z1 = 5,//5
A1,//6
B1//7
};
enum A enumA = Y1;
enum A enumB = B1;
13.以下程序输出结果是 8 17
int fun(int x, int y)
{
static int m = 0;
static int i = 2;
i += m + 1;
m = i + x + y;
return m;
}
void main()
{
int j = 4;
int m = 1;
int k;
k = fun(j, m);
printf("%d, ", k);
k = fun(j, m);
printf("%d\n", k);
return;
}
m i 是静态局部变量
它的生存周期为整个源程序，但是其作用域仍与自动变量相同，只能在定义该变量的函数内使用该变量。退出函数后，尽管该变量还继续存在，但不能使用它。
每次调用函数时，它们上次所保留的值不会丢失。所以再次调用fun函数时，都是上次调用fun函数时修改的值。
14
int Change(int* px)//形参，出作用域就销毁，对主函数没有影响
{
int y = 8;
y = y - *px;
px = &y;
return 0;
}
int main()
{
int xx = 3;
int* pY = &xx;
Change(pY);//如果传&pY形参用二级指针接收就可以改变
printf("%d\n", *pY);//3
return 0;
}
15.下列错误的语句是
int main()
{
int a = 4, b = 3, *p, *q, * w;
p = &a;
q = &b;
w = q;
q = NULL;
*q = 0;//错误 q是NULL的时候，不能对q进行赋值操作
w = p;
*p = a;
*p = *w;
return 0;
}
16 如下代码结果是多少
int fun(int x)
{
int count = 0;
while (x)
{
count++;
x = x & (x - 1);//找出了规律，二进制是8个1 所以是8次
}
return count;
}
int main()
{
printf("fun(2017)=%d\n", fun(2019));
}
17
#define CIR(r) r*r
void main()
{
int a = 1;
int b = 2;
int t;
t = CIR(a + b);//1+2*1+2 预编译的时候就进行了替换
printf("%d\n", t);
return;
}
18 .int a = 4,则对于表达式++（a++）的结果是什么（D）
A. 5
B.6
C.7
D.以上都不是
自增运算必须针对变量，常量不可以修改，a++返回4 ++4是错误的
19 .式子7*15 = 133成立，则用的是几进制（8）
若是7进制的话不可能存在数字7，排除A
若是8进制，15用十进制表示就是13，7*13 = 91，133用十进制表示的话是91，故选B
20 .已知x >= y and y >= z为真，那么x > z or y == z值为 真
21 .执行以下程序后，x的值是 3
int x = 0;
switch(++x)
{
case 0: ++x;
case 1: ++x;
case 2: ++x;
}
22 . 如下代码的运行结果是 12
char s[] = "\\123456\123456\t";// \\相当于\ \123=S 八进制 \t是tab
printf("%d\n",strlen(s));
23 .（32位机器上）
void Func(char str_arg[2])
{
int m = sizeof(str_arg);//指针的长度 4
int n = strlen(str_arg);//对传过来的数组求长度和2是没有任何关系的
printf("%d %d\n", m, n);
}
int main()
{
char str[] = "Hello";
Func(str);
return 0;
}
24 .p和"Hello,world"存储在内存哪个区域？
#include<stdio.h>
int main()
{
const char *p = "Hello,world";// 栈 只读存储区
return 0;
}
25 .空指针所指向的空间位置就是地址为0的指针
26
int main() {
int a[5] = { 1,2,3,4,5 };
int* p1 = (int*)(&a + 1);
int* p2 = (int*)((int)a + 1);//2000000
int* p3 = (int*)(a + 1);
printf("%d,%x,%d\n", p1[-1], p2[0], p3[1]);//%x是以16进制输出
return 0;
}
27
int main()
{
char acX[] = "abc";//数组可以修改
char acY[] = { 'a','b','c' };//数组可以修改
char* szX = "abc";
char* szY = "abc";
}
acX , acY 是2个数组,属于变量,一般存在栈区,可以修改, szX , szY 是2个指针指向常量区,常量区的东西不能被修改
28 .
int main()
{
char* str[3] = { "stra","strb","strc" };
char* p = str[0];
int i = 0;
while (i < 3)
{
printf("%s ", p++);
i++;
}
return 0;
}
stra tra ra char* p = str[0] 和 char* p = str是不一样的 前者++是str[0][1] 后者是++就变成str[1]
29
char* myString()
{
char buffer[6] = { 0 };
char* s = "Hello World";
for (int i = 0; i < sizeof(buffer) - 1; i++)
{
buffer[i] = *(s + i);
}
return buffer;
}
int main()
{
printf("%s\n", myString());
return 0;
}
没有使用malloc分配内存，所有buffer数组的内存区域在栈区，随着char* mystring()的结束，栈区内存释放。
30
int main()
{
char a[1000];
int i;
for (i = 0; i < 1000; i++)
{
a[i] = (char)(-1 - i);
}
printf("%d\n", strlen(a));
return 0;
}
数值0和字符‘0’不一样，数值0存的和‘\0’一样 0x00
char的范围是-128到127
总共255个
31 下列关于数组和指针的区别描述正确的是 B
A.数组要么在静态存储区被创建（如全局变量），要么在栈上被创建
B.用运算符sizeof可以计算数组的容量
C.指针可以随时指向任意类型的内存块
D.用运算符sizeof可以计算出指针所指向内容的容量
A 还可以在堆上创建动态数组
B sizeof（数组名）
C 指针可以随时指向任意类型的内存块，它的特征是“可变”char * const p 指针常量 则指向的地址不可变
D char* str = “hello” sizeof(str)只是指针的容量
32
int main()
{
unsigned char a = 0xA5;//十六进制
//0 1 2 3 4 5 6 7 8 9 A B C D E F
unsigned char b = ~a >> 4 + 1;//+的优先级高于>>先+后右移
printf("%d\n", b);
return 0;
}
33
const int i = 0;//
int* j = (int*)& i;
*j = 1;
printf("%d,%d", i, *j);// 1 1
const 只是将变量定义为只读，但通过指针还是可以修改它的值的
34 数组的大小不光是在编译下确定，动态开辟空间也可以在运行时确定。
35 在C语言中，若有定义：int a [4][10](其中0<=i<4,0<=j<10);则下列选项中不能表示数组元素a[i][j]值的是
A *(a+i)+j
B *(&a[0][0])+10 * i+j)
C *(a[i]+j)
D *( *(a+i)+j)
A是a[i][j]的地址 (a+i)相当于a[i]表示的是第i行的首地址
D是A再取则是a[i][j]的值
C正确，a[i]为第i行第0个元素的值，加j后为a[i][j]地址，再取就是a[i][j]
B正确，a[0][0]取地址是数组第一个元素的地址，加上10i为第i行第0个元素的地址，在加j是a[i][j]地址，再取*是a[i][j]的值
36
int func()
{
int i, j, k = 0;
for (i = 0, j = -1; j = 0; i++, j++)
//j = 0条件为假不执行为1的话无限循环
{
k++;
}
return k;
}
int main()
{
printf("%d\n", func());
}
37
wb 二进制全新数据
wb+ 不是全新数据
38
ftell()函数用于得到文件指针当前位置相对于文件首地址的偏移字节数
fseek()函数用于设置文件指针的位置
rewind()函数可以使文件指针重新定位到文件读写的首地址
ferror()函数可以用于检查调用输入输出函数时出现的错误
39
int main()
{
int k, j, s;
for (k = 0; k < 6; k++, k++)//两次加一
{
s = 1;
for (j = k; j < 6; j++)
{
s += j;
}
}
printf("%d\n", s);
return 0;
}
40
int arr[] = {6,7,8,9,10};
int* ptr = arr;
*(ptr++) += 123;
//*(ptr++) += 123;相当于 *ptr=*ptr + 123; ptr++;此时ptr应指向第二个元素7
printf("%d,%d",*ptr,*(ptr++));//C语言中printf 计算参数时是从右到左计算的
41
struct student
{
int num;
char name[32];
float score;
}stu;
struct 是结构体类型的关键字
struct student 是用户定义的结构体类型
num，score都是结构体成员
stu是结构体变量而不是用户定义的结构体类型名
42
int main()
{
unsigned int a = 0xfffffff7;
unsigned char i = (unsigned char)a;//小端读出
char* b = (char*)& a;//影响的只是指针的寻址
printf("%08x,%08x", i, *b);//000000f7,fffffff7
//%08x 8位对齐的16进制格式
system("pause");
return 0;
}
43 二维数组中行可以省略，列不能省略
44 switch( c )中的c的数据类型可以是char long float unsigned bool,这种说法是错误的
为啥是错误的，因为它必须是整数，而char相当于ASCll实际也可以
45
int main()
{
char* szStr = "abcdef";
szStr += 2;
printf("%lu\n", szStr);//输出的是地址
return 0;
}
46
int main()
{
int i;
char acNew[20] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
for (i = 0; i < 10; i++)
{
acNew[i] = '0';//字符‘0’相当于ASCll值48
//数字0相当于‘\0’
}
printf("%d\n", strlen(acNew));//10
//
system("pause");
return 0;
}
47
int main()
{
int x = 0, y = 0, z = 0;
z = (x == 1) && (y = 2);//x!=1后面不会在执行
printf("%d", y);//所以y输出还是0
}
48
int main()
{
int i = 10;
long long t = sizeof(i++);
//sizeof是静态运算符，它的结果只在编译时刻就决定了，不要在sizeof的括号里做运算，这些运算不会做的。
printf("%d", i);
}
49 标识符第一个必须是字母或者下划线
50
char ch = -1;
printf("%d\n",ch);
//输出还是-1 因为char的范围是-128到127 有符号 输出是-1
51 表达式(double)(10/4*4)的结果是 8.000000
有()先运算再转类型
printf("%f", (double)(10 / 4 * 4)); %f默认保留6位小数
52 以下不能进行字符串初始化的语句是（A）
很明显会有越界行为
