c 语言学习：基本操作，数组，字符串，指针

c语言学习连接：

1. https://blog.csdn.net/zpj779878443/article/details/78229049
2. http://www.runoob.com/cprogramming/c-function-getchar.html

基本操作

判断闰年平年

// 判断闰年平年
#include <stdio.h>
int main()
{
    int year;
    printf("请输入需要判断的年份:\n");
    scanf("%d",&year);
// 能被4除尽，前提不是整百年；整百年被400除尽
    if(!(year%4)&&(year%100)||!(year%400)&&!(year%100))
    {printf("%d年是闰年\n",year);}
    else 
	{printf("%d年不是闰年\n",year);}
    return 0; 
}

倒序输出五位数

// 倒序输出五位数
#include <stdio.h>
int main()
{
    int a,i;
    printf("请输入需要倒序输出的五位数\n");
    scanf("%d",&a);//通过&a获得存放这个数据的内存地址的值
    printf("输出倒序后的五位数:\n");
    for(i = 0;i<5;i++)//循环5次
    {
        printf("%d",a%10);
        a /= 10;
    }
}

赋值运算

// 赋值运算
// 括号最大 > ！ > 算数运算符 > 关系运算符 > 逻辑与或 > ß赋值运算符
#include <stdio.h>
int main()
{
    int a,b,c;
    //普通赋值:
    a = 2,b= 6,c = 26;
    a *= b = c = 3;     //a = 6,b=3,c=3;
    printf("a = %d,b = %d,c = %d\n",a,b,c);
    a += b +=c;         //a = 12,b=6,c =3
    printf("a = %d,b = %d,c = %d\n",a,b,c);
    a = b == c + 5;     //a = 0,b = 6,c = 3
    printf("a = %d,b = %d,c = %d\n",a,b,c);
    return 0;
}

用条件表达式求三个数的最大值

//用条件表达式求三个数的最大值
#include <stdio.h>
int main()
{
    int a,b,c;
    int max;
    printf("请输入三个数:\n");
    scanf("%d%d%d",&a,&b,&c);
    a > b ? (max = a):(max = b);
    max > c ? (max = max):(max = c);
    printf("输出最大值:%d\n",max);
    return 0;
}

// 逗号表达式的值
#include <stdio.h>
int main()
{
    int a,b,c;
    a = b = c = 1;
	// 逗号表达式遵从从左到右，赋值取最右边的值
    c = (a = 10,b = 10,2 * a + 5,a + a * b + c);
    //输出结果:10,10,111;
    printf("a = %d,b = %d,c = %d\n",a,b,c);
    return 0;
}

测试int,float,char类型在本机所占的字节数

// sizeof：通常用来测试某个数据类型所占的内存空间大小
// 测试的是int,float,char类型在本机所占的字节数

#include <stdio.h>    
int main()    
{    
    int a = 1;    
    float b = 1.1;    
    char c = 'cv';    
    printf("%d,%d,%d\n",sizeof(a),sizeof(b),sizeof(c));    
    return 0;    
}  

单个字符的输入getchar()

//单个字符的输入getchar()，输出putchar()
// getchar用法
#include <stdio.h>    
int main()    
{    
    char a,b;
	a = getchar();
	b = getchar();
    printf("输出存储的字符\n%c%c\n",a,b);    
    return 0;    
}  

输出结果

为什么只输出第一个字符和一个回车，第二个字符还没输入就结束了？
答：这是因为getchar()可以获取一个换行符，更改代码如下：

#include <stdio.h>    
int main()    
{    
    char a,b;
	a = getchar();
	getchar();
	b = getchar();
    printf("输出存储的字符\n%c\n%c\n",a,b);    
    return 0;    
}  

修改后输出：

使用*抑制符跳过输入的某个值

//scanf和printf语句
#include <stdio.h>    
int main()    
{    
    int a,b,c;  

    //1.正常的scanf的用法    
    scanf("%d%d%d",&a,&b,&c);    
    printf("a = %d b = %d c = %d\n",a,b,c);   

    //2.使用*抑制符跳过输入的某个值    
    scanf("%3d%*2d%2d%3d",&a,&b,&c);    
    printf("a = %d b = %d c = %d\n",a,b,c);  

    //3.最好不要在scanf里面写逗号和空格之类的,不然输入    
    //输入的时候必须把这些都写上    
    scanf("%d,%d,%d",&a,&b,&c);    
    printf("a = %d b = %d c = %d\n",a,b,c);    
    return 0;    
}    

判断if,else

//判断结构中的双分支结构-if else语句
//取钱时判断是否为100的倍数
#include <stdio.h>    
int main()    
{    
    int money;  
    printf("请输入你要取款的金额\n");
    scanf("%d",&money);    
    	
	if (money%100)
        printf("输入金额错误，请重新输入100的倍数\n");	
    else 
	    printf("出钞%d\n",money);
    return 0;    
}    

数组

选择排序

// 选择排序
// 思路，两个for循环，两两比较，如果前者大于后者，交换位置
#include <stdio.h>
int main()
{
    int i,j,t,a[4];    //输入n个数字，n=4
    printf("please enter 4 integer\n");
    for(i=0;i<=3;i++) //输入数值
        scanf("%d",&a[i]);    
    for(i=0;i<=2;i++)  //从第一个数开始，执行n-1次
        for (j=i+1;j<=3;j++)  //从第i+1开始比较
            if(a[i]>a[j])    
            {
                t=a[i];
                a[i]=a[j];
                a[j]=t;
            }
    printf("\n");
    for(i=0;i<=3;i++)
        printf("%5d", a[i]); 
    printf("\n");
    return 0;
}

冒泡排序法

// 冒泡排序法
//原理：用冒泡排序法的升序排列对任意输入的 10 个数按照从小到大的顺序进行排序。从最左边开始，比较相邻的两位数字，将大的那个放在右边，依次类推，第一轮结束后最大值就是最右边的数字。

#include <stdio.h>
int main()
{
    int i,j,t,a[5];  
    printf("input 4 integer\n");
    for(i=1;i<5;i++)
        scanf("%d",&a[i]);   
        
    for(i=1;i<4;i++)     //变量i代表比较的趟数(趟数=数字个数-1)
        for(j=1;j<5-i;j++)    //变最j代表每趟两两比较的次数
            if(a[j]>a[j+1])
            {
                t=a[j];    //利用中间变童实现两值互换
                a[j]=a[j+1];
                a[j+1]=t;
            }
            printf("排序后的顺序是：\n");
        
	for(i=1;i<=4;i++)
        printf("%5d",a[i]);    //将冒泡排序后的顺序输出
        printf("\n");
    return 0;
}

矩阵转置

// 矩阵转置
#include <stdio.h> 
int main()
{   
    int i,j;
    int a[3][4],b[4][3];
    printf("please enter an aray element of a:\n");
    // aray a
    for(i=0;i<3;i++)
    {
    	for(j=0;j<4;j++)
    	scanf("%d",&a[i][j]);	
	}
	// transpose of a matrix
	    for(i=0;i<3;i++)
    {
    	for(j=0;j<4;j++)
    	b[j][i]=a[i][j];
	}
	// output aray b
    printf("output aray b\n");
    for(i=0;i<4;i++)
    {
    	for(j=0;j<3;j++)
    	printf("%d",b[i][j]);
    	printf("\n");
	}
    return 0;
}

字符串操作

strcpy()复制, puts

// strcpy()复制
// puts()函数会在字符串末尾自动的添加换行符,也就是说它会自动的换行,
// 而printf()函数就没有这项功能
#include <stdio.h>
#include<string.h> 
int main()
{
	char c1[]="hello\0",c2[15];
	strcpy(c2,c1);
	puts(c2);                                        // hello
	printf("输出字符数组c2的长度：%d\n",sizeof(c2));   // 15
	return 0;
}

strcat()拼接

// strcat()拼接 
#include <stdio.h>
#include<string.h> 
int main()
{
	char c1[]="hello world",c2[10];
	//除了字符串，这里还可以连接字符数组
    strcpy(c2,c1);
	strcat(c1,"pig"); //直接在c1后面拼接 
	strcpy(c2,"pig"); // 后面的字符数组复制到c2中，c2原来的数组清零，但是c2长度不变
	puts(c1);
	puts(c2);
	return 0;

结果：

求字符串和字符数组的长度

// 求字符串和字符数组的长度
#include <stdio.h>
int main()
{
    int i=0,n=0;
    char c[]="abcd\0-";
    while(c[i++]!='\0')
	{
		n++;
	}
	
    printf("输出字符串的长度:%d\n",n);//4, 字符串的结束标志为\0，之后的字符不属于该字符串了 
    n = sizeof(c)/sizeof(char);       //字符数组长度=sizeof(数组名)/sizeof(数组原始类型) 
    printf("output the length of c:%d\n",sizeof(c));     //7,sizeof(数组名)
    printf("output the length of c:%d\n",sizeof(char));  //1,字符数组一定有个空字符串\0作为字符串的结束标志 
    printf("输出字符数组的长度:%d\n",n); //7
    
    for(i=0;i<7;i++)
    {
    	printf("%c",c[i]); //abcd
	}
	return 0;
}

puts，pringf；scanf，gets

// 分别用两种方法演示字符串的输入输出
// puts和pringf区别：puts能自动在末尾输入一个换行符
// scanf和gets区别：scanf不支持空格、制表符输入 
#include <stdio.h>
int main()
{
	char c1[10],c2[10];
	scanf("%s",c1); 
    printf("%s\n",c1);
    
    /*
    printf("接着输入第二组字符串\n");
	gets(c2);
    puts(c2);*/
	return 0;
}

strlen()长度

// strlen()长度 
#include <stdio.h>
#include<string.h> 
int main()
{
	char c[10]="hello";
	int n;
	n = strlen(c);//求字符串的长度，不含字符串结束标志'\0' 
	printf("c长度为：%d\n",n);//n=5
	printf("c长度为：%d\n",sizeof(c));//值为10 
	printf("c长度为：%d\n",sizeof(char));//值为1。char 型数据占 1 字节
	return 0;
}

strcmp()比较

// strcmp()比较 
#include <stdio.h>
#include <string.h>
/*strcmp(a,b)：将a，b两个字符串从左到右对每个字符，按照ASCII码的值进行比较， 
知道出现不同的或者’\0’，终止比较，如果内容一样，返回0；大于返回正整数，小于 
则返回负整数；*/
int main()
{
	// strcmp()函数：从左到右根据ASCII码值比较 
	// 每个字母的大小，直接遇到不同或结束标志时为止
	char a[5]="abc", b[5]="abc";
	int flag;
//1. 直接用等号比较的话
//比较的是地址是否一样
	if(a==b) printf("a==b\n");
	else if (a!=b) printf("a!=b\n");
//2. 用strcmp()比较
	flag = strcmp(a,b);
	if(flag== 0)  printf("a与b内容相同\n");
	else if (flag>0)  printf("a>b\n");
	else if (flag<0)  printf("a<b\n");

	return 0;
}

**要点小结：**
1.数组是用来 存储数据类型相同 的变量的 有序集合，可以 通过下标访问 数组中的 元素;
2.一维数组 的定义，初始化与引用;
3.二位数组 用于存储表格数据，定义，初始化与引用;
4.区分字符串与字符数组的区别：字符串是要用字符数组存储，最后要加上一个‘\0’;
5.字符数组的长度至少比字符串多1；
6.使用sizeof(数组名)/sizeof(数组元素的数据类型) = 字符数组长度
7.字符数组直接 == 比较的是 地址
8.使用string.h提供的字符串操作函数： 
strcpy(a,b)：将b的字符串复制到a中，会覆盖
strcat(a,b)：将字符串b的内容拼接到a的后面
strcmp(a,b)：将a，b两个字符串从左到右对每个字符，按照ASCII码的值进行比较， 
知道出现不同的或者’\0’，终止比较，如果内容一样，返回0；大于返回正整数，小于 
则返回负整数；
strlen(a)：返回字符串的长度，不包括字符串结束的标记’\0’

指针

1. 指针：是一个地址
2. 指针变量：用来存放另一变量的地址
3. *：表示“指向
4. 如果定义变量 i 为指针变量，那么 *i 就表示指针变量i里面存放的地址是所指向的存储单元里面的数据。
5. int*i；*表示这个变量是一个指针变量，而int表示这个变量只能存放 int 型变量的地址。

指针的使用

// 指针的使用 
#include <stdio.h>

int main()
{
	int a=10,b;
	int *p,*q;//指针变量的定义 
//	取得a变量的地址赋值给p
    p = &a; 
    b = *p+3;//通过指针变量访问变量 
    printf("%d\n",p);//p是一个地址:6487616 
    printf("%d\n",b);//b=13  
//    如果p指向的内存中的数据+1，a会等于多少？
	*p = *p+1;
	printf("a = %d,b = %d\n",a,b);//a = 11,b = 13
//	我们把p的地址赋给q,然后对q+1，观察a的变化
    q = p;
	*q = *q+1; 
	printf("a = %d,b = %d\n",a,b);//a = 12,b = 13 
	return 0;
}

指针与一维数组 ，实现数组的倒序排列

// 指针与一维数组 
#include <stdio.h>

int main()
{
    int a[10]={1,2,3,4,5,6,7,8,9,10};
    int *p=a,*q=&a[9],*c=&a[3]; 
    int i,num;
    
//   数组名本身就是一个指针（地址），它代表了数组的首地址，数组在内存中连续存放
    printf("%p %p %p %p\n",a,p,&a[0],q);           //%p 打印地址，三者地址相同 
    printf("*p=%d,*q=%d,*c=%d\n",*p,*q,*c);   //*p=1,*q=10,*c=4
//    循环的目的是实现数组的倒序排列 
    while(p<=q)
    {
    	num = *q;
    	*q = *p;
		*p = num;
//	    将指针p后移一个单位
//	    将阵阵q后移一个单位
		p++;q--;	
	}    
	printf("*p=%d *q=%d\n",*p,*q) ;// *p=5 *q=6 
    printf("输出交换后的数组：\n");
    for(i=0;i<10;i++)
    {
    	printf("%d",a[i]);
	}
	printf("\n");  //输出结果：10987654321 
	return 0;
}

指针与字符串

// 指针与字符串 
// 双引号表示字符串，单引号表示字符 
#include <stdio.h>

int main()
{
    int num = 0;
//定义方式一：
    char str1[]= "How do you do!"; 
    printf("%s\n",str1);//  How do you do! 
    printf("%p\n",str1);// str1指向了字符串的第一个字符的地址 
    
//定义方式二：
	char *str = "How do you do!"; 
	printf("%s\n",str); //  How do you do! 
	printf("%d\n",*str); // 指用字符指针向了字符串的第一个字符H，值为十进制的72 
	
	for(;*str;str++)
//	第一个分号前面没有写循环初始状态，表明无条件开始循环。
//  *str意思是*str!=0执行，*str==0停止循环 
//  执行一次循环体后， 执行步长运算部分： p++
	{
		if(*str == 'o') num++;
	}
	printf("*str = %d\n",*str);//  *str=0 
	printf("字符串中o出现了%d次\n",num);
	return 0;
}

指针与二维数组

// 指针与二维数组 
#include <stdio.h>
int main()
{
    int a[2][2] = {{1,2},{3,4}};
    int (*p)[2],i,j;      // 定义一个二维指针 
    p = &(a[0]);
    printf("%d",(*p)[0]); // 1
    return 0;
}

指向数组

// 指向数组 
#include <stdio.h>
int main()
{
    int i,j;
    int a[2][3];
    //定义一个行指针，并指向数组的首地址
    int (*p)[3];// 该语句是定义一个数组指针，指向含4个元素的一维数组
    //  int (*p)[n]; ()优先级高，首先说明p是一个指针，指向一个整型的一维数组，这个一维数组的长度是n，
	// 也可以说是p的步长。也就是说执行p+1时，p要跨过n个整型数据的长度
    
    p = &(a[0]);
    printf("请输入二维数组中的数组元素：\n");
    
    for(i = 0;i < 2;i++) 
    {
        for(j = 0;j < 3;j++)
        {
            scanf("%d",p[i]+j);
        }
    }
    printf("输出二维数组中的数据：\n");
    for(i = 0;i < 2;i++) 
    {
        for(j = 0;j < 3;j++)
        {
            printf("%4d",*(p[i]+j));
        }
        printf("\n");
    }
    return 0;
}