函数定义使用说明递归参数函数指针，李白打酒，程序例子

函数定义

#include <stdio.h>

// 函数：
/*
函数三要素：
返回值 (由关键字 return 进行返回)
函数名(数字、字母、下划线，不能以数字开头)
函数参数放在括号里面，每一个参数之间以逗号隔开
{}内部叫函数定义，函数功能的实现
*/
int max(int a, int b)
{
if (a > b)
return a;
else
return b;
}

int main()
{

int a = 10;
int b = 20;

// 函数调用，使用函数的地方函数调用
// 
int c = max(b, a);

printf ("%d\n", c);


return 0;
}

函数使用

#include <stdio.h>


// 求1----n的和
int sum(int n)
{
int i;
int res = 0;
for (i = 1; i <= n; i++)
{
res += i;
}

return res;
}


int main()
{
int res = sum(100);

printf ("%d\n", res);

return 0;
}

函数声明

#include <stdio.h>


// 函数声明
// 声明的东西：
/*
1、返回值
2、函数名
3、各个参数类型


int max(int, int);
*/
int max(int a, int b);


int main()
{
int a = 10;
int b = 20;
int c = 0;
c = max(a, b);
printf ("%d\n", c);

return 0;
}


// 函数定义
int max(int a, int b)
{
return (a>b ? a : b);
}

空类型韩束

#include <stdio.h>


void printA()
{
printf ("Hello World\n");
}


void printB(void)
{
printf ("Hello World\n");
}


int main1()
{
printA();

return 0;
}


int main()
{
// printA 没有参数 参数可以任意个
printA(1,2,3,4,5,6,7);

printB(1,2);

return 0;
}

递归

#include <stdio.h>




// 阶乘函数,求n的阶乘
int func(int n)
{
if (n == 1)
return 1;

int res = n * func(n-1);

return res;
}


// 求斐波那契数列中第n个数的值
int feibo(int n)
{
if (n == 0 || n == 1)
return n;

int res = feibo(n-1) + feibo(n-2);

return res;
}


int main()
{
int a = 0;

a = func(4);

int b = feibo(9);

printf ("%d\n", b);

return 0;
}

十进制转二进制

#include <stdio.h>


#define BASE 3


int main1()
{
int a = 12;

scanf ("%d", &a);

int s[10]= {0};
int i = 0;
while (a)
{
s[i++] = a % 2;
a /= 2;
}

for (i = i-1; i >= 0; i--)
{
printf ("%d", s[i]);
}

printf ("\n");

return 0;
}






void tran(int n)
{
if (n == 0)
return;

// printf ("%d", n%2);
tran(n/BASE);
printf ("%d", n%BASE);
return;
}


int main()
{
int a = 12;

tran(12);
printf ("\n");

return 0;
}

十进制转16进制

#include <stdio.h>


#define BASE 16


char num2char(int num)
{
switch (num)
{
case 0:
return '0';
case 1:
return '1';
case 2:
return '2';
case 3:
return '3';
case 4:
return '4';
case 5:
return '5';
case 6:
return '6';
case 7:
return '7';
case 8:
return '8';
case 9:
return '9';
case 10:
return 'A';
case 11:
return 'B';
case 12:
return 'C';
case 13:
return 'D';
case 14:
return 'E';
case 15:
return 'F';
}
}


void tran1(int n)
{
if (n == 0)
return;

// printf ("%d", n%2);
tran1(n/BASE);
printf ("%c", num2char(n%BASE));
return;
}


void tran2(int n)
{
if (n == 0)
return;

// printf ("%d", n%2);
tran2(n/BASE);

if (n%BASE > 9)
printf ("%c", n%BASE - 10 + 'A');
else
printf ("%d", n%BASE);
return;
}


int main()
{
int a = 12;

tran2(28);
printf ("\n");

return 0;
}


李白打酒

#include <stdio.h>


int count = 0;


void libai(int store, int flower, int alco, int pre, char *ch, int index)
{
if(store == 0 && flower == 0)
{
if (alco == 0 && pre == 0)
{
int i = 0;
for (i = 0; i < 15; i++)
{
printf ("%c", ch[i]);
}
printf ("\n");
count++;
}
return ;
}

if (store > 0)
{
ch[index] = 'a';
libai(store-1, flower, alco*2, 1, ch, index+1);// 1代表碰到的是店
}


if (flower > 0)
{
ch[index] = 'b';
libai(store, flower-1, alco-1, 0,ch, index+1);// 0代表碰到 的是花
}

}




void libai2(int alco, int store, int flower)
{
if (store > 5 || flower > 10)
return;

if (store == 5 && flower == 9)
{
if (alco == 1)
count++;
return ;
}
libai2(alco*2, store+1, flower);


libai2(alco-1, store, flower+1);
}


int main()
{

//libai2(2, 0, 0);
char ch[20];
libai(5, 10, 2, -1, ch, 0);

printf ("%d\n", count);

return 0;
}

局部变量全局变量

#include <stdio.h>


// 全局变量，全局变量的范围是从它定义的那个位置开始，到这个文件的结尾
// 全局变量如果不初始化，默认值是0
int g_a;  


// 局部变量：{}内部定义的变量  全局变量 函数外部定义的变量
// 局部变量的作用域是它所在{}范围之内
int add(int a, int b)
{
printf ("g_a = %d\n", g_a);
g_a ++;

int sum = a + b;   // sum是局部变量 是函数add的局部变量 作用域范围是add函数

return sum;
}


int main1()
{
g_a = 1;
int res = add(10, 30);

printf ("main:g_a %d\n", g_a);

printf ("%d\n",res);

return 0;
}


int a = 10;


int main()
{
printf ("1 : %d\n", a);
int a = 20;
// 当局部变量与全局变量冲突的时候，使用局部变量
printf ("2 : %d\n", a);
// {}内部的变量变量，范围是{}之内，出了{}不能再使用
{
int a = 30;
a = 50;
printf ("3 : %d\n", a);
}
printf ("4: %d\n", a);
return 0;
}

指针做函数参数

#include <stdio.h>


// 错误的交换
int swap1 (int a, int b)
{
int tmp = a;
a = b;
b = tmp;
}




// int *pa = &a
int swap(int *pa, int *pb)
{
int tmp = *pa;
*pa = *pb;
*pb = tmp;
}


int main()
{
int a = 10;
int b = 20;

swap(&a, &b);

printf ("a = %d, b = %d\n", a, b);


return 0;
}

数组做函数参数

#include <stdio.h>
#include <string.h>
// C语言不支持数组之间的直接赋值
// 数组名是指向数组首个元素的地址
// 数组名作函数参数 需要一个数组指针来接
// 在函数定义中  int a[10] 这样的形参定义方式会被转化成 int *a
//void printA(int pa[100000])
void printA(int pa[])
//void printA(int *pa)
{
int i;

// 指针的大小是四个字节
printf ("%d\n", sizeof(pa));

for (i = 0; i < 10; i++)
{
printf("%d\n", pa[i]);
}
}


// 数组作函数参数的时候，没有办法通过指针获取数组的长度
// 数组的长度要作为参数传给函数
void printB(int *a, int len)
{
int i;
for (i = 0; i < len; i++)
{
printf ("%d\n", a[i]);
}
}


int main1()
{
int a[15] = {1,2,3,4,5,6,7,8,9,0, 11,12,13,14,15};

printA(a);

printB (a, sizeof(a)/sizeof(a[0]));


return 0;
}


// 将数组逆序
void rev(int *a, int len)
{
int min = 0;
int max = len-1;
int tmp;
while (min < max)
{
tmp = a[min];
a[min++] = a[max];
a[max--] = tmp;
}
}


int main2()
{
int a[10] = {1,2,3,4,5,6,7,8,9,0};
int len = sizeof(a)/sizeof(a[0]);
rev(a, len);

printB(a, len);

return 0;
}


// while(1);   for (;;){}


// 求字符串长度
int myStrlen(char *str)
{
int len = 0;
while (str[len])
len++;

return len;
}


int myStrlen1(char *str, int n)
{
if (str[n])
{
int len = myStrlen1(str, n+1);
return len;
}
else
return n;
}


int main3()
{
char str[] = "hello";

int len = myStrlen1(str, 0);

printf ("%d\n", len);

return 0;
}


// 将字符串逆序
void reverse(char *str)
{
int len = strlen(str);
int min = 0;
int max = len - 1;
char tmp;
while (min < max)
{
tmp = str[min];
str[min++] = str[max];
str[max--] = tmp;
}
}


// I am from shanghai
int main()
{
char str[] = "you are from shanghai";

// 整个句子逆序
reverse(str);

char *p1 = str;
char *p2 = str;
while (*p2)
{
if (*p2 == ' ')
{
*p2 = '\0';
reverse(p1);
*p2 = ' ';
p1 = p2+1;
}
p2++;
}

reverse(p1);

puts(str);

return 0;
}




#include <stdio.h>


void printA(int (*b)[3], int len)
{
int i,j;
for (i = 0; i <len; i++)
{
for (j = 0; j < 3; j++)
printf ("%4d", b[i][j]);

printf ("\n");
}
}




int main1()
{
int b[2][3] = {{1,2,3}, {4,5,6}};
printA(b, 2);

return 0;
}


void printB(char *str[], int len)
//void printB(char **str, int len)
{
int i;
for (i = 0; i < len; i++)
{
printf ("%s\n", str[i]);
}
}


int main2()
{
char *str[] = {"abc", "efg", "hello", "world"};
printB(str, sizeof(str)/sizeof(str[0]));

return 0;
}


// main函数参数
// int main(int argc, char *argv[])
// argc 命令行传过来的参数个数
// argv 命令行传过来的参数的值，是一个字符指针数组
int main3(int argc, char **argv)
{
printf ("argc = %d\n", argc);
//char *str[] = {"./a.out", "1","2", "3", "4"};
int i;
for (i = 0; i < argc; i++)
{
printf ("%s\n", argv[i]);
}

return 0;
}


int main(int argc, char** argv)
{
if (argc != 4)
{
printf ("Usge:%s num1 op num2\n", argv[0]);
return -1;
}
int a = atoi(argv[1]);
int b = atoi(argv[3]);
int res;

//switch (*argv[2])
switch (argv[2][0])
{
case '+':
res = a + b;
break;
case '-':
res = a - b;
break;
case '*':
res = a * b;
break;
case '/':
res = a / b;
break;
}
printf ("%d\n", res);

return 0;
}

指针函数做参数

#include <stdio.h>


// 不能返回函数内局部变量的地址，在函数执行结束的时候
// 局部变量的空间已经被释放
int* func()
{
int a = 10;

return &a;
}




int main()
{
int *a = func();
printf ("hello world\n");
printf ("%d\n", *a);


return 0;
}

找合法帧

#include <stdio.h>
#include <string.h>


// 在字符串str中寻找字符串sub，如果找到返回从sub开始的字符串
char *findStr(char* str, char *sub)
{
char *p = NULL;
int len = strlen(sub);  // 算字串的长度
while(*str)
{
if (strncmp(str, sub, len) == 0)
{
p = str;
break;
}
str++;
}

return p;
}


// 找合法帧
void findFrame(char *str, char *head, char *tail)
{
char *phead = findStr(str, head);  // 找帧头的位置
char *ptail = findStr(str, tail);  // 找帧尾的位置

if (phead != NULL && ptail != NULL)
{
ptail += strlen(tail);
*ptail = '\0';

printf ("%s\n", phead);
}


}


int main()
{
char str[] = "asdheadhauboisoktailgdg";
findFrame(str, "head", "tail");

return 0;
}

函数指针

#include <stdio.h>


// 函数名代表函数空间的入口地址
// 函数名是地址，可以用指针去接收


// 返回值，函数名，参数列表
// 函数指针：表明函数的返回值与参数列表
int add (int, int);


int add (int a, int b)
{
return a+b;
}


int sub (int a, int b)
{
return a-b;
}


int mul (int a, int b)
{
return a*b;
}


int div (int a, int b)
{
return a/b;
}


// 如果函数指针作函数的操作，把这个函数指针叫做回掉函数
int func(int (*pfunc)(int, int), int a, int b)
{
int res = pfunc(a, b);

return res;
}




int main()
{
int a = 10; 
int b = 20;
char ch;
int res;
scanf ("%c", &ch);
switch (ch)
{
case '+':
res = func(add, a, b);
break;
case '-':
res = func (sub, a, b);
break;
case '*':
res = func(mul, a,b);
break;
case '/':
res = func(div, a, b);
break;
}
printf ("%d\n", res);
return 0;
}


// int (*b)[3]
int main1()
{
// 定义一个函数指针，指向一个函数，这个函数有一个int型返回和两个int的参数
int (*p)(int, int) = add;

p = mul;

// int sum = add(10, 30);
// 可以将函数指针当成函数名使用
int sum = p (10,30);

printf ("%d\n", sum);

return 0;
}