C语言常见问题

最新推荐文章于 2025-02-04 16:30:56 发布

好大一只鸡

最新推荐文章于 2025-02-04 16:30:56 发布

阅读量1.5k

点赞数

分类专栏： C/C++

本文链接：https://blog.csdn.net/stwuyiyu/article/details/90513534

版权

C/C++ 专栏收录该内容

4 篇文章

订阅专栏

1.宏只是替换,不参与计算

【示例①】用函数计算平方值。

#include <stdio.h>
int SQ(int y){
  return ((y)*(y));
}

int main(){
  int i=1;
  while(i<=5){
    printf("%d^2 = %d\n", (i-1), SQ(i++));
  }
  return 0;
}

运行结果：
1^2 = 1
2^2 = 4
3^2 = 9
4^2 = 16
5^2 = 25
【示例②】用宏计算平方值。

#include <stdio.h>
#define SQ(y) ((y)*(y))

int main(){
  int i=1;
  while(i<=5){
    printf("%d^2 = %d\n", i, SQ(i++));
  }
  return 0;
}

在 VS2010 和 C-Free 5.0 下的运行结果：
3^2 = 1
5^2 = 9
7^2 = 25
区别说明:
在示例①中，先把实参 i 传递给形参 y，然后再自增 1，这样每循环一次 i 的值增加 1，所以最终要循环 5 次。
在示例②中，宏调用只是简单的字符串替换，SQ(i++) 会被替换为 ((i++)*(i++))，这样每循环一次 i 的值增加 2，所以最终只循环 3 次。
由此可见，宏和函数只是在形式上相似，本质上是完全不同的。

2.const 和指针

const 也可以和指针变量一起使用，这样可以限制指针变量本身，也可以限制指针指向的数据。const 和指针一起使用会有几种不同的顺序，如下所示：

const int *p1;
int const *p2;

p1、p2 本身的值可以修改（指向不同的数据），但它们指向的数据不能被修改。

int * const p3;

指针是只读的，也就是 p3 本身的值不能被修改；
在最后一种情况下，在前面两种情况下，指针所指向的数据是只读的

当然，指针本身和它指向的数据都有可能是只读的，下面的两种写法能够做到这一点：

const int * const p4;
int const * const p5;

const 和指针结合的写法多少有点让初学者摸不着头脑，大家可以这样来记忆：const 在前面表示指针指向的内容是只读的,但指针可以变,可以指向不同地址，在后面表示指针的值不可变

const 和函数形参
在C语言中，单独定义 const 变量没有明显的优势，完全可以使用#define命令代替。const 通常用在函数形参中，如果形参是一个指针，为了防止在函数内部修改指针指向的数据，就可以用 const 来限制。

3.typedef

typedef 还可以给数组、指针、结构体等类型定义别名。先来看一个给数组类型定义别名的例子：

typedef char ARRAY[20];

表示 ARRAY 是类型char [20]的别名。
它是一个长度为 20 的数组类型。接着可以用 ARRAY 定义数组：
ARRAY a1, a2, s1, s2;
它等价于：
char a1[20], a2[20], s1[20], s2[20];

注意，数组也是有类型的。例如char a1[20];定义了一个数组 a1，它的类型就是 char [20]。

又如，为结构体类型定义别名：

typedef struct stu{
char name[20];
int age;
char sex;
} STU;

STU 是 struct stu 的别名，可以用 STU 定义结构体变量：
STU body1,body2;
它等价于：
struct stu body1, body2;

再如，为指针类型定义别名：

typedef int (*PTR_TO_ARR)[4];

表示 PTR_TO_ARR 是类型int * [4]的别名，它是一个二维数组指针类型。接着可以使用 PTR_TO_ARR 定义二维数组指针：
PTR_TO_ARR p1, p2;

按照类似的写法，还可以为函数指针类型定义别名：

typedef int (*PTR_TO_FUNC)(int, int);
PTR_TO_FUNC pfunc;

typedef 和 #define 的区别
typedef 在表现上有时候类似于 #define，但它和宏替换之间存在一个关键性的区别。正确思考这个问题的方法就是把 typedef 看成一种彻底的“封装”类型，声明之后不能再往里面增加别的东西。

可以使用其他类型说明符对宏类型名进行扩展，但对 typedef 所定义的类型名却不能这样做。如下所示：

#define INTERGE int
unsigned INTERGE n; //没问题
typedef int INTERGE;
unsigned INTERGE n; //错误，不能在 INTERGE 前面添加 unsigned

在连续定义几个变量的时候，typedef 能够保证定义的所有变量均为同一类型，而 #define 则无法保证。例如：

#define PTR_INT int *
PTR_INT p1, p2;

经过宏替换以后，第二行变为：
int *p1, p2;
这使得 p1、p2 成为不同的类型：p1 是指向 int 类型的指针，p2 是 int 类型。
相反，在下面的代码中：

typedef int * PTR_INT
PTR_INT p1, p2;

p1、p2 类型相同，它们都是指向 int 类型的指针。

4.位域的数据结构

有些数据在存储时并不需要占用一个完整的字节，只需要占用一个或几个二进制位即可。例如开关只有通电和断电两种状态，用 0 和 1 表示足以，也就是用一个二进位。正是基于这种考虑，C语言又提供了一种叫做位域的数据结构。
在结构体定义时，我们可以指定某个成员变量所占用的二进制位数（Bit），这就是位域。请看下面的例子：

struct bs{
unsigned m;
unsigned n: 4;
unsigned char ch: 6;
}

:后面的数字用来限定成员变量占用的位数。成员 m 没有限制，根据数据类型即可推算出它占用 4 个字节（Byte）的内存。成员 n、ch 被:后面的数字限制，不能再根据数据类型计算长度，它们分别占用 4、6 位（Bit）的内存。
C语言标准规定，位域的宽度不能超过它所依附的数据类型的长度。通俗地讲，成员变量都是有类型的，这个类型限制了成员变量的最大长度，:后面的数字不能超过这个长度。

例如上面的 bs，n 的类型是 unsigned int，长度为 4 个字节，共计 32 位，那么 n 后面的数字就不能超过 32；ch 的类型是 unsigned char，长度为 1 个字节，共计 8 位，那么 ch 后面的数字就不能超过 8。

我们可以这样认为，位域技术就是在成员变量所占用的内存中选出一部分位宽来存储数据。

C语言标准还规定，只有有限的几种数据类型可以用于位域。在 ANSI C 中，这几种数据类型是 int、signed int 和 unsigned int（int 默认就是 signed int）；到了 C99，_Bool 也被支持了。

5.文件读写

#include<stdio.h>
#define N 3
struct stu{
    char name[10]; //姓名
    int num;  //学号
    int age;  //年龄
    float score;  //成绩
}boys[N], boy, *pboys;

int main(){
    FILE *fp;
    int i;
    pboys = boys;
    if( (fp=fopen("d:\\demo.txt", "wb+")) == NULL ){
        printf("Cannot open file, press any key to exit!\n");
        getch();
        exit(1);
    }

    printf("Input data:\n");
    for(i=0; i<N; i++,pboys++){
        scanf("%s %d %d %f", pboys->name, &pboys->num, &pboys->age, &pboys->score);
    }
    
    fwrite(boys, sizeof(struct stu), N, fp);  //写入三条学生信息
    fseek(fp, sizeof(struct stu), SEEK_SET);  //移动位置指针
    fread(&boy, sizeof(struct stu), 1, fp);  //读取一条学生信息
    printf("%s  %d  %d %f\n", boy.name, boy.num, boy.age, boy.score);

    fclose(fp);
    return 0;
}

fopen() 函数用来打开一个文件，
它的原型为：FILE *fopen(char *filename, char *mode);

filename为文件名（包括文件路径），mode为打开方式，它们都是字符串。fopen() 会获取文件信息，包括文件名、文件状态、当前读写位置等，并将这些信息保存到一个FILE类型的结构体变量中，然后将该变量的地址返回。
FILE是在stdio.h头文件中定义的一个结构体，用来保存文件信息。

如果希望接收 fopen() 的返回值，就需要定义一个 FILE 类型的指针。
例如：
FILE fp = fopen(“demo.txt”, “r”);*

对EOF的说明
EOF 本来表示文件末尾，意味着读取结束，但是很多函数在读取出错时也返回 EOF，那么当返回EOF时，到底是文件读取完毕了还是读取出错了？我们可以借助 stdio.h 中的两个函数来判断，分别是 feof() 和 ferror()。

feof() 函数用来判断文件内部指针是否指向了文件末尾，它的原型是：
int feof ( FILE * fp );
当指向文件末尾时返回非零值，否则返回零值。

ferror() 函数用来判断文件操作是否出错，它的原型是：
int ferror ( FILE *fp );
出错时返回非零值，否则返回零值。

fread() 函数用来从指定文件中读取块数据。所谓块数据，也就是若干个字节的数据，可以是一个字符，可以是一个字符串，可以是多行数据，并没有什么限制。fread() 的原型为：
size_t fread ( void *ptr, size_t size, size_t count, FILE *fp );
fwrite() 函数用来向文件中写入块数据，它的原型为：
size_t fwrite ( void * ptr, size_t size, size_t count, FILE *fp );

对参数的说明：
ptr 为内存区块的指针，它可以是数组、变量、结构体等。fread() 中的 ptr 用来存放读取到的数据，fwrite() 中的 ptr 用来存放要写入的数据。
size：表示每个数据块的字节数。
count：表示要读写的数据块的块数。
fp：表示文件指针。
理论上，每次读写 size*count 个字节的数据。

文件定位函数rewind和fseek
移动文件内部位置指针的函数主要有两个，即 rewind() 和 fseek()。

rewind() 用来将位置指针移动到文件开头，前面已经多次使用过，它的原型为：
void rewind ( FILE *fp );
fseek() 用来将位置指针移动到任意位置，它的原型为：
int fseek ( FILE *fp, long offset, int origin );
参数说明：

fp 为文件指针，也就是被移动的文件。
offset 为偏移量，也就是要移动的字节数。之所以为 long 类型，是希望移动的范围更大，能处理的文件更大。
origin 为起始位置，也就是从何处开始计算偏移量。C语言规定的起始位置有三种，分别为文件开头、当前位置和文件末尾，每个位置都用对应的常量来表示：
起始点常量名常量值
文件开头 SEEK_SET 0
当前位置 SEEK_CUR 1
文件末尾 SEEK_END 2
例如，把位置指针移动到离文件开头100个字节处：
fseek(fp, 100, 0);
值得说明的是，fseek() 一般用于二进制文件，在文本文件中由于要进行转换，计算的位置有时会出错。
文件的随机读写
在移动位置指针之后，就可以用前面介绍的任何一种读写函数进行读写了。由于是二进制文件，因此常用 fread() 和 fwrite() 读写。

6.头文件重复定义的处理

昨天下午将全局变量定义在H文件中导致链接时提示变量在多个obj文件内重复。
解决办法如下：
将变量移入C文件中进行定义，然后在H文件中加入extern在变量之前。
这样当其它C文件引用该全局变量时就会去链接这个变量符号而不是重新生成。

另附防止H文件被重复包含的处理方法：
#ifndef H文件名_H
#define H文件名_H
//H文件内容
#endif

个关键字真的比较可恶，在定义（函数）的时候，这个extern居然可以被省略，所以会让你搞不清楚到底是声明还是定义，下面分变量和函数两类来说：
尤其是对于变量来说。

extern int a;//声明一个全局变量a
int a; //定义一个全局变量a
extern int a =0 ;//定义一个全局变量a 并给初值。一旦给予赋值，一定是定义，定义才会分配存储空间。
int a =0;//定义一个全局变量a,并给初值，声明之后你不能直接使用这个变量，需要定义之后才能使用。

第四个等于第三个，都是定义一个可以被外部使用的全局变量，并给初值。
糊涂了吧，他们看上去可真像。但是定义只能出现在一处。也就是说，不管是int a;还是int a=0;都只能出现一次，而那个extern int a可以出现很多次。
当你要引用一个全局变量的时候，你就要声明extern int a;这时候extern不能省略，因为省略了，就变成int a;这是一个定义，不是声明。

7.函数指针

定义形式为：

returnType (*pointerName)(param list);

returnType 为函数返回值类型，pointerNmae 为指针名称，param list 为函数参数列表。参数列表中可以同时给出参数的类型和名称，也可以只给出参数的类型，省略参数的名称，这一点和函数原型非常类似。

注意( )的优先级高于*，第一个括号不能省略，如果写作returnType *pointerName(param list);就成了函数原型，它表明函数的返回值类型为returnType *。

8.一种更好的声明与定义方式

test.h内容

#ifndef _TEST_H
  #define _TEST_H
  #ifdef GLOBALS
    int count;
  #else
    extern int count; 
  #endif 
#endif

test.c内容

#define GLOBALS
#include <stdio.h>
#include "test.h"
extern void Fis_Cal(void);
void main(void)
{
   Fis_Cal();
   printf("the present value of count is %d\n",count);
}

first.c内容

#include <stdio.h>
#include "test.h"
void Fis_Cal(void)
{
   printf("the last value of count is %d\n",count);
   count = 1;
}

说明：
这种方法可以只定义一个头文件实现在不同C文件中分别实现定义与声明。
“#define GLOBALS”只在当前定义的test.c文件中有效，所以在test.c中#include “test.h"预处理后，加入的是int count，而first.c中加入的"extern int count;”。
其实还有一种书写方法，也能实现这个效果。

test.h内容

#ifndef _TEST_H
  #define _TEST_H
   #ifdef GLOBALS
   #define EXT
   #else
   #define EXT extern
#endif

EXT int count;
#endif 。