字符型二维数组；函数

1.字符型二维数组：
    "hello"
    "world"
    "how"
    "are"
    "you"

    在C语言中字符型二维数组主要用来存放字符串数组

#include <stdio.h>

int main(void)
{
	char str[5][32] = {"hello", "world", "how", "are", "you"};
	char ch[32] = {"hello world"};
	int i = 0;

	printf("============================\n");
	puts(ch);
	printf("============================\n");
	for (i = 0; i < 5; i++)
	{
		puts(str[i]);
	}
	printf("============================\n");
	for (i = 0; i < 5; i++)
	{
		printf("str[%d] = %s\n", i, str[i]);
	}
	printf("============================\n");
	puts(str[0]);
	puts(str[1]);
	puts(str[2]);
	puts(str[3]);
	puts(str[4]);

	return 0;
}

   1.定义：
        数据类型 数组名[第一维元素个数][第二维元素个数];

        char str[5][32];

    2.元素访问:
        str[0][0];
        str[0][1];
        str[0][2];

        str[0]
        str[1]
        str[2]
        str[3]
        str[4]

    3.数组存储:
        连续性：数组元素存放空间连续
        有序性：数组元素存放顺序有序

    4.数组的初始化:
        1.局部初始化:
            char str[3][32] = {{'h', 'o', 'w', '\0'}, {'a', 'r', 'e', '\0'}, {'y', 'o', 'u', '\0'}};
            char str[3][32] = {{"how"}, {"are"}, {"you"}};
            char str[3][32] = {"how", "are", "you"};
            char str[3][32] = {0};

        2.默认初始化:
            char str[][32] = {"how", "are", "you"};

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

int main(void)
{
	char str[5][32] = {0};
	int i = 0;
	int j = 0;
	char temp[32] = {0};

	for (i = 0; i < 5; i++)
	{
		gets(str[i]);
	}
	
	for (j = 0; j < 4; j++)
	{
		for (i = 0; i < 4-j; i++)
		{
			if (strcmp(str[i], str[i+1]) > 0)
			{
				strcpy(temp, str[i]);
				strcpy(str[i], str[i+1]);
				strcpy(str[i+1], temp);
			}
		}
	}

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

	return 0;
}

=========================================================================

1.函数：
     1.能够让程序模块化
     2.可以减少重复性代码

    1.函数的三种形式:
        1.函数的定义：
            函数类型  函数名（数据类型1 形参1, 数据类型2 形参2, ...）
            {
                函数体;

                return 返回值;
            }

#include <stdio.h>

int fun(int x, int y)
{
	if (x > y)
	{
		printf("%d > %d\n", x, y);
	}
	else 
	{
		printf("%d <= %d\n", x, y);
	}

	return 0;
}

int main(void)
{
	int a = 10;
	int b = 20;
	int m = 100;
	int n = 200;
	int p = 1000;
	int q = 2000;
	
	fun(a, b);
	fun(m, n);
	fun(p, q);

	return 0;
}

            函数名：和变量名要求保持一致
            函数类型：函数运行结果的类型（如果返回值类型与函数类型不一致,会将返回值强制类型转换成函数类型返回） 
                     不写函数类型默认为int类型
                     如果没有返回值,函数类型应该为void类型 
            返回值：函数的运行结果
            形参：形式参数（做个样子）

            注意：
                函数没有返回值,return后面什么都不写

      2.函数的调用：
            函数名(实参1, 实参2, ...);

            注意：
                1.实参个数必须与形参个数一致，并一一对应
                2.实参可以是常量、变量、表达式
                3.实参与形参类型不一致时,会将实参强制类型转换为形参类型,传入函数中
                4.函数调用时会发生传参的过程（实参将值传递给形参）

#include <stdio.h>

int Add(int x, int y);
int Sub(int x, int y);
int Mul(int x, int y);
double Div(int x, int y);

int Add(int x, int y)
{
	int ret = 0;

	ret = x + y;

	return ret;
}

int Sub(int x, int y)
{
	int ret = 0;

	ret = x - y;

	return ret;
}

int Mul(int x, int y)
{
	int ret = 0;

	ret = x * y;

	return ret;
}

double Div(int x, int y)
{
	double ret = 0;

	ret = (double)x / (double)y;

	return ret;
}

int main(void)
{
	int Num1 = 0;
	int Num2 = 0;
	int Result = 0;
	double DivRes = 0;

	scanf("%d%d", &Num1, &Num2);

	Result = Add(Num1, Num2);
	printf("ADD:%d\n", Result);

	Result = Sub(Num1, Num2);
	printf("SUB:%d\n", Result);

	Result = Mul(Num1, Num2);
	printf("MUL:%d\n", Result);

	DivRes = Div(Num1, Num2);
	printf("DIV:%.2lf\n", DivRes);

	return 0;
}

        3.函数的声明：
            声明和定义的区别：
                1.声明：声明一个已经存在的变量或函数
                2.定义：定义一个之前不存在的变量或函数,需要开辟新的空间

            注意：
                被调函数在主调函数下方定义,需要声明该函数

2.变量的作用域和生存周期：
        1.作用域：
            变量能够使用的范围

            1.局部变量：
                局部变量作用域在离定义该变量最近的大括号内
            2.全局变量：
                全局变量作用域在整个文件中

        2.生存周期：
            变量从开始被创建，到空间被回收的整个过程 

            1.变量的存储类型：
                存储类型 数据类型 数组名;
                int a;

                1.自动型存储（局部存储）（默认存储类型）
                    auto 

                    auto int a;
                    int a;

                    将变量存放到栈区中：
                        1.未经初始化值为随机值
                        2.代码执行到变量定义时为变量开辟空间
                        3.超过变量的作用域回收变量空间

                2.静态存储
                    static 

                    static int a;
                    
                    将变量存放到数据区中：
                        1.未经初始化前值为0值
                        2.编译时为变量开辟空间
                        3.代码执行结束回收变量空间

#include <stdio.h>

static int Num3;

int Add(int x, int y)
{
	int ret = 0;

	ret = x + y;

	return ret;
}

int Sub(int x, int y)
{
	
	return 0;
}

int main(void)
{
	int Num1 = 0;
	int Num2 = 0;	
	static int TmpNum;

	printf("TmpNum = %d\n", TmpNum);
	printf("Num3 = %d\n", Num3);
//	scanf("%d%d", &Num1, &Num2);

//	Add(Num1, Num2);
	
	return 0;
}

                    除了修饰静态变量,还有2个功能：
                        1.限定变量的作用域只能在本文件中使用
                        2.可以防止多个文件中的全局变量重名

#include <stdio.h>

int c;

int main(void)
{
	int i = 0;

	for (i = 0; i < 3; i++)
	{
		int a = 0;
		static int b = 0;
	
		a++;
		b++;
		c++;

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

	return 0;
}

                3.寄存器存储：
                    register 

                    register int a;

                    优先存放到CPU内部的寄存器中,如 果寄存器存满了,等价于auto存放在栈区中
                

#include <stdio.h>

int main(void)
{
	register int a;
	int i = 0;
		
	for (i = 0; i < 100000; i++)
	{
		a = i;
	}
	
	for (i = 0; i < 100000; i++)
	{
		printf("%d\n", a);
	}

	return 0;
}

                4.外部存储：
                    extern

                    extern int a;

                    声明一个变量或函数是在外部存储的

#include <stdio.h>

extern int Num1;
extern int Num2;
extern int Add(int x, int y);

int main(void)
{
	int sum = 0;

	sum = Add(Num1, Num2);

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

	return 0;
}

int Num1 = 100;
int Num2 = 200;

int Add(int x, int y)
{
	return x + y;
}

        3.函数的传参：
            1.赋值传递（复制传递）
                函数体内想使用函数体外部变量的值,使用复制传递
                函数体外部想获得函数体内部值的时候,通过返回值获得

        （主要为了想访问而无法访问的变量）

#include <stdio.h>

int Add(int x, int y)
{
	int ret = 0;

	ret = x + y;

	return ret;
}

int main(void)
{
	int Num1 = 100;
	int Num2 = 200;
	int Result = 0;

	Result = Add(Num1, Num2);
	printf("Result = %d\n", Result);

	return 0;
}

            
            2.全局变量传递
 

#include <stdio.h>

int Num1 = 0;
int Num2 = 0;
int Sum = 0;

void Add(void)
{
	Sum = Num1 + Num2;

	return;
}

int main(void)
{
	Num1 = 100;
	Num2 = 200;

	Add();
	
	printf("Sum = %d\n", Sum);

	return 0;
}