指针作为c语言的精华所在所以会多学习几天来扎实的掌握
下面讲几个今天学习个人认为比较重要的知识，以及对于return及函数返回值的作用的一些思考和笔记
关于return和一个用户定义的函数返回值或者说这个函数处理完继续去主函数运算的值的思考
首先，一个函数的返回值有且只有一个。呢么肯定会有问题当函数产需要多个值回到主函数去处理时怎么办？
1.最简单的例如交换两个数据完全可以利用指针去完成。相当于原来是两个房间a，b你是把a住的人拿到c去然后b的人住进来a的人再去b也就是人换看，实际上他们的内存位置交换了同时值也交换了。但是利用指针是把门牌号换了就不存在去操作里面的人也就是变量。这也是我学到的第一个指针带给我的意义。
2.利用全局变量
分析：全局变量作为C语言的一个知识点，虽然我们都了解它的特点，但在实际教学过程中应用得并不是很多。由于全局变量的作用域是从定义变量开始直到程序结束，而对于编写有多个返回值的C语言函数，我们可以考虑把要返回的多个值定义成全局变量。当函数被调用时，全局变量被更改，我们再把更改后的全局变量值应用于主调函数中。函数被调用后被更改后的全局变量值即为函数的数个返回值。下面以一个实例演示该方法的应用。
实例1：编写函数求3个数中的最大值与最小值。
方法：把最大值、最小值分别定义成2个全局变量max、min，在用户自定义函数中把求出来的最大值与最小值分别赋给全局变量max、min。函数调用完毕后全局变量的max、min值即保存了函数要求返回的值。程序参考代码如下：
#include "stdio.h"
#include "conio.h"
int max,min;/*定义两个全局变量用于保存函数返回值*/
void max_min(int a,int b,int c) /*定义求最大最小值的函数*/
{max=min=a; /*初始化最大最小值*/
if(max if(max if(min>b)min=b;
if(min>c)min=c;
}
main()
{int x,y,z;
printf(" 请输入3个整数：\n");
scanf("%d,%d,%d",&x,&y,&z);
max_min(x,y,z) ;/*调用求最大值与最小值的函数*/
printf("三个数中的最大值为:%d;最小值为:%d",max,min);/*输出最大值与最小值*/
getch();
}
调试结果如下：
请输入3个整数：
5,-6,2
三个数中的最大值为:5;最小值为:-6
注意：该方法虽然可以实现有多个返回值的函数，但由于全局变量不能保证值的正确性(因为其作用域是全局，所以程序范围内都可以修改它的值，如果出现错误将非常难以发现)，并且全局变量增加了程序间模块的耦合，所以该方法要慎用。
3.传递数组指针
分析：在教学过程中，我们知道C语言函数参数的传递方式有值传递与地址传递。当进行值传递时，主调函数把实参的值复制给形参，形参获得从主调函数传递过来的值运行函数。在值传递过程中被调函数参数值的更改不能导致实参值的更改。而如果是地址传递，由于传递过程中从实参传递过来的是地址，所以被调函数中形参值的更改会直接导致实参值的更改。因此，我们可以考虑把多个返回值作为数组元素定义成一个数组的形式，并使该数组的地址作为函数的形式参数，以传址方式传递数组参数。函数被调用后，形参数组元素改变导致实参改变，我们再从改变后的实参数组元素中获得函数的多个返回值。以下实例演示该方法的应用。
实例2：编写函数求一维整形数组的最大值与最小值，并把最大值与最小值返回给主调函数。
方法：以指针方式传递该一维数组的地址，然后把数组的最大值与数组的第一个元素交换，把数组的最小值与最后一个元素交换。函数被调用完毕后，实参数组中的第一元素为数组的最大值，实参数组中最后一个元素为数组的最小值，从而实现返回数组的最大值与最小值的功能。程序参考代码如下：
#include "stdio.h"
#include "conio.h"
void max_min(int *ptr,int n) /*定义求数组最大值最小值的函数，传递数组指针*/
{int i,j,k;/*j保存最大值所在位置，k保存最小值所在位置*/
int *temp;/*用于交换位置*/
*temp=*ptr;
for(i=0;i {
if(*ptr<*(ptr+i))/*最大值与第一个元素进行交换*/
{
k=i;
*temp=*ptr;
*ptr=*(ptr+k);
*(ptr+k)=*temp ;
}
if(*(ptr+n-1)>*(ptr+i))/*最小值与最后一个元素进行交换*/
{
j=i;
*temp =*(ptr+n-1);
*(ptr+n-1)=*(ptr+j);
*(ptr+j)= *temp ;}
}
}
/*调用最大最小值函数*/
main()
{
int A[6],i;
for(i=0;i<6;i++)
scanf("%d",&A[i]);
max_min(A,6);
printf("max=%d, min=%d\n \n",A[0],A[5]);
getch();
}
调试结果如下：
请输入6个整形数,以空格隔开:
5 8 9 32 -6 4
max=32,min=-6
注意：该方法适用于多个返回值的数据类型一致的情况。当返回值数据类型不一致时，不适用该方法。
4.传递结构体指针
分析：结构体作为教学中的一个难点，教材对它介绍的内容并不多，应用的实例更是少之又少，所以学生对于结构体普遍掌握情况不理想。其实，编写返回多个值的C语言函数，也可以考虑采用结构体的方式去实现。通过方法2，我们知道如果返回的数个数值的数据类型不一致，可以通过定义全局变量实现有多个返回值的C语言函数，也可以考虑把要求返回的数个值定义成一个结构体，然后同样以传递结构体指针方式把结构体的指针传递给形参结构体指针，那么函数中对形参结构体的修改即是对实参结构体的修改，函数被调用后获取的实参结构体成员即为函数的多个返回值，下面以实例演示该方法的应用。
实例3：编写一个用户自定义函数，允许用户录入学生的基本信息(包括学号、姓名、所属班级、总评成绩)，并返回这些基本信息给主调函数。
方法：把学生基本信息定义成一个结构体，在用户自定义函数中传递该结构体的指针，则自定义函数中对结构体成员的录入操作即是对实参结构体成员的录入操作，从而实现多个返回值。参考代码如下：
#include "stdio.h"
#include "conio.h"
struct inf{/*定义学生结构体，分别包含成员学号、姓名、班别、总评成绩*/
char xh[12];
char name[20];
char class[15];
int chj;
};
main(void)
{
struct inf a1; /*定义学生结构体类型变量*/
void xxxx(struct inf *ptr);
printf("请输入学号,姓名,班别,总评成绩,以空格隔开:\n") ;
xxxx(&a1);/*调用函数，以学生结构体类型变量地址作为实参*/
printf("学号：%s,姓名： %s,班别：%s,总评成绩：%d",a1.xh, a1.name,a1.class,a1.chj);
getch();
}
void xxxx(struct inf *ptr)/*该函数实现对结构体成员数据的录入操作*/
{
char xh1[12],name1[20],class1[15];
int chj1;
scanf("%s%s%s%d",xh1,name1,class1,&chj1);
strcpy(ptr->xh,xh1);
strcpy(ptr->name,name1);
strcpy(ptr->class,class1);
ptr->chj=chj1;
}
调试结果如下：
请输入学号,姓名,班别,总评成绩,以空格隔开:
200102LiLi200185
学号：200102,姓名： LiLi,班别：2001,总评成绩：85
注意：当函数要求返回的多个值是相互联系的或者返回的多个值数据类型不一致时可以采用该方法。
5.结束语
对于以上这三种方法，如果想要返回的数个值数据类型一致，可以考虑采用方法2；而对于不同数据类型的返回值，如果各个数值之间是相互联系的，则方法3较为合适；方法1虽然在很多情况下都可以实现多个返回值的C语言函数，但毕竟全局变量应用过程中有很多危险，要慎重使用。
通过对以上几种方法的分析讲解，在教学过程中，学生再遇到这样的问题时，就能根据返回值的情况选择合适的途径去实现多个返回值的C语言函数。另外，如果再遇到类似的无法用教材知识点去直接解决的问题时，他们基本都能举一反三地尝试采用间接方式去解决。
参考文献
[1] 谭浩强. C程序设计(第二版)[M]. 北京:清华大学出版社,1999.
[2] 薛万鹏译. C程序设计教程[M]. 北京:机械工业出版社,2000.
[3] 邓劲生译. Visual C++程序员实用大全[M]. 北京:中国水利水电出版社,2005.
下面就是一些关于return存在意义的思考
1.停止执行，直接跳出到调用函数，下面的语句不执行，完成比break更猛的操作。
2.main函数的返回值表示程序的退出状态，如果返回0，代表着正常退出，反之。（很有仪式感）
3.返回给调用函数后期使用，其实当调用函数就是个入栈和出栈的过程，顺便说一下调用函数，调用函数时，这个函数的地址先入栈，函数参数入栈，局部变量入栈，然后调用结束后先进后出，这个在栈和堆中已经讲过，而rerurn就是提前结束调用，和break相似，但不同的是return可以返回参数。（也就是某个变量如果不返回就会在内存中释放掉，而你返回就会存在储存中保存下来当你再次使用指针或者这个变量时就能正确的使用它）
4.返回值和函数的参数有关
下面是一篇关于c语言返回值的文章
转自https://www.jb51.net/article/117059.htm
详解C语言函数返回值解析
程序一：
int main()
{
int *p;
int i;
int*fun(void);
p=fun();
for(i=0;i<3;i++)
{
printf("%d\n",*p);
p++;
}
return 0;
};
int* fun(void)
{
static int str[]={1,2,3,4,5};
int*q=str;
return q;
}
//不能正确返回
虽然str是在动态变量区，而该动态变量是局部的，函数结束时不保留的。
程序二：
int main()
{
char *p;
char*fun(void);
p=fun();
printf("%s\n",p);
return 0;
};
char * fun(void)
{
char *str="hello";
return str;
}
//可以正确返回
但是，字符串"hello"不是变量，而是一个常量，编译程序在处理这种常量时，通常把它放在了常量区中。而常量区则是始终存在的。
后一个例子中函数fun的返回值就是一个指向这种常量区的指针。
函数返回指针，要使主程序可以使用这个指针来访问有意义的数据，关键就是要保证在使用这个指针值的时候，该指针所指向的地方的数据仍然有意义。
还有，如果指针是指向函数的指针，那么这个指针就是指向程序代码区的。这也是一种应用的情况。
另外，如果明白了它的原理，程序员还可以发明出一些其他灵活的使用方法，当然，那都属于“怪”方法，一般不提倡的。
程序三：
int main()
{
int a,b;
int max;
int fun (int a,int b);
scanf("%d%d",&a,&b);
max=fun (a,b);
printf("\n%d\n",max);
return 0;
};
//http://www.bianceng.cn
int fun(int a,int b)
{
int max;
if(a>b)
max=a;
else
max=b;
return max;
}
//可以正确返回
程序三：
这个例子中，返回的不是变量max的地址，返回的是它的值。
return后面的东西，看做一个表达式，返回的是这个表达式的值。
例如，入口如果a是3，b是5，则此时（执行return语句时）max里面存的是5。而return语句的功能就是把max里面的5取出来，放到“返回值寄存器”中。
主程序是从“返回值寄存器”得到这个5的（此时max变量已经不存在了）。
你前面的第二个例子中，同样，指针变量str在函数结束后已经不存在了。但是在return语句中，把指针变量str里面的值（等于字符串"hello"存放处的地址）送到“返回值寄存器”中了。
动态变量str不存在了，但常量区中的字符串"hello"还存在。主程序根据返回的地址就可以找到该字符串。
程序四：
int main()
{
char *p;
char *fun(void);
p=fun();
printf("%x\n",p);
printf("%s\n",p);
return 0;
}
char* fun(void)
{
// char str[]={'a','b','c','d','e','f','\0'};
char str[]="hello";
printf("%x\n",str);
return str;
}
//不能正确返回
char str[]="hello"; 是在动态变量区中开辟了可以容纳6个字符的数组，数组名叫str。同时将字符串"hello"（原存放于常数空间）拷贝到这个数组空间中去作为数组的初始化值。
此时若执行return str; 其中的str是数组名。C语言规定，表达式中如果是数组名，则该表达式的值就等于这个数组的地址。所以返回的是这个数组的地址，请注意：并不是字符串常量"hello"的地址！而函数结束时，虽然常数空间并不破坏，但这个数组空间是破坏了的，而你返回的却不是常数空间里的地址而正是已经破坏了的数组的地址。
而char *str="hello"; 是在动态变量区中开辟了一个可以存放一个指针值的变量，名叫str。同时将原存放于常数空间的字符串"hello"的地址赋给这个指针变量作为初始值。
此时若执行return str; 其中的str是指针变量名。C语言规定，表达式中如果是变量名，则该表达式的值就等于这个变量的值(指针变量的值就是地址)。所以返回的是变量str的值，而变量str的值就等于字符串常量"hello"的地址。而函数结束时，变量str破坏了的，但常数空间中的字符串并不破坏。主程序根据返回的地址就可以找到该字符串。
【总结】
常规程序中，函数返回的指针通常应该是：
(1)指向静态（static）变量；
(2)指向专门申请分配的（如用malloc）空间；
(3)指向常量区（如指向字符串"hello"）；
(4)指向全局变量；
(5)指向程序代码区（如指向函数的指针）。
除这5项以外，其它怪技巧不提倡。
函数内的变量，没有关键字static修饰的变量的生命周期只在本函数内，函数结束后变量自动销毁。当返回为指针的时候需要特别注意，因为函数结束后指针所指向的地址依然存在，但是该地址可以被其他程序修改，里面的内容就不确定了，有可能后面的操作会继续用到这块地址，有可能不会用到，所以会出现时对时错的情况，如果需要返回一个指针而又不出错的话只能调用内存申请函数
返回结构体：
#include <stdio.h>
typedef struct {
int a;
int b;
int c;
}str;
str change(str s)
{
s.a += 1;
s.b += 1;
s.c += 1;
return s;
}
int main(void)
{
str s1, s2;
s1.a = 1;
s1.b = 1;
s1.c = 1;
s2 = change(s1);
printf("s1.a = %d\ts1.b = %d\ts1.c = %d\n",s1.a, s1.b, s1.c);
printf("s2.a = %d\ts2.b = %d\ts2.c = %d\n",s2.a, s2.b, s2.c);
return 0;
}
//可以返回
其他的重要知识
（1）使用指针的过程时一定要进行初始化指针或者赋值所使用内存的步骤类似于开出一片自己的领地
参考博客https://www.cnblogs.com/mfrbuaa/p/3756342.html
C语言指针的初始化和赋值
1、指针的初始化
指针初始化时，“=”的右操作数必须为内存中数据的地址，不能够是变量，也不能够直接用整型地址值(可是int*p=0;除外，该语句表示指针为空)。此时，*p仅仅是表示定义的是个指针变量，并没有间接取值的意思。
比如：
int a = 25;
int *ptr = &a;
int b[10];
int *point = b;
int *p = &b[0];
假设：int *p;
*p = 7;
则编译器（vs2008）会提示The variable 'p' is being used without being initialized.即使用了未初始化的变量p。
由于p是指向7所在的地址，*p = 7给p所指向的内存赋值，p没有赋值，所以p所指向的内存位置是随机的，没有初始化的。
int k;
int *p;
p = &k; //给p赋值
*p = 7; //给p所指向的内存赋值，即k= 7
2、指针的赋值
int *p;
int a;
int b[1];
p = &a;
p = b;
指针的赋值，“=”的左操作数能够是*p，也能够是p。
当“=”的左操作数是*p时，改变的是p所指向的地址存放的数据；
当“=”的左操作数是p时，改变的是p所指向的地址。
数组的变量名b表示该数组的首地址，因此p=b；也是正确的
同类型的指针赋值：
int val1 = 18,val2 = 19;
int *p1,*p2;
p1 = &val1;
p2 = &val2;
p1 = p2; //注意啦，p1指向了val2，而没有指向val1
备注：字符串与指针的初始化和赋值
初始化：
char *cp = "abcdefg"; //这个初始化过程，是将指针cp指向字符串的首地址，而并非传递字符串的值。由于，在C语言里面，没有总体处理一个字符串的机制
赋值：
cp = "abcdefg";
*cp=”abcdefg” ;//错误！字符串常量传递的是它的首地址，不能够通过*cp改动该字符串的值，由于该字符串为常量，而它仅仅是简单的将指针指向该字符串常量
3、指针常量
在C语言中没有一种内建（built-in）的方法去表示指针常量，所以当我们使用它的时候通常先写成整型常量的形式，然后再通过强制类型转换把它转换成对应的类型，如：int * , double * , char *等。 所以后面所看到的的做法是不行的： int *p = 0x12345678 ; 正确的方式应为：int *p = (int *) 0x12345678; 要注意指针中仅仅能存放地址，不能将一个非0值整型常量表达式或者其它非地址类型的数据赋给一个指针，原因就在此。在大多数计算机中，内存地址确实是以无符号整型数来表示的，并且多以16进制表示，但我们在C语言中不能用整型数去表示地址，仅仅能用指针常量来表示，由于它是被用来赋给一个指针的。
对于这个赋值问题还能够换一个角度去理解，在C语言中，使用赋值操作符时，赋值操作符左边和右边的表达式类型应该是同样的，假设不是，赋值操作符将试图把右边表达式的值转换为左边的类型。所以假设写出int *p = 0x12345678 ; 这条语句编译器会报错：'=' : cannot convert from ' const int ' to ' int * ' ，由于赋值操作符左边和右边的表达式的类型应该同样，而0x12345678是int型常量，p是一个指向int型的指针，两者类型不同，所以正确的方式是：int *p = (int *) 0x12345678 ;
4、指针初始化补充
ANSI C定义了零指针常量的概念：一个具有0值的整形常量表达式，或者此类表达式被强制转换为void *类型，则称为空指针常量，它能够用来初始化或赋给不论什么类型的指针。也就是说，我们能够将0、0L、'/0'、2–2、0*5以及(void *)0赋给一个不论什么类型的指针，此后这个指针就成为一个空指针，由系统保证空指针不指向不论什么对象或函数。
ANSI C还定义了一个宏NULL，用来表示空指针常量。大多数C语言的实现中NULL是採用后面这样的方式定义的：#define NULL ((void *)0)。
对指针进行初始化时经常使用的有下面几种方式：
1.採用NULL或空指针常量，如：int *p = NULL;或 char *p = 2-2; 或float *p = 0;
2.取一个对象的地址然后赋给一个指针，如：int i = 3; int *ip = &i；
3.将一个指针常量赋给一个指针，如：long *p = (long *)0xfffffff0;
4.将一个T类型数组的名字赋给一个同样类型的指针，如：char ary[100]; char *cp = ary;
5.将一个指针的地址赋给一个指针，如：int i = 3; int *ip = &i；int **pp = &ip;
6.将一个字符串常量赋给一个字符指针，如：char *cp = “abcdefg”;
对指针进行初始化或赋值的实质是将一个地址或同类型(或相兼容的类型)的指针赋给它，而无论这个地址是怎么取得的。要注意的是：对于一个不确定要指向何种类型的指针，在定义它之后最好把它初始化为NULL，并在解引用这个指针时对它进行检验，防止解引用空指针。另外，为程序中不论什么新创建的变量提供一个合法的初始值是一个好习惯，它能够帮你避免一些不必要的麻烦。
5、void *型指针
ANSI C定义了一种void *型指针，表示定义一个指针，但不指定它指向何种类型的数据。void *型指针作为一种通用的指针，能够和其他不论什么类型的指针(函数指针除外)相互转化而不须要类型强制转换，但不能对它进行解引用及下标操作。C语言中的malloc函数的返回值就是一个void *型指针，我们能够把它直接赋给一个其他类型的指针，但从安全的编程风格角度以及兼容性上讲，不妨将返回的指针强制转换为所需的类型，另外，malloc在无法满足请求时会通过返回一个空指针来作为“内存分配失败”的信号，所以要注意返回值指针的判空。
6、指向指针的指针
在指针初始化的第5种方式中提到了用一个指针的地址来初始化一个指针。回顾一下上一讲的内容：指针是一种变量，它也有自己的地址，所以它本身也是可用指针指向的对象。我们能够将指针的地址存放在还有一个指针中，如：
int i = 5000;
int *pi = &i;
int **ppi = π
此时的ppi即是一个指向指针的指针,下图表示了这些对象：
i的地址为108，pi的内容就是i的地址，而pi的地址为104，ppi的内容即是pi的地址。对ppi解引用照常会得到ppi所指的对象，所获得的对象是指向int型变量的指针pi。想要真正地訪问到i.，必须对ppi进行两次解引用，如以下代码所看到的：
printf("%d", i );
printf("%d", *pi );
printf("%d", **ppi );
以上三条语句的输出均为5000。
（2）“*”表示“指向” ；例如：int *pointer可以理解为pointer指向的那个变量是整形变量所以定义的时候要加一个可爱的“*”
还有就是*pointer代表它指向的变量因此等价于它所指向的那个变量，而pointer可以理解为一个地址但是地址也是一串数字因此同样可以赋值。
（3）c语言实参变量对于形参变量的数据传递是单向的“值传递”
（4）最后因为这些问题中的很多都是看两个数的交换发现的，于是吃水不忘挖井人，就拿这篇关于两个数交换的博文做结吧
c语言：多种方法实现两个数的交换
交换两个数的内容是c语言中常见的问题，所以在此总结一下我所学到的几种方法。
首先，举一个例子，假设a=10，b=20.
第一种方法，借助一个临时变量来进行保存，这是最容易也是最直观的方法。
代码如下：
int a, b, t;
a = 10;
b = 20;
printf("a=%d b=%d", a, b);
t = a;
a = b;
b = t;
printf("\n");
printf("a=%d b=%d", a, b);
实现结果如下：
在这种方法的基础上，可以借助指针写一个函数来交换两个数的大小。
代码如下：
void swap(int *pa, int *pb)
{
int tmp;
tmp = *pa;
*pa = *pb;
*pb = tmp;
}
int main()
{
void swap(int *pa, int *pb);
int a = 10;
int b = 20;
printf("a=%d b=%d\n", a, b);
swap(&a, &b);
printf("a=%d b=%d\n", a, b);
}
实现结果如下：
第二类方法，如果不允许借助第三个变量，该如何做呢？
此时，可以有如下几种办法。
1）加减运算，这种方法实际上就是先将a+b的结果暂时先保存在变量a中，通过改变后的a和原始的b进行减法就可以得到交换后的b，但是这种方法存在缺陷，a和b都是int型的话，可能会造成溢出。
代码如下：
int a = 10;
int b = 20;
printf("a=%d b=%d\n", a, b);
a = a + b;
b = a - b;
a = a - b;//同号时可能溢出
printf("a=%d b=%d\n", a, b);
2）乘除运算，与加减类似，用a*b替代a+b放在a中暂存，但是这种方法与加减运算一样有着缺陷，比加减运算更容易溢出。
int a = 10;
int b = 20;
printf("a=%d b=%d\n", a, b);
a = a*b;
b = a/b;
a = a/b;
printf("a=%d b=%d\n", a, b);
3）位运算，这种方法比起加减和乘除来说，并不会有溢出的可能。主要利用了异或的特性，将a^b的值存在a里，就可以顺利完成交换。
int a = 10;
int b = 20;
printf("a=%d b=%d\n", a, b);
a = a^b;
b = a^b;
a = a^b;
printf("a=%d b=%d\n, a, b);
总的来说，使用第一种借助第三变量方法更为直观，异或的方法也不会存在缺陷。这是两种较为常用的方法，但值得注意的是 ，在使用指针变量做交换时，形参的改变并不会影响实参的改变，采用单向值传递的方法，应该使他们的地址进行交换。
原文：https://blog.csdn.net/mxrrr_sunshine/article/details/78506186
这样今天所有的疑惑就基本搞明白了 明天继续学习指针 希望对能和我有一样问题的小伙伴有所帮助 ：）
最后因为最近很多东西不会，看到很多写的很好的博文就拿过来引用一下。如果有作者不愿意我引用他的文章可以联系我我会尽快删除