C语言进阶技术

[复制链接]

gaosmile 发布时间：2020-10-2 08:46

技术帖
文章封面:	-
文章简介:	-

壹

#include"xxx.c"
1、操作一波 咱们先体验一波#include"xxx.c"文件能不能用:

参考demo：

1//FileName :main
2#include <stdio.h>
3#include <stdlib.h>
4
5/***************************
6 * .c文件声明区域
7 **************************/
8#include"module1.c"
9#include"module2.c"
10
11/***************************
12 * Fuction: main
13 * Author

最后一个bug)
14 **************************/
15int main(int argc, char *argv[]) {
16
17 Fuction1();
18 Fuction2();
19 printf("欢迎关注公众号:最后一个bug\n");
20 return 0;
21}

1//FileName: Module1.c
2#include<stdio.h>
3/***************************
4 * Fuction: Fuction1
5 * Author

最后一个bug)
6 **************************/
7void Fuction1()
8{
9 printf("Run Fuction1\n");
10}

1//FileName: Module2.c
2#include<stdio.h>
3/***************************
4 * Fuction: Fuction2
5 * Author

最后一个bug)
6 **************************/
7void Fuction2()
8{
9 printf("Run Fuction2\n");
10}

输出结果：

分析一下：

看来这波操作可行，似乎还省去了.h文件，之前bug菌说过，分析.h文件的时候直接把.h文件在对应的.c文件中的位置处展开然后进一步分析即可，其实这.c文件也是如此，接着往下看。

参考demo：

1//FileName :main
2#include <stdio.h>
3#include <stdlib.h>
4
5char * cBug1 = "bugNo1"; //这里是位置1
6char * cBug2 = "bugNo2";
7/***************************
8 * .c文件声明区域
9 **************************/
10#include"module1.c"
11#include"module2.c"
12
13//char * cBug1 = "bugNo1";//这里是位置2
14//char * cBug2 = "bugNo2";
15
16/***************************
17 * Fuction: main
18 * Author

最后一个bug)
19 **************************/
20int main(int argc, char *argv[]) {
21
22 Fuction1();
23 Fuction2();
24 printf("欢迎关注公众号:最后一个bug\n");
25 return 0;
26}

1//FileName: Module2.c
2#include<stdio.h>
3/***************************
4 * Fuction: Fuction1
5 * Author

最后一个bug)
6 **************************/
7void Fuction1()
8{
9 printf("Run Fuction1\n");
10 printf("%s\n",cBug1);
11}

1//FileName: Module2.c
2#include<stdio.h>
3/***************************
4 * Fuction: Fuction2
5 * Author

最后一个bug)
6 **************************/
7void Fuction2()
8{
9 printf("Run Fuction2\n");
10 printf("%s\n",cBug2);
11}

输出结果：

分析一下：

我们在位置1进行两个变量的定义，成功编译运行得到如上的结果，符合我们的预期，然而当我们去掉位置1进行位置2的定义，程序却无法进行编译，看来跟我们预期在编译过程中直接展开.c文件是一致的。

2、有什么用? 这种方式在bug菌的编码历史长河中一般只在两种情况下用到:

1、维护毫无设计的代码

有些历史悠久的项目经过了N多位大佬的蹂躏，说实在的代码结构上已经非常可怕了，往往每个源文件内容非常之长，为了保持代码原样，会采用#include"xxx.c"把这几的相关文件嵌入进去，也便于自己后期维护。

2、测试代码

在前期进行软件调试的时候可能自己会在不同的文件中安插不同测试功能函数，通过这样方法可以方便的引入和剔除。

比如说你需要对源文件中的一些静态变量进行相关的监控处理，然而又不想在本文件中增加测试代码，于是便可以在#include"xxx.c"中进行测试函数的编写来供使用，比如 :

1//FileName :main
2#include <stdio.h>
3#include <stdlib.h>
4
5static int a = 5;
6/***************************
7 * .c文件声明区域
8 **************************/
9#include"module1.c"
10
11/***************************
12 * Fuction: main
13 * Author

最后一个bug)
14 **************************/
15int main(int argc, char *argv[]) {
16
17 Fuction1();
18 printf("main %d\n",a);
19 printf("欢迎关注公众号:最后一个bug\n");
20 return 0;
21}

1//FileName: Module2.c
2#include<stdio.h>
3/***************************
4 * Fuction: Fuction1
5 * Author

最后一个bug)
6 **************************/
7void Fuction1()
8{
9 printf("Run Fuction1\n");
10 printf("Fuction1 %d\n",a);
11}

注意了!!

那么之前有小伙伴说 : " static的作用域仅仅在对应的文件中 "，通过上面的多个.c文件使用静态a变量，那么这位小伙伴表述就不那么贴切了！
3、技术总结 大家在正常的开发过程中bug菌还是不建议使用#include"xxx.c"，因为在我们程序的设计过程中，.h文件就是一种外部的引用接口，而.c是对应的内部实现，如果滥用#include"xxx.c"有可能造成函数等等的重复定义，同时也对调试相关程序带来一些困扰，当然如果游刃有余就没啥问题的啦。
不过对于喜欢写长文件的小伙伴来说却是是福音，把一个长的.c文件分成多个.c文件，这样至少可以把不知道这种用法的同事面前秀一秀！

贰

void

1、简单认识一下void
void在大部分小伙伴的程序中都只是用于函数无参数传入，或者无类型返回。然而我们平时所定义的变量都会有具体的类型，int，float，char等等，那是否有void类型的变量呢？大家可以动手实验一下，答案是:不行,编译会出错。
å¾®ä¿¡å¾ç_20201002083846.png

上图很明显编译器不允许定义void类型的变量，变量都是需要占用一定内存的，既然void表示无类型，编译器自然也就不知道该为其分配多大的内存，于是造成编译失败。
虽然void不能直接修饰变量，但是其可以用于修饰指针的指向即无类型指针void*，无类型指针那就有意义了，无类型指针不是一定要指向无类型数据，而是可以指向任意类型的数据。
2、void * 基本操作
大家其实在使用动态内存分配的使用就已经遇到了void *的使用，来我们一起看看如下几个标准函数的原型定义:
å¾®ä¿¡å¾ç_20201002083849.png

上面这些函数都是与内存操作有关的函数，可能一些小伙伴使用过也不一定知道每个参数的具体类型是什么，这些void*部分的形参所传入的实参都是不需要进行强制类型转化的，所以根本就不需要关注传入指针所指向的具体类型，然而函数所返回的void *一般都需要通过强制类型转化为对应的具体类型，除非你最后所传递的变量也是void*类型。

参考void*用法：

1#include <stdio.h>
2#include <stdlib.h>
3#include <malloc.h>
4
5#define NUM 10
6/*************************************
7 * Fuction:了解一下void*的使用
8 * Author : (最后一个bug)
9 *************************************/
10int main(int argc, char *argv[]) {
11 int *p1 = (int *)malloc(NUM*sizeof(int));
12 int *p2 = (int *)malloc(NUM*sizeof(int));
13 int  i = 0;
14
15 //初始化p1
16 for(i = 0;i < NUM;i++)
17 {
18       *(p1+i) = i;
19 }
20 //进行内存copy
21 memcpy(p2,p1,NUM*sizeof(int));
22
23 //输出另外一个分配的内存
24 for(i = 0;i < NUM;i++)
25 {
26    printf("%d,",*(p2+i));
27 }
28 //释放内存
29 free(p1);
30 free(p2);
31 return 0;
32}

运行结果：

3、使用void * 实现无类型数据封装
为了保持文章的完整性，也许这里才是作者最想跟大家介绍的，void*既然如此的灵活一定大有用处，如果仅仅只是用来简单的传递参数似乎有点大材小用，我们得把其用到上层的软件设计上来。
在一些项目中经常看到有小伙伴把数据类型转来转去，甚至有时候为了一个数据类型的变化还得重新写一个仅仅数据类型不同的函数，这样的代码上万行代码指日可待，按下面我们以一个例子来跟大家介绍一种办法能够减少数据类型变化所带来的程序重复代码的增加。

参考实例：

1#include <stdio.h>
2#include <stdlib.h>
3/**********************************
4 * Fuction : add
5 * descir :  加法的相关数据及处理办法
6 * Author : (最后一个bug)
7 **********************************/
8typedef struct _tag_Add
9{
10 int a;
11 int b;
12 int result;
13}sAdd;
14
15void Add(void *param)
16{
17 sAdd *p = (sAdd *) param;
18 p->result = p->a + p->b;
19}
20/**********************************
21 * Fuction : add
22 * descir :  乘法的相关数据及处理办法
23 * Author : (最后一个bug)
24 **********************************/
25typedef struct _tag_Mul
26{
27 float a;
28 float b;
29 float result;
30}sMul;
31
32void Mul(void *param)
33{
34 sMul *p = (sMul *) param;
35 p->result = p->a * p->b;
36}
37
38/*************************************
39 * Fuction : sCal
40 * descir :  公共的调用接口
41 * Author : (最后一个bug)
42 ************************************/
43void sCal(void *param,void *fuc)
44{
45 ((void (*)(void*))fuc)(param);
46}
47
48/**********************************
49 * Fuction : main
50 * descir : 应用接口实例
51 * Author : (最后一个bug)
52 **********************************/
53int main(void)
54{
55 sAdd stAdd;
56 sMul stMul;
57
58 //数据初始化
59 stAdd.a = 10;
60 stAdd.b = 20;
61
62 stMul.a = 5;
63 stMul.b = 5;
64 //接口直接用
65 sCal(&stAdd,Add);
66 sCal(&stMul,Mul);
67 //对应的输出
68 printf("a + b = %d\n",stAdd.result);
69 printf("a * b = %f\n",stMul.result);
70 printf("公众号:最后一个bug\n");
71 return 0;
72 }

运行结果：

分析一下：

上面的例子可能还是无法完全彰显void*的强悍之处了，不过其主要的作用就是为了隐藏数据类型，大家也可以理解为一种数据类型的抽象处理，这也是面向对象编程的一种体现。
4、技术总结
大家一定要记得对于一些编程技巧一定要尝试着去使用，可能达到项目目标的方式有很多种，但是一些好的设计不仅仅会让你的代码增色不少，同时也会让同事们觉得你是一个喜欢专研技术的人。

叁

“ 逗号表达式 ” 1、先来一个逗号表达式例子

一个逗号表达式的实例：

1#include <stdio.h>
2#include <stdlib.h>
3/******************************************
4 * Fuction: Main
5 * Descir : 测试一个逗号表达式
6 * Author :（最后一个bug）
7 *****************************************/
8int main(int argc, char *argv[]) {
9 int Val = 1;
10
11 Val = ++Val,Val+10,Val*10; //逗号表达式
12
13 printf("Val = %d",Val);
14
15 return 0;
16}

分析一下：

大家首先可以自己算一下最后输出的结果，然后再去看下面的答案，其实对于逗号表达式的语法规则并不是很难，主要是大家在平时的开发中使用得比较少，一旦经常不使用就容易淡忘。

逗号表达式的形式 : 表达式1，表达式2，......，表达式n

三点搞定：

逗号表达式从表达式1开始顺序从左向右执行；
其逗号表达式最后的值为最后一个表达式的值；
逗号运算的优先级最低，也就说明与其他运算符结合使用的时候，在没有括号的情况下逗号运算符最后才执行。

% c# I" S9 M6 ]! z

上面例子的结果：

可能有部分小伙伴算出的结果是10，主要是没有考虑其逗号表达式优先级最低，所以第一赋值表达式优先执行。

2、"不怎么用"是不是就"没有用"？

既然大家平时都用得不多，是不是这个逗号表达式就是多此一举呢 ? C发展这么多年，如果真的没有价值估计早就不存在了吧，所以还是要秉承着"存在即是合理"的态度看待逗号表达式。

大家在平时阅读代码的时候应该都是按照从左至右，然后从上至下来的方式吧。基本上一个分号结束一行的书写，由于电脑屏幕的限制，有效代码暴露在人的视野中是有限的，同时人瞬间记忆时间也是有限的，如果在一个小小的屏幕上阅码势必会阻碍程序员的阅读和理解，比如下面两种书写方式:

1/******************************************
2 * Fuction: 非逗号表达式书写
3 * Descir :
4 * Author :（最后一个bug）
5 *****************************************/
6if(IsOk())
7{
8 sOkProc();
9 return GetOkCode();
10}
11else
12{
13 sNoProc();
14 return GetNoCode();
15}
16/******************************************
17 * Fuction: 采用逗号表达式书写
18 * Descir :
19 * Author :（最后一个bug）
20 *****************************************/
21return (IsOk())?(sOkProc(),GetOkCode())

sNoProc(),GetNoCode());

分析一下：

上面是两种代码书写方式，第一种占据了多行，而第二种进占据一行，这样同样一个屏幕所容纳的有效代码第一种就明显少于第二种方式，所以很多程序员都会选择使用一种大长屏或者多屏进行开发。
第二种方式似乎很多小伙伴觉得代码不够美观，也不便于维护，其实这仅仅只是一种习惯罢了，就好像编码的时候 : 第一个大括号是否需要另外起一行，或者是使用==号一定要像if( 1== b)这样把数据放左边，当你习惯了这种编码风格也会觉得用第二方式来得直接。

- u: S) H2 b$ Q. x

3、逗号表达式常用的地方

下面为大家介绍几个用逗号表示式比较多的地方:

1、for循环中的处理

参考demo：

1#include <stdio.h>
2#include <stdlib.h>
3#define  ROW_NUM  (5)
4#define  LINE_NUM (5)
5/******************************************
6 * Fuction: Main
7 * Descir :for 遍历查找
8 * Author :（最后一个bug）
9 *****************************************/
10int main(int argc, char *argv[]) {
11 int i = 0,j = 0;
12 int Matrix[ROW_NUM][LINE_NUM] ={{1,1,1,1,1},\
13                                  {2,2,2,2,2},\
14                                  {3,3,3,3,3},\
15                                  {4,4,4,4,4},\
16                                  {5,5,5,5,5},\
17                                  };
18
19 for(i = 0,j = 0;(i < ROW_NUM)&&(j < LINE_NUM);i++,j += 2)
20 {
21       printf("Matrix[%d][%d] = %d\n",i,j,Matrix[j]);
# l( E. i8 i3 G( e* K22 }: z, |; v9 T" B% p' H5 K+ \7 p
23 printf("公众号:最后一个bug\n");) |" [1 H. L/ t
24 return 0;
9 r" F4 S5 y- o/ A5 W25}

分析一下：

上面在for循环中遍历相关数据几比较常规的处理，也是逗号表达式经常出现的地方，这样的表现形式让代码更加简单明了。
其结果如下：
, q }: b$ W' k' y! d! A

7 A. e7 N) O& L7 Y' B+ }; \

2、弱化++处理大家应该都知道++在前先执行自加，然后再进行相应处理，而++在后则相反，那么我们可以使用逗号运算符优先级最低的特点来弱化该问题，避免编码出现bug。
参考Demo
1#include <stdio.h>
/ M' Y# G& S0 i( a9 F" ^7 K: c 2#include <stdlib.h>- g' t8 s5 m& H6 D' T4 I0 u" D8 q7 b
3/******************************************
/ K% @  Y+ S8 D! J% ~6 p7 v3 d0 L 4 * Fuction: Main   B# Y, L/ F9 H4 X# c0 P
5 * Descir :弱化++前后问题
) W' w; d0 z# D# |4 o 6 * Author :（最后一个bug） . p* F+ W5 L: o- J9 V$ v  }3 B+ {9 k8 u
7 *****************************************/
% O; S4 m" V5 @: H 8int main(int argc, char *argv[]) {
" \& R3 E3 I% b  w3 F 9 int i = 0;
0 H; S0 s( K9 A10
8 P4 {. c+ ?$ C' u  v7 ^  ?11 //1、常规操作
0 B. p5 I4 s4 {: i1 p& ^: H12 i = 0;
! G9 s8 s# b! H5 H0 k& S" D13 while(++i < 3)8 G, z$ D: ?: Z. [/ a7 D
14 {) J5 l3 S2 r) j, ^
15       printf(" i = %d\n",i);
; L/ g- l' K( F6 e9 }7 O+ n16 }
5 K) Z/ m1 g0 t3 I4 v17 printf("*****************\n");  j* e# P; j$ i+ P. H: y. P; R* c
18
# ?- \$ g6 C$ n. C1 F5 G9 i) u19 i = 0;
; F( f2 N7 G9 c20 while(i++ < 3)$ {' ]* I8 X( \/ V8 q5 f
21 {' @" I( D* R  x! s8 y
22       printf(" i = %d\n",i);: @# l. N5 ?: j" ~/ Z5 S/ j
23 }: P% L3 \' Z8 a
24 printf("*****************\n");
# o( u& ~  m! J& B25
. s2 c- A1 o+ Q. ]6 @26 //2、逗号表达式处理一下* M9 Y3 N* @) j
27 i = 0;
% x1 P2 g# F6 O: g& S5 t6 h. E28 while( i++,i < 3)
# N7 m# V- s8 _( v4 o29 {. H  L7 h) \( L" Q  ?
30       printf(" i = %d\n",i);
4 E+ O3 ^  X; }9 V31 }+ A" ^  F( G7 h) {% o' r6 q1 q
32 printf("*****************\n");+ {( n9 }& D' O2 b+ Q3 k7 R4 e
33# D5 Q. h  |/ e( B3 x) C% G
34 i = 0;# ?' K. _- c7 T+ f% I
35 while( ++i,i < 3)4 z  y# s1 k# D. E, i
36 {6 [( S+ J, }6 I4 x
37       printf(" i = %d\n",i);9 b5 W* v" W# G* Z  w% T
38 }
% Z3 R7 {/ H* F6 s! J# R39 printf("*****************\n");. m4 G+ K$ {( T5 t/ Q
40
8 _4 f4 t: P0 ~5 y( J41 printf("公众号:最后一个bug\n");( @, \9 D$ `3 ~( Y& K' B# L, I0 ~" O& {
42 return 0;/ b1 ?- s% n/ v; b  S
43}" B& B  F2 {) d. s, d  r; o' e4 z
44
分析一下：
当使用逗号表达式以后，不管++在前还是在后，其都会自增加1，然后再进行右边表达式的处理，这样就不用担心是不是多记了一次，导致各种问题。
运行结果:
0 c# b4 {; {9 i& ], Q  a4 i/ r+ U

6 D8 s) z& c6 B9 ^

2 s: l* n6 o1 k& b

3 P% q$ G( ], ^
3、更加精简宏定义
参考demo
1#include <stdio.h>% f8 D3 K, I$ X' l; t! R
2#include <stdlib.h>0 ]% A* P5 i& M' _" J% M/ U
3
$ r/ Y  e3 s/ b0 ~" { 4#define  GET_INDEX(a ,b)  ( a+= 2,a + b)1 r  u2 D+ E# f. l/ l
5/******************************************
$ M. A8 }2 @/ C, e5 @ 6 * Fuction: Main
- _. W0 ?$ H# J4 P: w3 k 7 * Descir : 简化宏
, D3 z7 j2 ?% `6 [) J8 X 8 * Author :（最后一个bug）
! Z4 B7 y: L2 W/ z- ]0 v1 E7 v 9 *****************************************/
: P. L$ F# A5 b2 \8 A10int main(int argc, char *argv[]) {. C3 c! q; O, Q% q' Y. O  p
11 int i = 0,Val = 0;" s$ a6 F! P8 e  c( u* T2 ?
12 int Param1 = 0, Param2 = 0;2 Q& }$ F6 n9 P* d7 d
13 int Matrix[5] ={5,5,5,5,5};
, G0 [3 r6 |( T0 z14$ l  E1 I" e$ c3 x
15 printf(" Matrix = %d\n",Matrix[GET_INDEX(Param1,Param2)]);6 U% |' A6 o( \) ?2 R1 K
16 printf("公众号:最后一个bug\n");
- q8 `0 F! e, [) q+ o6 N. s17 return 0;
# o1 [- F/ A, {/ C2 C" v18}: ?- N( q& n! P; Z% g

分析一下：
逗号表达式最终还是一个表达式，所以它可以直接用在几乎所有变量可以用的地方，这是和语句不同的。
所以逗号表达式左边的表达式可以预先进行各种处理，其最右边的表达式相当于返回最后的结果，从而减少函数的封装和调用。

  ]* K! m5 K' g6 u* Q- _
) w# G7 U0 }. i4 y- ~

4、技术总结
. c  h4 K  P$ `

! `- E  o( Q* R$ J4 Z' w
逗号表达式其实就是横向编码的一种方式，能够让程序员更好的利用一行的空间，使得代码更加紧凑，所以使用逗号表达式并没炫技，而是增强了代码的灵活度，不过话说回来逗号表达式在C混乱编码大赛上的使用频度是非常之高的。

6 M0 |& {3 A/ H6 N