C语言学习笔记--预编译/宏定义/数组/参数传递/函数指针

目录

预编译

值传递、指针传递、引用传递

数组

typedef 函数指针

---

预编译

预编译又叫预处理。预编译不是编译，而是编译前的处理。这个操作是在正式编译之前由系统自动完成的。#define 和 #include 一样，都是以“#”开头的。凡是以“#”开头的均为预处理指令。

#define 宏定义。其定义一个标识符来表示一个常量。其特点是：定义的标识符不占内存，只是一个临时的符号，预编译后这个符号就不存在了。在头文件的开头，常使用宏定义来防止头文件的重复包含，此时宏定义只有宏值，没有宏名。宏值和宏名是可以分离的。

#define定义常量和const变量的区别。

最大的区别是const 变量依然是变量，是只允许被读的变量。在C语言中，其作为数组长度的定义会报错。这一点在不同的C语言版本和C++中都存在区别。

值传递、指针传递、引用传递

int a = 3, b = 5；int *A = &a;  int *B = &b;

1. 函数申明 f(int a, int b);   函数调用 f(a, b)      // 值传递。

2. 函数申明 f(int *A, int * B);  函数调用 f(&a, &b), f(A, B)    // 指针传递， 实际上传递的还是形参的值，不过这个值是地址。是int变量a, b的地址，也是指针变量A和B的地址。

3. 函数申明 f(int &a, int &b);    函数调用 f(a, b)    // 引用传递 ,   传递的是形参的地址。实参是两个整型变量，但传递的实际是他们地址。引用传递，子函数的调用不会为形参开辟新的内存，对形参的处理等于直接修改实参的值。

数组

数组在C语言中不是基本数据结果。不能直接赋值，不能作为函数类型返回。

尽量使用定长数组。int arr[] = {0}实际是1个元素的定长数组。int arr[0]可以表示不定长数组。

数组名和指针的区别：数组名表示数组的首地址，但是数组名包含了数组除首地址外的其他的信息。当数组作为形参传递时，这一点比较明显。但不管以下那种函数申明方式，当数组名作为实参传递的都是地址。

int a[10] = {0};  int *A = a;

1. 函数申明 sort(int a[10])，sort(int a[]);  函数调用 sort(a);  // 数组作为形参，数组名作为实参。函数的调用传入的实参会当做数组首地址使用。子函数内部对数组的使用，可以不受函数形参数组大小10的限制，函数调用数组长度也不受形参限制。

2. 函数申明 sort(int *A);  函数调度sort(a);  或者 sort(A);    // 此处子函数内部不包含数组信息，为了方便使用，有时候讲函数变形为sort(int *A,  int num), 带上另外一个参数表示数组长度。此种调用方式，数组名a被修改为了一个纯粹的指针。

3. 函数申明 sort(int (&a)[10]);  函数调用 sort(a);  // 引用作为形参，数组名作为实参。子函数sort包括的数组长度信息不会消失。函数调用时必须传入一个长度为10的数组名。这种方式保留了数组的长度信息。因为引用是只用使用的实参地址，没有形参到实参的一个变量类型强制过程。

typedef 函数指针

typedef常用数据类型意义不大，而且容易出现一些错误。但是函数在C语言中不是一种类型，却可以通过typedef来定义一种特定的类型。使函数在C语言中的使用变得灵活，可以作为数组结构体的一个元素等使用。类型定义的语法可以归结为一句话：只要在变量定义前面加上typedef，就成了类型定义。这儿的原本应该是变量的东西，就成为了类型。其核心区别还是变量定义和类型申明的区别。

int integer;     //整型变量
int *pointer;   //整型指针变量
int array [5]; //整型数组变量
int *p_array [5]; //整型指针的数组的变量
int (*array_pointer) [5];//整型数组的指针的变量
int (*function) (int param);//现在就是指向函数的指针了

若要定义相应类型，即为类型来起名字，就是下面的形式：
typedef int integer_t;       //整型类型
typedef int *pointer_t;     //整型指针类型
typedef int array_t [5]; //整型数组类型
typedef int *p_array_t [5];    //整型指针的数组的类型
typedef int (*array_pointer_t) [5]; //整型数组的指针的类型
typedef int (*function_t) (int param); //指向函数的指针的类型

typedef在语法上是一个存储类的关键字（如auto、extern、mutable、static、register等一样），虽然它并不真正影响对象的存储特性。因此typedef不能和其他的存储类关键字同时使用。

typedef后的类型跟其他关键字配合时，跟正常类型会出现区别。

typedef char * pStr; 
char string[4] = "abc"; 
const char *p1 = string;   // p1++是合法的
const pStr p2 = string;  // 此处const修饰的时 p2， p2++是非法的；

typedef & 结构的问题

当用下面的代码定义一个结构时，编译器报了一个错误，为什么呢？莫非C语言不允许在结构中包含指向它自己的指针吗？请你先猜想一下，然后看下文说明：

typedef struct tagNode
{
　char *pItem;
　pNode pNext;
} *pNode;

答案与分析：

1. typedef的最简单使用

   typedef long byte_4;
   //给已知数据类型long起个新名字，叫byte_4。
   

2. typedef与结构结合使用

   typedef struct tagMyStruct
   { 
   　int iNum;
   　long lLength;
   } MyStruct;
   

   这语句实际上完成两个操作：
   1) 定义一个新的结构类型

   struct tagMyStruct
   { 
   　int iNum; 
   　long lLength; 
   };
   

   分析：tagMyStruct称为“tag”，即“标签”，也被称作结构体的本名，struct 关键字和tagMyStruct一起，构成了这个结构类型，不论是否有typedef，这个结构都存在。

   我们可以用struct tagMyStruct varName来定义变量，但要注意，使用tagMyStruct varName来定义变量是不对的，因为struct 和tagMyStruct合在一起才能表示一个结构类型。

   2) typedef为这个新的结构起了一个名字，叫MyStruct。也称作这个结构体类型的别名，表示的是一种类型。

   typedef struct tagMyStruct MyStruct;
   

   因此，MyStruct实际上相当于struct tagMyStruct，我们可以使用MyStruct varName来定义变量。

   C语言当然允许在结构中包含指向它自己的指针，我们可以在建立链表等数据结构的实现上看到无数这样的例子，上述代码的根本问题在于typedef的应用。

   根据我们上面的阐述可以知道：新结构建立的过程中遇到了pNext域的声明，类型是pNode，要知道pNode表示的是类型的新名字，那么在类型本身还没有建立完成的时候，这个类型的新名字也还不存在，也就是说这个时候编译器根本不认识pNode。

   解决这个问题的方法有多种：

   1)、

   typedef struct tagNode 
   {
   　char *pItem;
     struct tagNode *pNext;
   } *pNode;
   

   2)、

   typedef struct tagNode *pNode;
   struct tagNode 
   {
   　char *pItem;
   　pNode pNext;
   };
   

   注意：在这个例子中，你用typedef给一个还未完全声明的类型起新名字。C语言编译器支持这种做法。

利用函数指针实现封装性，得到类似于C++的类，获取面向对象的效果

struct _Data;

typedef  void (*process)(struct _Data* pData);

typedef struct _Data
{
    int value;
    process pProcess;
    
}Data;

    封装性的意义在于，函数和数据是绑在一起的，数据和数据是绑在一起的。这样，我们就可以通过简单的一个结构指针访问到所有的数据，遍历所有的函数。封装性，这是类拥有的属性，当然也是数据结构体拥有的属性。当结构体中即包含了数据，也包含了对数据的操作和使用，则结构体就获得了类拥有的封装性属性。