字符串函数的运用、sprintf、sscanf、main标准形参、变量和常量定义、基本数据占用字节数总结、scanf函数输入数据、位运算全面介绍、基本运算符全面介绍。

1. 基本数据类型转字符串

格式化打印:
int sprintf(char *str, const char *format, ...);
int snprintf(char *str, size_t size, const char *format, ...);
printf默认将数据格式化打印到标准输出(文件指针-->显示终端)。
int printf(const char *format, ...);
示例:
#include <stdio.h>  //标准输入输出
#include <string.h> //字符串处理头文件

int main(int argc,char **argv)
{
    char str[100];
    //int data=666;
    //sprintf(str,"---%d---",data);
    //printf("%s\n",str);
    //float data=666.123;
    //sprintf(str,"---%.3f---",data);
    //printf("%s\n",str);
    
    //int data=12345;
    //sprintf(str,"---0x%X---",data);
    //printf("%s\n",str);
    
    sprintf(str,"%s-%s-%s-%d\n","123","456","789",888);
    printf("%s\n",str);
    return 0;
}

2. 字符串转基本数据类型

int scanf(const char *format, ...);
int fscanf(FILE *stream, const char *format, ...);
int sscanf(const char *str, const char *format, ...);

示例:
#include <stdio.h>  //标准输入输出
#include <string.h> //字符串处理头文件
int main(int argc,char **argv)
{
    //char str[]="123";
    //int data;
    //sscanf(str,"%d",&data);
    //printf("data=%d\n",data);
    
    char str[]="123.456";
    float data;
    sscanf(str,"%f",&data);
    printf("data=%.3f\n",data);
    
    return 0;
}

3. 数组类型当做函数的形参传递

C语言的代码是由函数组成的。
函数返回值类型 函数名称(函数的形参列表,....)
{
    .....
    return <返回值的类型>;
}

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

函数的基本运用示例:
#include <stdio.h>  //标准输入输出
#include <string.h> //字符串处理头文件

int sum(int a,int b);
int main(int argc,char **argv)
{
    int a=100;
    int b=100;
    int c;
    c=sum(a,b); //调用函数
    printf("c=%d\n",c);
    return 0;
}

/*
函数功能: 求和
*/
int sum(int a,int b)
{
    return a+b;
}

4. 数组当做函数形参类型

数组类型可以当做函数的形参，但是数组类型不能当做函数返回值类型(只能通过指针返回)。

示例（通过子函数给主函数里的数组赋值）:

#include <stdio.h>  //标准输入输出
#include <string.h> //字符串处理头文件

void func(char str[]); //函数声明

int main(int argc,char **argv)
{
    char str[100];
    func(str);
    printf("%s\n",str);
    return 0;
}

//数组当做函数形参时,填入的数组的首地址
void func(char str[])
{
    scanf("%s",str);
}

封装子函数：

示例(封装排序的子函数):
#include <stdio.h>  //标准输入输出
#include <string.h> //字符串处理头文件

void func(int data[],int len); //函数声明

int main(int argc,char **argv)
{
    int data[10]={5,4,3,2,1};
    int i;
    func(data,5);
    for(i=0;i<5;i++)
    {
        printf("%d ",data[i]);
    }
    printf("\n");
    return 0;
}

//数组当做函数形参时,填入的数组的首地址
void func(int data[],int len)
{
    int i,j;
    int tmp;
    for(i=0;i<len-1;i++)
    {
        for(j=0;j<len-1-i;j++)
        {
            if(data[j]>data[j+1])
            {
                tmp=data[j];
                data[j]=data[j+1];
                data[j+1]=tmp;
            }
        }
    }
}

5. C语言main函数标准形参

#include <stdio.h> /*引用系统的库函数*/
/*
main: 主函数表示开头
函数形参介绍:
int argc   :传入的参数个数
char **argv:传入的参数缓冲区地址。
参数示例: ./app 123 456 789
注意点:  传入的任何参数都是以字符串的形式存放的。
*/
int main(int argc,char **argv)
{
    int i;
    printf("argc=%d\n",argc);
    for(i=0;i<argc;i++)
    {
        printf("argv[%d]=%s\n",i,argv[i]);
    }
    return 0;
}

6. 变量和常量

#include <stdio.h> /*引用系统的库函数*/
int main(int argc,char **argv)
{
    int a;    /*定义一个整型的变量a
            *什么是变量?  (变量)空间数据可以改变。 
            *什么是常量?  空间的数据初始化之后不能改变。
            */
    const int b=123; //定义一个整型的常量b,并初始化赋值为123
    
    return 0;
}

7. 基本的数据类型

#include <stdio.h> /*引用系统的库函数*/
int main(int argc,char **argv)
{
    int a=12;      //整型变量、占4个字节。
    printf("sizeof=%d,%d\n",sizeof(int),a);
    
    char b='A';     //字符类型变量、占1个字节。
    printf("sizeof=%d,%c\n",sizeof(char),b);
    
    float c=12.1;   //浮点类型变量、占4个字节。
    printf("sizeof=%d,%.2f\n",sizeof(float),c);
    
    double d=12.1;  //双精度类型变量、占8个字节。
    printf("sizeof=%d,%.3f\n",sizeof(double),d);
    
    long e=12;      //长整型、占4个字节。
    printf("sizeof=%d,%ld\n",sizeof(long),e);
    
    long long f=12; //双长整型、占8个字节。
    printf("sizeof=%d,%lld\n",sizeof(long long),f);
    
   short  短整型 占2个字节
    /* 
     *  1字节多大？8个位 ，8个位最大可以存放多少数据？ 255->0xFF
     *  
     */
     unsigned int a_1=12; //定义无符号整型。
     /*
      *  unsigned关键字只能使用在整型上。
     */
    return 0;
}

8. char类型变量

#include <stdio.h> /*引用系统的库函数*/
int main(int argc,char **argv)
{
	char a=128;     
	printf("a=%d\n",a);
	/*
	 * unsigned char a; 存放数据的范围: 0~255
	 * char a;存放的范围: -128 ~ +127
	*/
	
	/*
	常用的变量ASCII码。 
	在电脑上的所有的数据在硬盘上存放都是以二进制形式存放。
	二进制-->转10进制。
	*/
	return 0;
}

9. scanf函数使用

#include <stdio.h> /*引用系统的库函数*/
int main(int argc,char **argv)
{
	int a,b; /*a这个名称在当前工程里不能重复、整个操作系统是可以重复*/
	scanf("%d%d",&a,&b); /* &表示取地址
	                      * 从键盘上读取一个整型的a给变量。
					      */
	/*
	scanf函数带阻塞功能: 当遇到回车才会结束输入。空格可以当做间隔符号。
	*/
	printf("data=%d,%d\n",a,b); 
	return 0;
}

10. 运算符

基本算术运算符
+ :加法运算符
- :减法运算符
*:乘法运算符
/ :除法运算符
%:取余运算符
= :赋值运算符。 右边值给左边值。 c=(a=b)  ,  c=(a==b)
++ :自增，i++ 相当于i=i+1;
逻辑运算符
>   大于 、>=
<   小于、 <=
==  等于判断

&&  逻辑与  所有条件全部为真，结果才为1
||    逻辑或  只要有一个条件为真，结果就为1
！   逻辑非  。非0即为0。  

11. 位运算

位运算:  针对二进制数字进行的，0和1。
&	按位与。 比如:  a=a&0x01;  规则: 全1为1，有0为0
#include <stdio.h> 
int main(int argc,char **argv)
{
	unsigned char a=0x2;
	unsigned char b=0x3;
	a=a&b;
	printf("0x%X\n",a);
	/*
	0000 0010
	0000 0011
	-------------
	0000 0010
	*/
	return 0;
}
|	按位或。 比如:  a=a|0x01;  规则: 有1为1，全0为0
#include <stdio.h>
int main(int argc,char **argv)
{
	unsigned char a=0x2;
	unsigned char b=0x3;
	a=a|b;
	printf("0x%X\n",a);
	/*
	0000 0010
	0000 0011
	-------------
	0000 0011
	*/
	return 0;
}
^	按位异或。 规则: 相同为0，不同为1
#include <stdio.h>
int main(int argc,char **argv)
{
	unsigned char a=0x2;
	unsigned char b=0x3;
	a=a^b;
	printf("0x%X\n",a);  //1
	/*
	0000 0010
	0000 0011
	-------------
	0000 0001
	*/
	return 0;
}
~	按位取反。  规则: 0为1，1为0
#include <stdio.h>
int main(int argc,char **argv)
{
	unsigned char a=0x7F;
	a=~a;
	printf("0x%X\n",a);
	/*
	01111111
	----------
	10000000
	*/
	return 0;
}
>>	右移运算符。规则: 低位溢出，高位补0
#include <stdio.h>
int main(int argc,char **argv)
{
	unsigned char a=0xF1;
	a=a>>1;
	printf("0x%X\n",a);
	/*
	11110001 >>0111 1000 0x78
	*/
	return 0;
}
<<	左移运算符。规则: 高位溢出，低位补0
#include <stdio.h>
int main(int argc,char **argv)
{
	unsigned char a=0x1F;
	a=a<<1;
	printf("0x%X\n",a);
	/*
	0001 1111 
	-------------
	0011 1110
	*/
	return 0;
}