C语言笔记 08_函数指针&回调函数&字符串&结构体&位域
函数指针
函数指针是指向函数的指针变量。
通常我们说的指针变量是指向一个整型、字符型或数组等变量，而函数指针是指向函数。
函数指针可以像一般函数一样，用于调用函数、传递参数。
函数指针变量的声明：
// 声明一个指向同样参数、返回值的函数指针类型 typedef int (*fun_ptr)(int,int);
以下实例声明了函数指针变量 p，指向函数 max：
#include <stdio.h>
int max(int x, int y)
{
return x > y ? x : y;
}
int main(void)
{
/* p 是函数指针 */
int (* p)(int, int) = & max; // &可以省略
int a, b, c, d;
printf("请输入三个数字:");
scanf("%d %d %d", & a, & b, & c);
/* 与直接调用函数等价，d = max(max(a, b), c) */
d = p(p(a, b), c);
printf("最大的数字是: %d\n", d);
return 0;
}
编译执行，输出结果如下：
请输入三个数字:1 2 3
最大的数字是: 3
回调函数
函数指针作为某个函数的参数
函数指针变量可以作为某个函数的参数来使用的，回调函数就是一个通过函数指针调用的函数。
简单讲：回调函数是由别人的函数执行时调用你实现的函数。
以下是来自知乎作者常溪玲的解说：
你到一个商店买东西，刚好你要的东西没有货，于是你在店员那里留下了你的电话，过了几天店里有货了，店员就打了你的电话，然后你接到电话后就到店里去取了货。在这个例子里，你的电话号码就叫回调函数，你把电话留给店员就叫登记回调函数，店里后来有货了叫做触发了回调关联的事件，店员给你打电话叫做调用回调函数，你到店里去取货叫做响应回调事件。
实例
实例中 populate_array 函数定义了三个参数，其中第三个参数是函数的指针，通过该函数来设置数组的值。
实例中我们定义了回调函数 getnextrandomvalue，它返回一个随机值，它作为一个函数指针传递给 populate_array 函数。
populate_array 将调用 10 次回调函数，并将回调函数的返回值赋值给数组。
注意：size_t 是一种数据类型，近似于无符号整型，但容量范围一般大于 int 和 unsigned。这里使用 size_t 是为了保证 arraysize 变量能够有足够大的容量来储存可能大的数组个数值。
#include <stdlib.h>
#include <stdio.h>
// 回调函数
void populate_array(int *array, size_t arraysize, int (*getnextvalue)(void))
{
for (size_t i=0; i<arraysize; i++)
array[i] = getnextvalue();
}
// 获取随机值
int getnextrandomvalue(void)
{
return rand();
}
int main(void)
{
int myarray[10];
populate_array(myarray, 10, getnextrandomvalue);
for(int i = 0; i < 10; i++) {
printf("%d ", myarray[i]);
}
printf("\n");
return 0;
}
编译执行，输出结果如下：
16807 282475249 1622650073 984943658 1144108930 470211272 101027544 1457850878 1458777923 2007237709
字符串
在 c 语言中，字符串实际上是使用 null 字符 '\0' 终止的一维字符数组。因此，一个以 null 结尾的字符串，包含了组成字符串的字符。
下面的声明和初始化创建了一个 "hello" 字符串。由于在数组的末尾存储了空字符，所以字符数组的大小比单词 "hello" 的字符数多一个。
char greeting[6] = {'h', 'e', 'l', 'l', 'o', '\0'};
依据数组初始化规则，您可以把上面的语句写成以下语句：
char greeting[] = "hello";
以下是 c/c++ 中定义的字符串的内存表示：
其实，不需要把 null 字符放在字符串常量的末尾。c 编译器会在初始化数组时，自动把 '\0' 放在字符串的末尾。让我们尝试输出上面的字符串：
#include <stdio.h>
int main ()
{
char greeting[6] = {'h', 'e', 'l', 'l', 'o', '\0'};
printf("greeting message: %s\n", greeting );
return 0;
}
当上面的代码被编译和执行时，它会产生下列结果：
greeting message: hello
操作字符串的函数
| 序号 | 函数 & 目的 |
|---|---|
| 1 | strcpy(s1, s2); 复制字符串 s2 到字符串 s1。 |
| 2 | strcat(s1, s2); 连接字符串 s2 到字符串 s1 的末尾。 |
| 3 | strlen(s1); 返回字符串 s1 的长度。 |
| 4 | strcmp(s1, s2); 如果 s1 和 s2 是相同的，则返回 0；如果 s1<s2 则返回小于 0；如果 s1>s2 则返回大于 0。 |
| 5 | strchr(s1, ch); 返回一个指针，指向字符串 s1 中字符 ch 的第一次出现的位置。 |
| 6 | strstr(s1, s2); 返回一个指针，指向字符串 s1 中字符串 s2 的第一次出现的位置。 |
下面的实例使用了上述的一些函数：
#include <stdio.h>
#include <string.h>
int main ()
{
char str1[12] = "hello";
char str2[12] = "world";
char str3[12];
int len ;
/* 复制 str1 到 str3 */
strcpy(str3, str1);
printf("strcpy( str3, str1) : %s\n", str3 );
/* 连接 str1 和 str2 */
strcat( str1, str2);
printf("strcat( str1, str2): %s\n", str1 );
/* 连接后，str1 的总长度 */
len = strlen(str1);
printf("strlen(str1) : %d\n", len );
return 0;
}
当上面的代码被编译和执行时，它会产生下列结果：
strcpy( str3, str1) : hello
strcat( str1, str2): helloworld
strlen(str1) : 10
c 标准库中还有更多字符串相关的函数。
结构体
结构是 c 编程中一种用户自定义的可用的数据类型，它允许您存储不同类型的数据项。结构用于表示一条记录。
定义结构
为了定义结构，您必须使用 struct 语句。struct 语句定义了一个包含多个成员的新的数据类型，struct 语句的格式如下：
struct tag {
member-list
member-list
member-list
...
} variable-list ;
tag 是结构体标签。
member-list 是标准的变量定义，比如 int i; 或者 float f，或者其他有效的变量定义。
variable-list 结构变量，定义在结构的末尾，最后一个分号之前，您可以指定一个或多个结构变量。下面是声明 book 结构的方式：
struct books
{
char title[50];
char author[50];
char subject[100];
int book_id;
} book;
在一般情况下，tag、member-list、variable-list 这 3 部分至少要出现 2 个。以下为实例：
//此声明声明了拥有3个成员的结构体，分别为整型的a，字符型的b和双精度的c
//同时又声明了结构体变量s1
//这个结构体并没有标明其标签
struct
{
int a;
char b;
double c;
} s1;
//此声明声明了拥有3个成员的结构体，分别为整型的a，字符型的b和双精度的c
//结构体的标签被命名为simple,没有声明变量
struct simple
{
int a;
char b;
double c;
};
//用simple标签的结构体，另外声明了变量t1、t2、t3
struct simple t1, t2[20], *t3;
//也可以用typedef创建新类型
typedef struct
{
int a;
char b;
double c;
} simple2;
//现在可以用simple2作为类型声明新的结构体变量
simple2 u1, u2[20], *u3;
在上面的声明中，第一个和第二声明被编译器当作两个完全不同的类型，即使他们的成员列表是一样的。
结构体的成员可以包含其他结构体，也可以包含指向自己结构体类型的指针，而通常这种指针的应用是为了实现一些更高级的数据结构如链表和树等。
//此结构体的声明包含了其他的结构体
struct complex
{
char string[100];
struct simple a;
};
//此结构体的声明包含了指向自己类型的指针
struct node
{
char string[100];
struct node *next_node;
};
如果两个结构体互相包含，则需要对其中一个结构体进行不完整声明，如下所示：
struct b; //对结构体b进行不完整声明
//结构体a中包含指向结构体b的指针
struct a
{
struct b *partner;
//other members;
};
//结构体b中包含指向结构体a的指针，在a声明完后，b也随之进行声明
struct b
{
struct a *partner;
//other members;
};
结构体变量的初始化
和其它类型变量一样，对结构体变量可以在定义时指定初始值。
#include <stdio.h>
struct books
{
char title[50];
char author[50];
char subject[100];
int book_id;
} book = {"c 语言", "runoob", "编程语言", 123456};
int main()
{
printf("title : %s\nauthor: %s\nsubject: %s\nbook_id: %d\n", book.title, book.author, book.subject, book.book_id);
}
执行输出结果为：
title : c 语言
author: runoob
subject: 编程语言
book_id: 123456
访问结构成员
为了访问结构的成员，我们使用成员访问运算符（.）。成员访问运算符是结构变量名称和我们要访问的结构成员之间的一个句号。您可以使用 struct 关键字来定义结构类型的变量。下面的实例演示了结构的用法：
#include <stdio.h>
#include <string.h>
struct books
{
char title[50];
char author[50];
char subject[100];
int book_id;
};
int main( )
{
struct books book1; /* 声明 book1，类型为 books */
struct books book2; /* 声明 book2，类型为 books */
/* book1 详述 */
strcpy( book1.title, "c programming");
strcpy( book1.author, "nuha ali");
strcpy( book1.subject, "c programming tutorial");
book1.book_id = 6495407;
/* book2 详述 */
strcpy( book2.title, "telecom billing");
strcpy( book2.author, "zara ali");
strcpy( book2.subject, "telecom billing tutorial");
book2.book_id = 6495700;
/* 输出 book1 信息 */
printf( "book 1 title : %s\n", book1.title);
printf( "book 1 author : %s\n", book1.author);
printf( "book 1 subject : %s\n", book1.subject);
printf( "book 1 book_id : %d\n", book1.book_id);
/* 输出 book2 信息 */
printf( "book 2 title : %s\n", book2.title);
printf( "book 2 author : %s\n", book2.author);
printf( "book 2 subject : %s\n", book2.subject);
printf( "book 2 book_id : %d\n", book2.book_id);
return 0;
}
当上面的代码被编译和执行时，它会产生下列结果：
book 1 title : c programming
book 1 author : nuha ali
book 1 subject : c programming tutorial
book 1 book_id : 6495407book 2 title : telecom billing
book 2 author : zara ali
book 2 subject : telecom billing tutorial
book 2 book_id : 6495700
结构作为函数参数
您可以把结构作为函数参数，传参方式与其他类型的变量或指针类似。
#include <stdio.h>
#include <string.h>
struct books
{
char title[50];
char author[50];
char subject[100];
int book_id;
};
/* 函数声明 */
void printbook( struct books book );
int main( )
{
struct books book1; /* 声明 book1，类型为 books */
struct books book2; /* 声明 book2，类型为 books */
/* book1 详述 */
strcpy( book1.title, "c programming");
strcpy( book1.author, "nuha ali");
strcpy( book1.subject, "c programming tutorial");
book1.book_id = 6495407;
/* book2 详述 */
strcpy( book2.title, "telecom billing");
strcpy( book2.author, "zara ali");
strcpy( book2.subject, "telecom billing tutorial");
book2.book_id = 6495700;
/* 输出 book1 信息 */
printbook( book1 );
/* 输出 book2 信息 */
printbook( book2 );
return 0;
}
void printbook( struct books book )
{
printf( "book title : %s\n", book.title);
printf( "book author : %s\n", book.author);
printf( "book subject : %s\n", book.subject);
printf( "book book_id : %d\n", book.book_id);
}
当上面的代码被编译和执行时，它会产生下列结果：
book title : c programming
book author : nuha ali
book subject : c programming tutorial
book book_id : 6495407book title : telecom billing
book author : zara ali
book subject : telecom billing tutorial
book book_id : 6495700
指向结构的指针
您可以定义指向结构的指针，方式与定义指向其他类型变量的指针相似，如下所示：
struct books *struct_pointer;
现在，您可以在上述定义的指针变量中存储结构变量的地址。为了查找结构变量的地址，请把 & 运算符放在结构名称的前面，如下所示：
struct_pointer = &book1;
为了使用指向该结构的指针访问结构的成员，您必须使用 -> 运算符，如下所示：
struct_pointer->title;
让我们使用结构指针来重写上面的实例，这将有助于理解结构指针的概念：
#include <stdio.h>
#include <string.h>
struct books
{
char title[50];
char author[50];
char subject[100];
int book_id;
};
/* 函数声明 */
void printbook( struct books *book );
int main( )
{
struct books book1; /* 声明 book1，类型为 books */
struct books book2; /* 声明 book2，类型为 books */
/* book1 详述 */
strcpy( book1.title, "c programming");
strcpy( book1.author, "nuha ali");
strcpy( book1.subject, "c programming tutorial");
book1.book_id = 6495407;
/* book2 详述 */
strcpy( book2.title, "telecom billing");
strcpy( book2.author, "zara ali");
strcpy( book2.subject, "telecom billing tutorial");
book2.book_id = 6495700;
/* 通过传 book1 的地址来输出 book1 信息 */
printbook( &book1 );
/* 通过传 book2 的地址来输出 book2 信息 */
printbook( &book2 );
return 0;
}
void printbook( struct books *book )
{
printf( "book title : %s\n", book->title);
printf( "book author : %s\n", book->author);
printf( "book subject : %s\n", book->subject);
printf( "book book_id : %d\n", book->book_id);
}
当上面的代码被编译和执行时，它会产生下列结果：
book title : c programming
book author : nuha ali
book subject : c programming tutorial
book book_id : 6495407book title : telecom billing
book author : zara ali
book subject : telecom billing tutorial
book book_id : 6495700
位域
有些信息在存储时，并不需要占用一个完整的字节，而只需占几个或一个二进制位。例如在存放一个开关量时，只有 0 和 1 两种状态，用 1 位二进位即可。为了节省存储空间，并使处理简便，c 语言又提供了一种数据结构，称为"位域"或"位段"。
所谓"位域"是把一个字节中的二进位划分为几个不同的区域，并说明每个区域的位数。每个域有一个域名，允许在程序中按域名进行操作。这样就可以把几个不同的对象用一个字节的二进制位域来表示。
典型的实例：
- 用 1 位二进位存放一个开关量时，只有 0 和 1 两种状态。
- 读取外部文件格式——可以读取非标准的文件格式。例如：9 位的整数。
位域的定义和位域变量的说明
位域定义与结构定义相仿，其形式为：
struct 位域结构名
{
位域列表
};
其中位域列表的形式为：
类型说明符 位域名: 位域长度
例如：
struct bs{
int a:8;
int b:2;
int c:6;
}data;
说明 data 为 bs 变量，共占两个字节。其中位域 a 占 8 位，位域 b 占 2 位，位域 c 占 6 位。
1字节=1b=8个二进制位
让我们再来看一个实例：
struct packed_struct {
unsigned int f1:1;
unsigned int f2:1;
unsigned int f3:1;
unsigned int f4:1;
unsigned int type:4;
unsigned int my_int:9;
} pack;
在这里，packed_struct 包含了 6 个成员：四个 1 位的标识符 f1..f4、一个 4 位的 type 和一个 9 位的 my_int。
对于位域的定义尚有以下几点说明：
-
一个位域存储在同一个字节中，如一个字节所剩空间不够存放另一位域时，则会从下一单元起存放该位域。也可以有意使某位域从下一单元开始。例如：
struct bs{ unsigned a:4; unsigned :4; /* 空域 */ unsigned b:4; /* 从下一单元开始存放 */ unsigned c:4 }在这个位域定义中，a 占第一字节的 4 位，后 4 位填 0 表示不使用，b 从第二字节开始，占用 4 位，c 占用 4 位。
由于位域不允许跨两个字节，因此位域的长度不能大于一个字节的长度，也就是说不能超过8位二进位。如果最大长度大于计算机的整数字长，一些编译器可能会允许域的内存重叠，另外一些编译器可能会把大于一个域的部分存储在下一个字中。
-
位域可以是无名位域，这时它只用来作填充或调整位置。无名的位域是不能使用的。例如：
struct k{ int a:1; int :2; /* 该 2 位不能使用 */ int b:3; int c:2; };
从以上分析可以看出，位域在本质上就是一种结构类型，不过其成员是按二进位分配的。
实例
如果程序的结构中包含多个开关量，只有 true/false 变量，如下：
struct
{
unsigned int widthvalidated;
unsigned int heightvalidated;
} status;
这种结构需要 8 字节的内存空间，但在实际上，在每个变量中，我们只存储 0 或 1。上面的结构可以重写成：
struct
{
unsigned int widthvalidated : 1;
unsigned int heightvalidated : 1;
} status;
现在，上面的结构中，status 变量将占用 4 个字节的内存空间，但是只有 2 位被用来存储值。如果您用了 32 个变量，每一个变量宽度为 1 位，那么 status 结构将使用 4 个字节，但只要您再多用一个变量，如果使用了 33 个变量，那么它将分配内存的下一段来存储第 33 个变量，这个时候就开始使用 8 个字节。让我们看看下面的实例来理解这个概念：
#include <stdio.h>
#include <string.h>
/* 定义简单的结构 */
struct
{
unsigned int widthvalidated;
unsigned int heightvalidated;
} status1;
/* 定义位域结构 */
struct
{
unsigned int widthvalidated : 1;
unsigned int heightvalidated : 1;
} status2;
int main( )
{
printf( "memory size occupied by status1 : %d\n", sizeof(status1));
printf( "memory size occupied by status2 : %d\n", sizeof(status2));
return 0;
}
当上面的代码被编译和执行时，它会产生下列结果：
memory size occupied by status1 : 8
memory size occupied by status2 : 4
位域声明
在结构内声明位域的形式如下：
struct
{
type [member_name] : width ;
};
下面是有关位域中变量元素的描述：
| 元素 | 描述 |
|---|---|
| type | 只能为 int(整型)，unsigned int(无符号整型)，signed int(有符号整型) 三种类型，决定了如何解释位域的值。 |
| member_name | 位域的名称。 |
| width | 位域中位的数量。宽度必须小于或等于指定类型的位宽度。 |
带有预定义宽度的变量被称为位域。位域可以存储多于 1 位的数，例如，需要一个变量来存储从 0 到 7 的值，您可以定义一个宽度为 3 位（2进制位）的位域，如下：
struct
{
unsigned int age : 3;
} age;
上面的结构定义指示 c 编译器，age 变量将只使用 3 位来存储这个值，如果您试图使用超过 3 位，则无法完成。让我们来看下面的实例：
#include <stdio.h>
#include <string.h>
struct
{
unsigned int age : 3;
} age;
int main( )
{
age.age = 4;
printf( "sizeof( age ) : %d\n", sizeof(age) );
printf( "age.age : %d\n", age.age );
age.age = 7;
printf( "age.age : %d\n", age.age );
age.age = 8; // 二进制表示为 1000 有四位，超出
printf( "age.age : %d\n", age.age );
return 0;
}
当上面的代码被编译时，它会带有警告，当上面的代码被执行时，它会产生下列结果：
sizeof( age ) : 4
age.age : 4
age.age : 7
age.age : 0
位域的使用
位域的使用和结构成员的使用相同，其一般形式为：
位域变量名.位域名 位域变量名->位域名
位域允许用各种格式输出。
请看下面的实例：
#include <stdio.h>
int main(){
struct bs{
unsigned a:1;
unsigned b:3;
unsigned c:4;
} bit,*pbit;
bit.a=1; /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */
bit.b=7; /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */
bit.c=15; /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */
printf("%d,%d,%d\n",bit.a,bit.b,bit.c); /* 以整型量格式输出三个域的内容 */
pbit=&bit; /* 把位域变量 bit 的地址送给指针变量 pbit */
pbit->a=0; /* 用指针方式给位域 a 重新赋值，赋为 0 */
pbit->b&=3; /* 使用了复合的位运算符 "&="，相当于：pbit->b=pbit->b&3，位域 b 中原有值为 7，与 3 作按位与运算的结果为 3（111&011=011，十进制值为 3） */
pbit->c|=1; /* 使用了复合位运算符"|="，相当于：pbit->c=pbit->c|1，其结果为 15 */
printf("%d,%d,%d\n",pbit->a,pbit->b,pbit->c); /* 用指针方式输出了这三个域的值 */
return 0;
}
得到以下结果
1,7,15
0,3,15
上例程序中定义了位域结构 bs，三个位域为 a、b、c。说明了 bs 类型的变量 bit 和指向 bs 类型的指针变量 pbit。这表示位域也是可以使用指针的。
参考自：