C语言自创函数

#include <stdio.h>
int p()/*平常我们都是直接定义主函数，现在主函数在下面去了，
这个P（）就是我们的自创函数自创函数和主函数一样的书写。这个自创函数为无定义型*/
{
    printf("小红在CSDN上学习");
    return 0;
}
int study(int num)/*这个也是自定义函数，这个是定义了参数的自创函数*/
{
    printf("小红在CSDN上已经参与学习了%d门课程",num);
    return 0;
}
int main()
{
    p();
    study(5);//此处的参数会传递给第二个有参数的自定义函数。
    return 0;
}

输出结果：

同理如果我们把主函数中的study参数设置为6结果就是下面这个啦！

为了方便理解可以再参考C语言中使用自定义函数计算三角形周长
----------------------------------分割线----------------------------------
本人承诺以上文章为本人编写，绝非复制粘贴。写在这里一是为了防止以后自己将知识点遗忘，二是为了和大家分享我自己对这个知识点的理解和认识。如果我的文章中有错误希望看到后可以指正，感激不尽！

C语言 子函数改变指针指向的值

首先，为了防止出错，我还在在《C primer plus》中再看了一次概念。
如下：

指针是个左值，就跟我们定义一个 int a = 10;一样。

接着再查找间接运算符*的说明。
如下：

首先我们写个对的。

#include <stdio.h>

int b = 30;

void trans(int** n)
{
	//int b = 30;//不能在里面进行定义堆栈会回收释放
	*n = (int*)&b;
	printf("b add =%p\n", &b);
	printf("*n  add =%p\n", *n);
	printf("**n =%d\n", **n);
}

int main()
{
	int a=10;
	int* p = (int*)&a;//指针创造的也只是个左值，指向地址。
	
	printf("p add =%p\n", p);
	
	trans(&p);
	
	printf("a add =%p\n",&a);
	printf("p  add =%p\n",p);
	printf("*p =%d\n",*p);
	return 0;
}

这里可以通过子函数改变指针指向的地址。
结果图：

换个失败的子函数，也是容易犯的错误

void trans(int* n)
{
	n = (int *)&b;
	//*n = 33;
	printf("b add =%p\n", &b);
	printf("*n add =%p\n", n);
	printf("*n =%d\n",*n);
	
}

结果图：

可以看到指向并没有改变。

这里我想讲讲我的理解：

子函数涉及堆栈区操作，在子函数要有一个压栈创建临时变量的工作，如果只是一个临时变量的话，则用完之后就会释放，而如果是地址传递则是直接对全局变量区进行操作，所以值能改变，自然就变成了指向的改变。

当然肯定有小伙伴说我为什么要用子函数来进行指针指向的改变，这样只会增加我的大脑负担啊。

没错，的确是这样的！！！

这种容易引起误会的操作在大量的代码工作中只会让我们疲于应对。

本人只是闲暇之余的探讨。如果一定要用到子函数来改变指针的指向的话最好子函数返回赋值给指针。

如：

int *p = get_new_arg(参数，参数);

c语言子函数返回字符串的错误

最近做leetcode上的一道题，通过子函数返回字符串。开始时用局部变量的字符串返回的，认为返回了字符串的首地址，便可以get到这个字符串，但由于局部变量离开函数后被回收了，因此字符串首地址是收到了，但是所在内容却被回收，因此出错。

//这是出错代码
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
char* intToRoman(int num) {
	int base[13] = { 1000,900,500,400,100,90,50,40,10,9,5,4,1 };
	char * basestr[13] = { "M","CM","D","DM","C","XC","L","XL","X","IX","V","IV","I" };
	int count[13];
	for (int i = 0; i < 13; i++) {
		count[i] = num / base[i];
		num -= base[i] * count[i];
	}
	char s[100];//这样子是局部变量
	int index = 0;
	for (int i = 0; i < 13; i++) {
		for (int j = 0; j < count[i]; j++) {
			strcpy(s + index, basestr[i]);
			index += strlen(basestr[i]);
		}
	}
	s[index] = '\0';
	return s;
}
int main() {
	printf("%s",intToRoman(3));
}

正确做法

法一：通过malloc函数分配
因为malloc函数分配内存在堆区，运行过程中由程序员自己管理，系统不回收。

char* intToRoman(int num) {
	int base[13] = { 1000,900,500,400,100,90,50,40,10,9,5,4,1 };
	char * basestr[13] = { "M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I" };
	int count[13];
	for (int i = 0; i < 13; i++) {
		count[i] = num / base[i];
		num -= base[i] * count[i];
	}
	char *s=(char*)malloc(sizeof(char)*100);
	int index = 0;
	for (int i = 0; i < 13; i++) {
		for (int j = 0; j < count[i]; j++) {
			strcpy(s + index, basestr[i]);
			index += strlen(basestr[i]);
		}
	}
	s[index] = '\0';
	return s;
}

法二：
通过引用传递（或者说传指针）
法三：
全局变量（不推荐）