接口封装设计思想引导

Sckclient客户端api模型设计

第一套api函数

#ifndef _SCK_CLINT_H_

#define _SCK_CLINT_H_

//函数声明

// 1、client环境初始化

int sckClient_init(void **handle); //5 day

//

// 2、client发送报文

int sckClient_send(void *handle, unsigned char *data, int datalen);

// 3、client端接受报文

int sckClient_rev(void *handle, unsigned char *out, int *outlen); //1

// 4、client环境释放

int sckClient_destroy(void *handle);

#endif

//条件编译 避免头文件多次包括

#ifndef _SCK_CLINT02_H_

#define _SCK_CLINT02_H_

#ifdef  __cplusplus

extern "C" {

#endif

//函数声明

// 1、client环境初始化

int sckClient_init2(void **handle); //5 day

//

// 2、client发送报文

int sckClient_send2(void *handle, unsigned char *data, int datalen);

// 3、client端接受报文

int sckClient_rev2(void *handle, unsigned char **out, int *outlen); //1

int sckClient_rev2_Free(void **p); //1

// 4、client环境释放

int sckClient_destroy2(void **handle);

#ifdef  __cplusplus

}

#endif

#endif

我们找到了一套标准，我们能够高效、有目的的学习。

Socket动态库业务模型思路分析

Shift+del 删除一行 ctrl+shift+u大小 ctrl +u 小写

Alt+F9

F5在多个断点间切换

//当数组当做函数參数的话的时候会退化为指针

int printfArray(int a[])

{

int i = 0;

printf("排序之前\n ");

for (i=0; i<10; i++)

{

printf("%d ", a[i]);

}

return 0;

}

//int a[10]  -=-->int a[] ---->int *a

//数组做函数形參的时候。假设在形參中定义int a[10]语句，

//c/c++编译器 会做优化。技术推演例如以下

//int a[10]  -=-->int a[] ---->int *a

//总结：函数调用的时候，把数组首地址和有效数据长度传给被调用函数才是最正确的做法

int printfArray04(int *a, int num)

{

int i = 0;

printf("排序之前\n ");

for (i=0; i<num; i++)

{

printf("%d ", a[i]);

}

return 0;

}

数据类型可理解为创建变量的模具（模子）；是固定大小内存的别名。

sizeof是操作符，不是函数；sizeof測量的实体大小为编译期间就已确定

数据类型能够取别名、測量大小

数据类型的封装

Void数据类型的封装

数据类型的引申

C一维数组、二维数组有数据类型吗 3

C语言中，函数是能够看做一种数据类型吗？15

数组类型三大技术难点，压死刚開始学习的人的三座大山

变量本质：（一段连续）内存空间的别名、内存空间的标号

改动变量的3种方法

1、直接

2、间接。内存有地址编号。拿到地址编号也能够改动内存；于是。。

。

横空出世了！

3、c++ 引用

总结：1对内存 可读可写； 2通过变量往内存读写数据，3不是向变量读写数据。4向变量代表的数据空间读写数据。变量跑到什么地方去了？

1、  内存四区模型和函数调用模型

基本概念

函数1调用函数2。函数1称为主调函数 函数2称为被调用函数

规则1：Main（主调函数）分配的内存（在堆区，栈区、全局区）都能够在被调用函数里使用吧。

规则2：在被调用函数里面分配的内存

、假设在被调用函数里面的暂时区（栈）分配内存，主调用函数是不能使用的。

全局区：//c++编译器优化

char *getStr1()

{

char *p = "abcd1";

return p;

}

char *getStr2()

{

char *p = "abcd1";

return p;

}

//

暂时区stack

char * getStr3()

{

char buf[100];

memset(buf, 0, sizeof(buf));

strcpy(buf, "abcd1");

return buf;

}

//栈属性

//栈向下生长的，

//栈的生长方向和内存空间buf存放方向是两个不同的概念

//堆向上生长的，

//演示：stack生长方向

int main31()

{

float *p1 = NULL;

int *p2 = NULL;

int a = 0;

int b= 0;

char buf[16];

printf("&p1:%x, &p2:%x, &a:%x, &b:%x \n", &p1, &p2, &a, &b);

printf("&buf[0]:%x, &buf[1]:%x", &buf[0], &buf[1]);

getchar();

}

//软件开发中 注意野指针

//细致观察malloc内存地址大小

//演示heap生长方向

int main32()

{

int a = 0;

int b = 0;

char *p1 = NULL;

char *p2= NULL;

p1 = (char *)malloc(16);

p2 = (char *)malloc(16);

printf("\n p1:%x, p2:%x", p1, p2);

printf("\n &p1:%x, &p2:%x", &p1, &p2);

//通过内存地址间接赋值

*((char *)0x394da0) = 'a';

*((char *)0x394da1) = 'b';

//通过内存地址间接改动内存空间的值

//通过变量名訪问内存空间

//通过内存地址间接訪问内存空间 这就是C语言的灵活性，也是c语言的精华

printf("\np2[0]:%c", p2[0]);

printf("\np2[1]:%c", p2[1]);

if (p1 != NULL)

{

free(p1);

}

if (p2 != NULL)

{

free(p2);

}

getchar();

return 0;

}

//在函数调用哪个的时候 实參的值机械的传给形參（c int数组场景）

//关于形參：

写在函数上形參变量。还是写在函数里面的变量，

从CC++编译的角度来讲，是没有不论什么差别的（分配4字节内存）。

仅仅只是是 写在函数上形參变量 ，具有对外的属性而已

//数据类型分为两种。一个是简单的数据类型。一个是复杂的数据类型。碰见复杂的数据类型不能用简单的数据类型的思维去思考它。抛砖

/*

int getbuf01(char   *p); int getbuf01(char*     p);

int getbuf02(char **p); int getbuf02(char *   *p); getbuf02(char **        p);

int getbuf03(char (*p)[]); int getbuf03(char (*p)      []);  int getbuf03(char (     *p)[     ]);

int getbuf03(char p[10][30]);

int getbuf04(char *****p);

*/

//角度1站在c++编译器的角度 指针就是一个变量，除此之外啥也不是。

//无论是1个* 还是8个*对c++编译器来讲。仅仅会分配4个字节内存

//角度2：当我们程序猿要使用指针所指向的内存空间的时候。我们关心，这个内存块是一维的，还是二维的。

//普通情况：1级指针代表1维，二级指针代表二维。

。。

//假设有超过char ***级及3级以上的指针。则不代表几维的内存。。

。

//多维数组做函数參数。普通情况下，仅仅能表达到二维。

//假设是三维内存（我们程序猿起的名字），已经没有意义。

//证明一下多维数组的线性存储

//线性打印

void printfAARRR(char ***ddd);

void printfAARRR(char *********dddd);

void printfArray411(int *array,int num)

{

int i = 0;

for (i=0; i<num ; i++)

{

printf("%d ",
array[i]);

}

}

void printfArray412(int (*array)[5],int num)

{

return ;

}

void printfArrr333(int c[3][4][5])

{

return ;

}

void main()

{

int a[3][5];

int c[3][4][5];

int i , j = 0;

int tmp = 0;

for (i=0; i<3; i++)

{

for (j=0; j<5; j++)

{

a[i][j] = tmp ++;

}

}

printfArray411((int *)a, 15);

system("pause");

}

C能够在暂时区分配内存块。。

。

。

。。。java不行

{

char *p1 = 0; //

strcpy(p1, "abcdefg");

strcpy(0, "abcdefg"); //抛砖：在两个函数里面就不一定能明确

}

//[] *的本质究竟是什么？

//*p 是我们程序猿手工的（显示）去利用间接赋值

//【】 仅仅只是是，c/c++ 编译器帮我们做了一个*p的操作。。。。

。。

// buf4[i]======> buf4[0+i] ====>  *(buf4+i)

//===*(buf4+i)   --> bu4[i];

//操作数组的方法

//下标法和指针法

void main()

{

int i = 0;

char *p = NULL;

//通过字符串初始化字符数组 而且追加\0

char buf4[] = "abcd";

for (i=0; i<strlen(buf4); i++)

{

printf("%c", buf4[i]); //p[]

}

//[] *的本质究竟是什么？

//*p 是我们程序猿手工的（显示）去利用间接赋值

//【】 仅仅只是是，c/c++ 编译器帮我们做了一个*p的操作。

。

。。。

。

// buf4[i]======> buf4[0+i] ====>  *(buf4+i)

//===*(buf4+i)   --> bu4[i];

printf("\n");

p = buf4;

for (i=0; i<strlen(buf4); i++)

{

printf("%c", *(p+i)); //*p

}

system("pause");

}

{

int a[10]; //a是一个指针===》a常量指针===》为什么c++

int *p = a;

p ++;

a ++;

}

//c++编译器要拿着a去析构内存。为了避免你把a的指向改变。。。

。。

间接赋值成立的是3个条件

/* 间接赋值成立的三个条件

条件1  //定义1个变量（实參） //定义1个变量（形參）

条件2//建立关联：把实參取地址传给形參

条件3：//*形參去间接地的改动了实參的值。

*/

Int iNum = 0; //实參

int *p = NULL;

p = &iNum;

iNum = 1;

*p =2 ; //通过*形參 == 间接地改变实參的值

*p成立的三个条件：

间接赋值成立三个条件的几种组合

123在一个函数里面

12    3 两个函数

1              23两个函数

//间接赋值条件应用深入分析 三个条件的组合，分别产生三种非常重要的语法现象

//123都写在一个函数里面

//12写在一个函数里面  3 写在另外一个函数里面

//1 写在一个函数里面  23 写在另外一个函数里面 抛砖。。。到时候别不认识啊。。

。。。

间接赋值应用场景12

场景1：一个函数之内  *p1++ = *p2++

场景2：int getFileLen(int *a )

间接赋值的推论

//在函数调用的时候

/*

用1级指针形參，去间接改动了0级指针（实參）的值。。

用2级指针形參。去间接改动了1级指针（实參）的值。。

用3级指针形參，去间接改动了2级指针（实參）的值。

。

用n级指针形參，去间接改动了n-1级指针（实參）的值。。

*/

间接赋值的project意义

//函数调用时，形參传给实參，用实參取地址。传给形參，在被调用函数里面用*p，来改变实參，把运算结果传出来。

//指针作为函数參数的精髓。

//C语言特有的想象。是C语言的精华。

。。

寻路

指针做函数參数是我们的研究重点。。。

。

。

指针是子弹、函数像枪管，。子弹枪管才干发挥它的威力。。。。

。

。。

下一步你的方向

1、  指针学完了。。

。。。

你仅仅是c语言的半壁江山。。。。。

2、  函数指针。

。。。

//c语言里面没有字符串这样的类型。。。

。。

//通过字符数组来模拟字符串

//C风格字符串是以零结尾的字符串

void main11()

{

//字符数组初始化

//指定长度 假设定义的长度剩余部分补充0

char buf1[100] = {'a', 'b', 'c'};

//不指定长度

char buf2[] = {'a', 'b', 'c'};

char buf3[] = {'a', 'b', 'c','\0'};

//通过字符串初始化字符数组 而且追加\0

char buf4[] = "abcdefg";

printf("%s\n", buf4 );

system("pause");

}

printf("%s\n", buf4 );

printf("sizeof(buf4): %d\n ", sizeof(buf4)); //注意sizeof是对数组类型进行大小測量 包含了\0

printf("strlen(buf4): %d \n", strlen(buf4));//strlen是求字符串的长度不包含\0

一级指针内存模型图

C库字符串API函数调用经验谈

字符串copy函数技术推演

//C字符串函数调用方法经验谈

//站在内存四区模型和函数调用模型去思考函数。。

。

。。

api接口

/*

1）  主调函数 被调函数

a)      主调函数可把堆区、栈区、全局数据内存地址传给被调用函数

b)      被调用函数仅仅能返回堆区、全局数据

2）  内存分配方式

a)      指针做函数參数，是有输入和输出特性的。

*/

//C字符串函数调用方法经验谈

//站在内存四区模型和函数调用模型去思考函数。。

。

。。api接口

/*

1）  主调函数 被调函数

a)      主调函数可把堆区、栈区、全局数据内存地址传给被调用函数

b)      被调用函数仅仅能返回堆区、全局数据

2）  内存分配方式

a)      指针做函数參数，是有输入和输出特性的。

*/

字符串操作常见project开发模型

业务模型&业务測试模型分离===》接口封装和设计第一步

//被调用函数分配内存吧结果甩出来有两种方法

//return

//指针做函数參数

char * getBuffer()

{

char buf[109];

char *p = (char *)malloc(199);

//char *p2= (char *)malloc(199);

return p;

}

strstr的while dowhile模型

//int cltClient_rev(void *handle, unsigned char *buf, int *buflen)

//不要相信别人给你传送的内存地址是可用的

int getCout(char *str, char *substr, int *count)

{

int rv = 0;

char *p = str;

int ncout = 0;

if (str==NULL || substr== NULL ||  count==NULL)

{

rv = -1;

printf("func getCout()check (str==NULL || substr== NULL ||  count==NULL) err:%d \n" , rv);

return rv;

}

do

{

p = strstr(p, substr);

if (p == NULL) //没有找到则跳出来

{

break;

}

else

{

ncout++;

p = p + strlen(substr);

}

} while (*p != '\0');

//fuzhi

*count  = ncout;

printf("ncout:%d\n", ncout);

return rv;

}

void main36()

{

char *p = "abcd1111abcd222abcd3333";

int ncout = 0;

while (p = strstr(p, "abcd"))

{

p = p + strlen("abcd");

ncout ++;

if (*p == '\0')

{

break;

}

}

printf("ncout:%d\n", ncout);

system("pause");

}

两头堵模型（两种写法）

//求去掉空格

//int trimSpaceStr2(char *p, unsigned char *buf2, int *buf2len)

int trimSpaceStr2( char *p, char *buf2)

{

int ret = 0;

int ncount = 0;

int i, j;

i = 0;

j = strlen(p) -1;

while (isspace(p[i]) && p[i] != '\0')

{

i++;

}

while (isspace(p[j]) && j>0 )

{

j--;

}

ncount = j - i + 1;

//

strncpy(buf2, p+i, ncount);

buf2[ncount] = '\0';

return ret;

}

//求去掉空格

//int trimSpaceStr2(char *p, unsigned char *buf2, int *buf2len)

//不要轻易去改变指针输入特性中in内存块的内存。。

。

。

int trimSpaceStr2_notgood( char *p)

{

int ret = 0;

int ncount = 0;

int i, j;

i = 0;

j = strlen(p) -1;

while (isspace(p[i]) && p[i] != '\0')

{

i++;

}

while (isspace(p[j]) && j>0 )

{

j--;

}

ncount = j - i + 1;

//

strncpy(p, p+i, ncount);

p[ncount] = '\0';

return ret;

}

字符串反转模型

void main51()

{

char p[] = "abcde";

char c ;

char *p1 = p;

char *p2 = p + strlen(p) -1;

while (p1 < p2)

{

c = *p1;

*p1 = *p2;

*p2 = c;

++p1;

--p2;

}

printf("p:%s \n", p);

system("pause");

}

int getKeybyValue(char *pKeyValude, char *pKey, char *pValude)

{

char rv = 0;

char *p = NULL;

if (pKeyValude==NULL  )

{

rv = -1;

printf("func getKeybyValue() err:%d pKeyValude \n", rv);

return rv;

}

if ( pKey==NULL )

{

rv = -1;

printf("func getKeybyValue() err:%d pKey=NULL \n", rv);

return rv;

}

if ( pValude==NULL )

{

rv = -1;

printf("func getKeybyValue() err:%d pValude \n", rv);

return rv;

}

//1 在pKeyValude中查找是否有keywordpKey

p = strstr(pKeyValude, pKey);

if (p == NULL)

{

rv = -1;

printf("func getKeybyValue() err:%d 查找没有keywordpKey  \n", rv);

return rv;

}

p = p + strlen(pKey); //为下一次检索做准备

//2 有没有=

p = strstr(p, "=");

if (p == NULL)

{

rv = -2;

printf("func getKeybyValue() err:%d 查找没有=  \n", rv);

return rv;

}

p = p + 1; //为下一次提取valude做准备

//3 提取依照要求的valude

rv = trimSpaceStr03(p, pValude);

if (rv != 0)

{

printf("func trimSpaceStr03() err:%d \n", rv);

return rv;

}

return rv;

}

建立一个思想：是主调函数分配内存，还是被调用函数分配内存。

//不要相信，主调函数给你传的内存空间，你能够写。。。。

。。一级指针你懂了。

可是二级指针，你就不一定懂。。。

抛出。。。。。。。。。

越界 语法级别的越界

char buf[3] =
"abc";

不断改动指针变量的值

暂时str3内存空间

char *str_cnct(char *x, char* y)     /*简化算法*/

{

char str3[80];

char *z=str3;     /*指针z指向数组str3*/

while(*z++=*x++);

z--;                  /*去掉串尾结束标志*/

while(*z++=*y++);

z=str3;       /*将str3地址赋给指针变量z*/

return(z);

}

、经验要学习

while(*z++=*x++);

z--;                  /*去掉串尾结束标志*/

Const优点

//合理的利用const，

//1指针做函数參数，能够有效的提高代码可读性，降低bug；

//2清楚的分清參数的输入和输出特性

结论：

//指针变量和它所指向的内存空间变量，是两个不同的概念。。。

。。。

//看const 是放在*的左边还是右边 看const是修饰指针变量，还是修饰所指向的内存空变量

int main()

{

const int a;  //

int const b;

const char *c;

char * const d;

const char * const  e ;

return 0;

}

Int func1(const )

0基础理解：const是定义常量==》const意味着仅仅读

含义：

//第一个第二个意思一样 代表一个常整形数

//第三个 c是一个指向常整形数的指针(所指向的内存数据不能被改动，可是本身能够改动)

//第四个 d 常指针（指针变量不能被改动。可是它所指向内存空间能够被改动）

//第五个 e一个指向常整形的常指针（指针和它所指向的内存空间，均不能被改动）

Char myArray[10][30]指针数组的一个指针.

myArray是一个指针变量 。是一个常量。

。。是一个常量指针

void f(int a[5]) ====》void f(int a[]); ===》 void f(int* a);

void g(int a[3][5])====》 void g(int a[][5]); ====》 void g(int (*a)[5]);

技术推演过程  *(*(a+1) +j ) a[i][j]

Chsr * p[3] = {“aaaa”, “bbb”,”cccc”};

Int printArray(char *p[3])==èInt printArray(char *p[])==èInt printArray(char **p)

void main()

{

//03、数组类型、数组指针类型、数组指针类型变量

typedef int MyTypeArray[5];

MyTypeArray a; //int a[5];

int intArray[3][5];

{

typedef int (*MyPTypeArray)[5];

MyPTypeArray  myArrayPoint ;

myArrayPoint = &a;

(*myArrayPoint)[0] = 1; //通过一个数组指针变量去操作数组内存

}

{

int (*myArrayVar)[5]; //告诉编译给我开辟4个字节的内存‘

myArrayVar = &a;

(*myArrayVar)[1] = 2;

}

{

int (*myArrayVar2)[5]; //告诉编译给我开辟4个字节的内存‘

myArrayVar2 = intArray; //

}

}

本质是由于 程序猿眼中的二维内存，在物理内存上是线性存储。所以说是真。。

。。

。

/证明一下多维数组的线性存储

//线性打印

//多维数组做函数參数，普通情况下。仅仅能表达到二维，

//假设是三维内存（我们程序猿起的名字），已经没有意义。

//普通情况：1级指针代表1维，二级指针代表二维。

。

。

//假设有超过char ***级及3级以上的指针，则不代表几维的内存。。。

void printfAARRR(char ***ddd);

void printfAARRR(char *********dddd);

void printfArray411(int *array, int num)

{

int i = 0;

for (i=0; i<num ; i++)

{

printf("%d ", array[i]);

}

}

void printfArray412(int (*array)[5], int num)

{

return ;

}

void printfArrr333(int c[3][4][5])

{

return ;

}

void main()

{

int a[3][5];

int c[3][4][5];

int i , j = 0;

int tmp = 0;

for (i=0; i<3; i++)

{

for (j=0; j<5; j++)

{

a[i][j] = tmp ++;

}

}

printfArray411((int *)a, 15);

system("pause");

}

1、  C语言中仅仅会以机械式的值拷贝的方式传递參数（实參把值传给形參）

int fun(char a[20], size_t b)

{

   printf("%d\t%d",b,sizeof(a));

}

原因1：高效

原因2：

C语言处理a[n]的时候，它没有办法知道n是几。它仅仅知道&n[0]是多少，它的值作为參数传递进去了

尽管c语言能够做到直接int fun(char a[20])。然后函数能得到20这个数字，可是，C没有这么做。

、二维数组參数相同存在退化的问题

二维数组能够看做是一维数组

二维数组中的每一个元素是一维数组

二维数组參数中第一维的參数能够省略

void f(int a[5]) ====》void f(int a[]); ===》 void f(int* a);

void g(int a[3][3])====》 void g(int a[][3]); ====》 void g(int (*a)[3]);

3、等价关系

数组參数                                               等效的指针參数

一维数组 char a[30]                                   指针 char*

指针数组 char *a[30]                                指针的指针 char **a

二维数组 char a[10][30]                           数组的指针 char(*a)[30]

char  **getMem(int count)

{

int i = 0;

char **tmp = (char **)malloc(count*sizeof(char *));

for (i=0; i<count; i++)

{

tmp[i]  = (char *)malloc(100);

}

return tmp;

}

void sortArray(char **myArray, int count)

{

int i = 0, j = 0;

char *tmp;

for (i=0; i<count; i++)

{

for (j=i+1; j<count; j++)

{

if (strcmp(myArray[i], myArray[j]))

{

tmp = myArray[i]; //这个地方交换的是指针变量

myArray[i] = myArray[j];

myArray[j] = tmp;

}

}

}

}

void sortArray02(char **myArray, int count)

{

int i = 0, j = 0;

char tmp[200];

for (i=0; i<count; i++)

{

for (j=i+1; j<count; j++)

{

if (strcmp(myArray[i], myArray[j]) > 0)

{

strcpy(tmp, myArray[i]);

strcpy(myArray[i], myArray[j]);

strcpy(myArray[j], tmp); //交换是buf的内容

}

}

}

}

void  printfArray(char **myArray, int count)

{

int i = 0, j = 0;

for (i=0; i<count; i++)

{

printf("%s \n", myArray[i]);

}

}

void main()

{

char **pArray = NULL;

pArray = getMem(3);

strcpy(pArray[0], "bbbbb");

strcpy(pArray[1], "aaaa");

strcpy(pArray[2], "cccc");

printf("排序之前\n");

printfArray(pArray ,3);

//sortArray(pArray, 3);

sortArray02(pArray, 3);

printf("排序之后\n");

printfArray(pArray ,3);

system("pause");

}

char  **getMem(int count)

{

int i = 0;

char **tmp = (char **)malloc((count+1)*sizeof(char *) );

for (i=0; i<count; i++)

{

tmp[i]  = (char *)malloc(100);

}

tmp[count] = '\0'; //转义字符的0

tmp[count] = 0; //转义字符的0

tmp[count] = NULL; //转义字符的0

return tmp;

}

//野指针产生问题分析

//指针变量和它所指内存空间变量是两个不同的概念

//解决野指针的方案

//1定义指针时 把指针变量赋值成null

//2 释放内存时，先推断指针变量是否为null

//3 释放内存完成后。把指针变量又一次赋值成null

#include "stdio.h"

#include "stdlib.h"

#include "string.h"

//野指针产生问题分析

//指针变量和它所指内存空间变量是两个不同的概念

//解决野指针的方案

//1定义指针时 把指针变量赋值成null

//2 释放内存时，先推断指针变量是否为null

//3 释放内存完成后，把指针变量又一次赋值成null

//

void main22()

{

char *p = NULL;

p = (char *)malloc(100); //char p[100];

strcpy(p, "abcdefg");

//做业务

//此处省略5000字。。。

。

。

if (p != NULL)

{

free(p);

p = NULL;

}

//做业务

//此处省略5000字。。。。。

if (p != NULL)

{

free(p);

}

system("pause");

}

char *getMem2(int count)

{

char *tmp = NULL;

tmp = (char *)malloc(100*sizeof(char)); //char tmp[100];

return tmp;

}

//实參和形參是两个不同的概念

void getMem3(int count, char *p)

{

char *tmp = NULL;

tmp = (char *)malloc(100*sizeof(char)); //char tmp[100];

p = tmp; //在这个场景下，你给形參赋值了，没有给实參赋值

//直接改动实參没戏。。

。。。。。 实參和形參是两个不同的概念

//return tmp;

}

void getMem4(int count, char **p /*out*/)

{

char *tmp = NULL;

tmp = (char *)malloc(100*sizeof(char)); //char tmp[100];

//p = tmp; //在这个场景下。你给形參赋值了。没有给实參赋值

//直接改动实參没戏。。

。

。。。。 实參和形參是两个不同的概念

//间接的改动实參

//*(实參的地址)  =

*p = tmp;

//return tmp;

}

//函数调用的时候，这个场景改动不实參

int FreeMem2(char *p)

{

if (p ==NULL)

{

return -1;

}

if (p != NULL)

{

free(p);

p = NULL; //想把实參给改掉。你能改动吗？ 改动不了实參。。

。。。

}

return 0;

}

void main51()

{

char *myp = NULL;

myp = getMem2(100);

//getMem3(100, myp);

//getMem4(100, &myp);

//做业务操作

//此 50000

FreeMem2(myp);

FreeMem2(myp);

}

void main()

{

Teacher t1;

Teacher t2;

Teacher *p  = NULL;

printf(" %d \n", sizeof( Teacher));

p  = &t1;

strcpy(t1.name, "name");

t1.age = 10; //通过.的方法来操作结构体的成员域

p->age = 12;

p->age; // . ->的本质是寻址。。

。。。寻每个成员相对于大变量t1的内存偏移。。

。。。。没有操作内存

//所以这样写是没有问题的。

t2 = t1; //编译器做了什么工作

对结构体而言。指针做函数參数和元素变量做函数不同地方

void copyStruct(Teacher *to, Teacher *from)

{

*to = *from;

}

//

int copyStruct2(Teacher to, Teacher from)

{

to = from;

return 10;

}

Teacher *creatTArray2(int num)

{

int i = 0, j = 0;

Teacher *tArray = NULL;

tArray = (Teacher *)malloc(num * sizeof(Teacher));

if (tArray == NULL)

{

return NULL;

}

for (i=0; i<num; i++)

{

tArray[i].tile = (char *)malloc(100);

}

//创建老师带的学生

for (i=0; i<num; i++)

{

char **ptmp = (char **)malloc((3+1)*sizeof(char *));

for (j=0; j<3; j++)

{

ptmp[j] = (char *)malloc(120);

}

//ptmp[3] = NULL;

tArray[i].pStuArray = ptmp;

}

return tArray;

}

释放函数

int FreeTArray(Teacher *tArray, int num)

{

int i =0, j = 0;

if (tArray == NULL)

{

return -1;

}

for (i=0; i<num; i++)

{

char **tmp = tArray[i].pStuArray;

if (tmp ==NULL)

{

continue;;

}

for (j=0; j<3; j++)

{

if (tmp[j] != NULL)

{

free(tmp[j]);

}

}

free(tmp);

}

for (i=0; i<3; i++)

{

if (tArray[i].tile != NULL)

{

free(tArray[i].tile);

tArray[i].tile = NULL; //laji

}

}

free(tArray);

tArray = NULL; //垃圾

}

//产生的原因

//编译器给我们提供的copy行为是一个浅copy

//当结构体成员域中含有buf的时候。没有问题

//当结构体成员域中还有指针的时候，编译器仅仅会进行指针变量的copy。

指针变量所指的内存空间，编译器不会在多分分配内存

//这就是编译器的浅copy，我们要属顺从。。。。

//

/结构体的定义

typedef struct _AdvTeacher

{

char *name;

char buf[100];

int age;

}Teacher ;

Teacher * creatT()

{

Teacher *tmp = NULL;

tmp = (Teacher *)malloc(sizeof(Teacher));

tmp->name = (char *)malloc(100);

return tmp;

}

void FreeT(Teacher *t)

{

if (t == NULL)

{

return ;

}

if (t->name != NULL)

{

free(t->name);

}

}

//解决方式

int copyObj(Teacher *to, Teacher *from)

{

//*to = *from;//copy。

memcpy(to, from, sizeof(Teacher));

to->name = (char *)malloc(100);

strcpy(to->name, from->name);

}

深刻理解-》 。操作符的本质

#include "stdlib.h"

#include "stdio.h"

#include "string.h"

typedef struct _A

{

int a ;

};

//结构体的定义

typedef struct _AdvTeacher

{

char *name; //4

int age2 ;

char buf[32];  //32

int age; //4

struct _A

}Teacher ;

void main2()

{

int i = 0;

Teacher * p = NULL;

p = p - 1;

p = p - 2;

p = p +2;

p = p -p;

i = (int) (&(p->age)); //1逻辑计算在cpu中。运算

printf("i:%d \n", i);

//&属于cpu的计算，没有读写内存，所以说没有coredown

system("pause");

}

//-> .

void main()

{

int i = 0;

i = (int )&(((Teacher *)0)->age );

printf("i:%d \n", i);

//&属于cpu的计算，没有读写内存。所以说没有coredown -->

system("pause");

}

char *fname = "c:\\1.txt";

char *fname2 = "c:/a1.txt"; //统一的用45度斜杠

fgetc fputc 依照字符读写文件

fputs fgets  依照行读写文件 （读写配置文件）

fread fwirte 依照块读写文件 （大数据块迁移）

void main04()

{

int i = 0;

FILE *fp = NULL;

char buf[100];

char *p = NULL;

char *fname = "c:\\1.txt";

char *fname2 = "c:/a1.txt"; //统一的用45度斜杠

fp = fopen(fname2, "r"); //无论文件是否存在，新建文件

if (NULL == fp)

{

printf("func fopen（） err: \n");

}

while (!feof(fp))

{

//_cdecl fgets(_Out_z_cap_(_MaxCount) char * _Buf, _In_ int _MaxCount, _Inout_ FILE * _File);

p = fgets(buf, 100, fp);

if (p == NULL)

{

printf("func fgets() .....\n");

return ;

}

printf("%s \n", buf);

printf("%s \n", p);

}

if (fp != NULL)

{

fclose(fp);

}

}

项目开发中參考fgets函数的实现方法

fgets(buf, bufMaxLen, fp);

对fgets函数来说，n必须是个正整数，表示从文件按中读出的字符数不超过n-1。存储到字符数组str中。并在末尾加上结束标志’\0’。换言之。n代表了字符数组的长度，即sizeof(str)。

假设读取过程中遇到换行符或文件结束标志，读取操作结束。若正常读取，返回指向str代表字符串的指针，否则。返回NULL（空指针）。

文件控制

fp = fopen(pFileName, "r+");

if (fp == NULL)

{

rv = -2;

printf("fopen() err. \n");

//goto End;

}

if (fp == NULL)

{

fp = fopen(pFileName, "w+t");

if (fp == NULL)

{

rv = -3;

printf("fopen() err. \n");

goto End;

}

}

fseek(fp, 0L, SEEK_END); //把文件指针从0位置開始，移动到文件末尾

//获取文件长度;

length = ftell(fp);

fseek(fp, 0L, SEEK_SET);

// cfg_op.h

#ifndef _INC_CFG_OP_H

#define _INC_CFG_OP_H

#ifdef  __cplusplus

extern "C" {

#endif

int GetCfgItem(char *pFileName /*in*/, char *pKey /*in*/, char * pValue/*in out*/, int * pValueLen /*out*/);

int WriteCfgItem(char *pFileName /*in*/, char *pItemName /*in*/, char *pItemValue/*in*/, int itemValueLen /*in*/);

//int CfgItem_Init(void *pHandle, int iType);

//int GetCfgItem(void *pHandle /*in*/, char *pKey /*in*/, char * pValue/*in out*/, int * pValueLen /*out*/);

//int WriteCfgItem(void *pFileName /*in*/, char *pItemName /*in*/, char *pItemValue/*in*/, int itemValueLen /*in*/);

//int CfgItem_Destory(void *pHandle);

#ifdef  __cplusplus

}

#endif

#endif

Int iNum = 0; //实參

int *p = NULL;

p = &iNum;

iNum = 1;

*p =2 ; //通过*形參 == 间接地改变实參的值

*p成立的三个条件：

编号

指针函数參数

内存分配方式（级别+堆栈）

主调函数

实參

被调函数

形參

备注

01

1级指针

（做输入）

堆

分配

使用

一般应用禁用

栈

分配

使用

经常使用

Int showbuf(char *p);

int showArray(int *array, int iNum)

02

1级指针

（做输出）

栈

使用

结果传出

经常使用

int geLen(char *pFileName, int *pfileLen);

03

2级指针

（做输入）

堆

分配

使用

一般应用禁用

栈

分配

使用

经常使用

int main(int arc ,char *arg[]); 指针数组

int shouMatrix(int [3][4], int iLine);二维字符串数组

04

2级指针

（做输出）

堆

使用

分配

经常使用，但不建议用，转化成02

int getData(char **data, int *dataLen);

Int getData_Free(void *data);

Int getData_Free(void **data); //避免野指针

05

3级指针

（做输出）

堆

使用

分配

不经常使用

int getFileAllLine(char ***content, int *pLine);

int getFileAllLine_Free(char ***content, int *pLine);