投稿
  1. 首页
  2. 随笔

C语言笔记

电接点双金属温度计 • 2022-11-8 • 随笔 • 阅读 18

C语言笔记,第1张

C语言笔记 第三章 C语言的数据类型 3.1 变量和常量

  • 常量

    不占内存，在程序运行时其值不能改变的量，在程序运行时它作为 *** 作对象直接出现在运算器的各种寄存器中

  • 变量

    变量是指在程序运行时可以改变的量，变量的功能就是存储数据。

  • 标识符

    在程序中使用的变量名，函数名，标号等统称为标识符。标识符只能时字母数字下划线组成，且第一个字符必须时字母或下划线。标识符区分大小写

3.2 数据类型和关键字
  • 基本数据类型(32为 *** 作系统数据范围)

  • 关键字

3.3 数据类型和取值范围 
# include
int main(void){
    printf("char:bytes %d;bit %dn",sizeof(char),sizeof(char)*8);
    printf("unsigned char:bytes %d;bit %dn",sizeof(unsigned char),sizeof(unsigned char)*8);
    printf("int:bytes %d;bit %dn",sizeof(int),sizeof(int)*8);
    printf("unsigned int:bytes %d;bit %dn",sizeof(unsigned int),sizeof(unsigned int)*8);
    printf("short :bytes %d;bit %dn",sizeof(short),sizeof(short)*8);
    printf("unsigned short :bytes %d;bit %dn",sizeof(unsigned short),sizeof(unsigned short)*8);
    printf("long :bytes %d;bit %dn",sizeof(long),sizeof(long)*8);
    printf("long long :bytes %d;bit %dn",sizeof(long long),sizeof(long long)*8);
    printf("unsigned long :bytes %d;bit %dn",sizeof(unsigned long),sizeof(unsigned long)*8);
    printf("float :bytes %d;bit %dn",sizeof(float),sizeof(float)*8);
    printf("double :bytes %d;bit %dn",sizeof(double),sizeof(double)*8);
    printf("long double :bytes %d;bit %dn",sizeof(long double),sizeof(long double)*8);
    return 0;

}


#include
#include
int main(void)
{
	printf("char:MIN %d;MAX %dn", CHAR_MIN, CHAR_MAX);
	printf("short:MIN %d;MAX %dn", SHRT_MIN, SHRT_MAX);
    printf("int:MIN %d;MAX %dn", INT_MIN, INT_MAX);
    printf("long:MIN %ld;MAX %ldn", LONG_MIN, LONG_MAX);
    printf("long long:MIN %lld;MAX %lldn", LLONG_MIN, LLONG_MAX);
	return 0;
}

// 也可以按照字节 位数进行计算
3.4 本章小结和练习

输出8进制 16进制的方法

// 无前缀方式
printf("%o",num)// 无前缀o的8进制数
printf("%x",num)// 无前缀0x的小写16进制数
printf("%X",num)  //无前缀0X的大写16进制数
// 有前缀的方式
printf("%#o",num) //有前缀o的8进制数

printf("%#x",num) //有前缀0x的小写16进制数

printf("%#X",num) //有前缀0X的大写16进制数

练习

# include
int main(void){
    int n;
    scanf("%d",&n);
    printf("%#o %#d %#xn",n,n,n);
    return 0;
}
第四章 C语言中的基本输入输出 4.1 字符输出函数putchar

字符输出函数，其功能是在终端(显示器)输出单个字符

# include
int main(void){
    int x=100;
    //putchar('A');// 输出大写字母A
    //putchar(x);// 输出d
    putchar('n');
    return 0;
}
4.2 字符输入函数getchar

getchar 函数的功能是接收用户从键盘输入的一个字符，其一般调用形式为:getchar()，返回一个ASCII码

# include
int main(void){
    char c;
    c = getchar();
    printf("%s",c);
	return 0;
}
4.3 格式化输出函数printf

printf函数叫做格式化输出函数，其功能是按照用户指定的格式，把指定的数据输出到屏幕上.

八进制 o 为小写

# include
int main(void){
    printf("%dn",10);// 整数
    printf("%on",10);// 八进制
    printf("%#xn",10);//16进制
    printf("%un",10);//十进制输出无符号整数
    printf("%7.3fn",1.0);// 宽度为7，小数位为3
    printf("%Cn",100);//字符
	return 0;
}


# include
int main(void)
{
	unsigned width,precision;
    int number = 256;
    double weight = 25.5;
    printf("Please input number's width:n");
    scanf("%d",&width);
    printf("The number is: %*dn",width,number);
    printf("Then please input width and precision:n");
    scanf("%d %d",&width,&precision);
    printf("Weight = %*.*fn",width,precision,weight);
    return 0;	
}

具体的说，如果转换说明符为%*d，那么参数列表中应该包括一个*的值和一个d的值，来控制宽度和变量的值。该技术也可以和浮点值一起使用来指定精度和字段宽度。

4.4 格式化输入函数scanf

scanf函数称为格式输入函数，即按照格式字符串的格式，从键盘把数据输入到指定的变量中。使用注意事项

  • 格式说明符中，可以指定数据的宽度，但不能指定数据的精度

    float a;
scanf("%10f",&a);//正确使用
scanf("10.2f",&a);//错误写法

  • 输入long类型数据时，必须使用%ld,输入double数据必须使用%lf或%le

  • 附加格式说明符 *,使对应的输入数据不附给相应的变量

    # include
int main(void){
	int num;
    printf("please enter three number:n");
    scanf("%*d %*d %d",&num);
    printf("The last number is %dn",num);
    return 0;
}

4.5 总结&练习 
# include
int main(void){
    char c1,c2,c3,c4,c5;
    scanf("%c%c%c%c%c",&c1,&c2,&c3,&c4,&c5);
    c1 = c1+4;
    c2 = c2+4;
    c3 = c3+4;
    c4 = c4+4;
    c5 = c5+4;
    printf("%c%c%c%c%c",c1,c2,c3,c4,c5);
    return 0;
}
第五章 运算符和表达式 5.1 基本运算符

基本运算符

理解自增自减运算

#include
int main()
{
        int a,b;
        a=b=5;
    	//printf("%d",a-- + --b);// 9 a-- 后缀模式  --b 前缀模式
        printf("%d      %dn",a--,--b);// 5 4
        printf("%d      %dn",a--,--b);// 4 3
        printf("%d      %dn",a--,--b);// 3 2
        printf("%d      %dn",a--,--b);// 2 1
        printf("%d      %dn",a--,--b);// 1 0
        return 0;
}

对于前缀运算符，先执行自增自减运算，在计算表达式的值，而后缀运算符，则先计算表达式的值，在执行自增或自减运算。

# include
int main(void){
	int a=20;
        int b=5;
        int c=6;
        printf("a = %d b = %d c = %dn",a,b,c);
        printf("a + b = %dn",a+b);
        printf("a - c = %dn",a-c);
        printf("a * b = %dn",a*b);
        printf("a / c = %dn",a/c);
        printf("a %% c = %dn",a%c);
        return 0;
}
5.2 sizeof 运算符

sizeof是一种单目运算符，以字节为单位返回某 *** 作数的大小，用来求某一类型变量的长度，其运算对象可以是任何数据类型或变量。

单目运算符 指的是只需要一个 *** 作数，自增：++ 自减 *** 作:-- 双目运算符指的是 需要两个 *** 作数 如 + - * / %

# include
int main(void){
    int floatsize = sizeof(float);
    printf("float sizeof is %d bytesn",floatsize);
    printf("long sizeof is %d bytesn",sizeof(long));
    return 0;
}
5.3 三目运算符

格式

表达式1？表达式2：表达式3
2>1?10:20 // 10
int a=3,b=5;
int c =10;
c?:(a+b):(a-b)//8
5.4 表达式和语句

表达式

*** 作数和运算符组成

语句

一个语句是一条完整的计算机指令，在C语言中一个分号为一个语句。

5.5 总结&练习 
# include
int main(void){
    double f,c;
    scanf("%lf",&f);// double 类型个数输入函数使用 %lf
    c = 5*(f-32)/9;
    printf("c=%0.2lf",c);
    return 0;
}


# include
# include
# define PI (atan(1.0)*4) // 定义宏
int main(void){
    double r,s;
    scanf("%lf",&r);
    s = r*r*PI;
    printf("%.2lf",s);
    return 0;
}


# include
int main(void)
{
    int n,a[3];
    scanf("%d",&n);
    a[0] = n%10;//个位
    a[1] = n/10%10;// 十位
    a[2] = n/100;// 百位
    printf("%d %d %d",a[0],a[1],a[2]);
    return 0;
}
第六章 C语句和程序流 6.1 表达式和语句 6.2 选择结构 
//形式一
if(表达式)  
{ 
    //语句 
}
//形式二
if(表达式)  
{ 
    //语句1 
} 
else 
{ 
    //语句2 
}
// 形式3
if(表达式)  
{ 
    //语句1 
} 
else if(表达式2)   
{ 
    //语句2 
} 
else if(表达式3)   
{ 
    //语句3; 
} 
//… … 
else     
{ 
    //语句4 
}
// switch结构
switch(表达式)  
{ 
    case 常量表达式1:语句1; 
    case 常量表达式2:语句2; 
    case 常量表达式3:语句3; 
    // … … 
    case 常量表达式n:语句n; 
    default:语句n+1； 
}
6.3 循环结构

提供三种循环结构

  • for

    for(i=0;i<100;i++)
{
    printf("i count is %dn",i);
}

  • while

    while(i++<10)
{
    printf(“count %d ”,i);
}

  • do while

    do
{
    printf("count %d"，i);
}while(i<20);
6.4 总结&练习 
# include
int main(void){
    int a,b,c,t;
    scanf("%d,%d,%d",&a,&b,&c);
    if(a>b){
        t=a;
    }else{
        t = b;
    }
    if (c>t){
        t = c;
    }
    printf("%dn",t);
    return 0;
}


# include
int main(void){
    int x,y;
    scanf("%d",&x);
    if (x<1){
        y = x;
    }else if(x>=1 && x<10){
        y = 2*x -1;
    }else{
        y = 3*x-11;
    }
    printf("%d",y);
    return 0;
}


# include
int main(void){
    char c;
    int score;
    scanf("%d",&score);
    if (score>=90){
        c = 'A';
    }else if(score>=80 && score<=89){
        c = 'B';
    }else if(score>=70 && score<=79){
        c = 'C';
    }else if(score>=60 && score<=69){
        c = 'D';
    }else{
        c = 'E';
    }
    printf("%c",c);
    return 0;
}


#include
int main()
{
	int i,count=0,x[5];
	for (i=0;i<5;i++){
	    int temp=0;
	    temp = getchar();// 返回ASCI码
	    if (temp==10)// 10 为换行的ASCI码
	    break;
	    count++;
	    x[i] = temp-48;//字符0的ASCI码为48
	}
	printf("%dn",count);
	for(i=0;i<=count-1;i++)
	printf("%d ",x[i]);
	printf("n");
	for (i=count-1;i>=0;i--)
	printf("%d",x[i]);
	return 0;
}

#include
int main()
{
	int x,y;
	scanf("%d",&x);
	if(x<=100000)
	{
	    y = x*0.1;
	}
	else if (x>100000 && x<200000){
	    y = (x-100000)*0.075+100000*0.1;
	}else if(x>200000 && x<=400000){
	    y = (x-200000)*0.05 + 100000*0.075 + 100000*0.1;
	}else if(x>400000 && x<=600000){
	    y = 100000*0.1+100000*0.075+200000*0.05+(x-400000)*0.03;
	}else if(x>600000 && x<=1000000){
	    y = 100000*0.1+100000*0.075+200000*0.05+200000*0.03+(x-600000)*0.015;
	}else{
	    y=(x-1000000)*0.01+100000*0.1+100000*0.075+200000*0.05+200000*0.03+400000*0.015;
	}
	printf("%dn",y);
	return 0;
}


# include
int gcd(int a,int b);//函数声明
int lcm(int a,int b);//函数声明
int main(void){
    int a,b;
    scanf("%d %d",&a,&b);
    printf("%d %d",gcd(a,b),lcm(a,b));
    return 0;
}
int gcd(int a,int b){
    if (b==0)
        return a;
    return gcd(b,a%b);//递归调用
}
int lcm(int a,int b){
    return (a*b)/gcd(a,b);// 利用 最大公约数*最小公倍数=两数值乘积
}


# include
int main(void){
    int a,c,d,b,e;
    a =c =d =b=0;
    while((e=getchar())!=10)// 10为换行的ASCII码
    {
        if (e>=65 && e<=90 || e>=97 && e<=122){
            a++;// 英文字母 ，a自增
        }else if (e>=48 && e<=57){
            b++;// 遇到数字字符 ，b自增
        }else if(e==32){
            c++;//空格 c自增
        }else{
            d++;// 遇到其他字符，自增
        }
    }
    printf("英文字母%d, 数字%d,空格%d,其他%d",a,b,c,d);
    return 0;
}


# include
int main(void){
    int i,n,sum=0,a=2,sum1=0;
    scanf("%d",&n);
    for(i=1;i<=n;i++){
        sum = sum*10+a;
        sum1 +=sum;
    }
    printf("%d",sum1);
    return 0;
}


# include
long long fac(int n);// 声明函数
int main(void){
    int n,i;
    long long Sn=0;
    scanf("%d",&n);
    for (i=1;i<=n;i++){
        Sn = Sn+fac(i);
    }
    printf("%lld",Sn);
    return 0;
}
long long fac(int n){
    long long f;
    if (n==0)
        return 1;
    f = fac(n-1)*n;
    return f;
}

类型名称      字节数  取值范围
signed` `char`      `1    -128～+127
short` `short`       `2    -32768～+32767(一个字节8位，2个字节16位，所以取值范围为2^16,考虑到有无符号，对半分)
int`          `4    -2147483648～+2147483647
long` `int`       `4    -2147483648～+2141483647
long` `long` `int`     `8    -9223372036854775808～+9223372036854775807

//long int   的简写是   long     占位符是：%ld   
//long long int的简写是   long long   占位符是：%lld
有符号
 short %hd
 int %d
 long %ld
无符号
 short %hd
 int	%u
 long %lu
字符
 char %c
 double %lf
 科学计数法输出double %e
 字符串 %s

# include 
int main(void){
    int a,b,c,i;
    float sum=0.0;
    scanf("%d %d %d",&a,&b,&c);
    for (i=1;i<=a;i++){
        sum += i;
    }
    for (i=1;i<=b;i++){
        sum += i*i;
    }
    for (i=1;i<=c;i++){
        sum += 1.0/i;// 1.0/i 返回浮点数,往精度高的方向靠
    }
    printf("%.2f",sum);
    return 0;
}

# include 
int main(void){
   int i=100;
   for (i=100;i<=999;i++){
       if((i/100)*(i/100)*(i/100)+(i/10%10)*(i/10%10)*(i/10%10)+(i%10)*(i%10)*(i%10)==i){
           printf("%dn",i);
       }
   }
    return 0;
}

百位:n/100 十位:n/10%10 个位:n%10

# include
int main(void){
    int N;
    scanf("%d",&N);
    int i,j,k,sum=0;
    for (i=2;i<=N;i++){
        for(j=1;j<=i/2;j++){// 寻找因子，并计算所有因子的和
            if (i%j==0)
                sum +=j;
        }
        if (sum==i){// 判断是否是完数
            printf("%d its factors are ",i);
            for(k=1;k<=i/2;k++){// 寻找因子，输出因子
                if(i%k==0)
                    printf("%d ",k);
            }
            printf("n");
        }
        sum =0;//每次循环后将sum重置为0，开始下次循环，这一步非常重要
    }
    return 0;
}


# include
int main(void){
    int a=2,b=1,i,N,temp;
    double sum=0;
    scanf("%d",&N);
    for (i=1;i<=N;i++){
        sum +=a*1.0/b;// 记得1.0，否则没有小数
        temp = a+b;
        b =a;
        a = temp;
    }
    printf("%.2lf",sum);
    return 0;
}


# include
int main(void){
    int size,i;
    double iterm=0,sum=0,high;
    scanf("%lf %d",&high,&size);// size 次数 high 高度
    iterm = high;
    for (i=0;i 

# include
int main(void){
    int i,N,s=1;// s桃子总数 N 天
    scanf("%d",&N);
    for(i=1;i 

# include
# include
int main(void){
    double x1,x2;
    int a;
    scanf("%d",&a);
    x1 = a*1.0/2;
    x2 = (x1+a*1.0/x1)/2;
    do {
        x1 = x2;
        x2 =(x1+a*1.0/x1)/2;
    }while(fabs(x1-x2)>=1e-5);
    printf("%lf",x2);
    return 0;
}


 

# include
int main(void){
    int N;
    scanf("%d",&N);
    int arr[N];
    for (int i=0;i 
第七章 函数 
7.1 函数的定义 

函数是C源程序的基本模块，程序的很多功能都是通过对函数模块的调用来实现的。
 

返回值类型 函数名(形参表说明)  
{ 
说明语句  
执行语句 
} 

 
7.2 函数的调用 

在主调函数中调用某函数之前应对该被调函数进行声明。在主调函数中对被调函数进行说明的目的是
 使编译系统知道被调函数返回值的类型,以便在主调函数中按此种类型对返回值进行相应的处理。其一般
 形式为:
 类型说明符 被调函数名(类型 形参,类型 形参…);
 需要注意的是,函数的声明和函数的定义有本质上的不同。主要区别在以下两个方面:
 (1)函数的定义是编写一段程序,应有函数的具体功能语句——函数体;而函数的声明仅是向编译系 统的一个说明,不含具体的执行动作。
 (2)在程序中,函数的定义只能有一次,而函数的声明可以有多次。
 
7.3 变量的存储类型 

变量的分类
 

 

详细解释
 

  •  
    全局变量
     
    全局变量是在函数之外定义的变量,其作用范围为从定义处开始到本文件结束,编 译时,编译系统为其分配固定的内存单元,在程序运行的自始至终都占用固定单元。
     
  •  
    局部变量
     
    局部变量是在一 个函数或复合语句内定义的变量,它仅在函数或复合语句内有效,编译时,编译系统不为局部变量分配内 存单元,而是在程序运行过程中,当局部变量所在的函数被调用时,编译系统根据需要,临时分配内存, 调用结束,空间释放。
     
  •  
    自动变量
     
    函数中的局部变量,如不专门声明为 static 存储类别,都是动态地分配存储空间的,数据存储在动态 存储区中。函数中的形参和在函数中定义的变量(包括在复合语句中定义的变量)都属此类,在调用该函 数时系统会给它们分配存储空间,在函数调用结束时就自动释放这些存储空间。这类局部变量称为自动变 量。自动变量用关键字 auto 进行存储类别的声明,例如声明一个自动变量:
     
  •  
    外部变量
     
    **外部变量(即全局变量)**是在函数的外部定义的,它的作用域为从变量定义处开始,到本程序文件的末尾。如果外部变量不在文件的开头定义,其有效的作用范围只限于定义处到文件末尾。如果在定义点之前的函数想引用该外部变量,则应该在引用之前用关键字 extern 对该变量进行“外部变量声明”。表示该 变量是一个已经定义的外部变量。有了此声明,就可以从“声明”处起,合法地使用该外部变量.
     用 extern 声明外部变量,扩展程序文件中的作用域
     
  •  
    静态变量
     
    有时希望函数中的局部变量的值在函数调用结束后不消失而保留原值,这时就应该指定局部变量为静 态局部变量,用关键字 static 进行声明。
     
  •  
    寄存器变量
     
    为提高效率,C 语言允许将局部变量的值存放在 CPU 的寄存器中,这种变量叫做寄存器变量,用关键字 register 声明。使用寄存器变量需要
     
  
     
   
    注意 只有局部自动变量和形式参数可以作为寄存器变量；一个计算机系统中的寄存器数目有限，不能定义任意多个寄存器变量；不能使用取地址运算符&求寄存器变量的地址。
     
  
     
 
7.4 总结&练习 

#include
int fun();// 声明函数
int main(void){
    fun();
    return 0;
}
// 定义函数
int fun(){
    int a[10],i,j;
    for (i=0;i<10;i++)
        scanf("%d",&a[i]);
    for (j=9;j>=0;j--)
        printf("%d ",a[j]);
}

 

# include
int gcd(int a,int b);// 定义最大公约数
int lcm(int a,int b);//定义最小公倍数
int main(void){
    int a,b;
    scanf("%d %d",&a,&b);
    printf("%d %d",gcd(a,b),lcm(a,b));
    return 0;
}
int gcd(int a,int b){
    if (b==0)
        return a;
    else
        return gcd(b,a%b);
}
int lcm(int a,int b){
    return (a*b)/gcd(a,b);// 利用公式 最大公约数*最小公倍数=两数乘积
}


 

#include
#include
void tow_num(int a, int b, double num);
void imag_num(int a, int b, double num);
void one_num(int a, int b);
//用三个函数分别求当b^2-4ac大于0、等于0、和小于0时的根，并输出结果。从主函数输入a、b、c的值。

int main(int argc, char* argv[])
{
    int a, b, c;
    double num = 0;
    scanf("%d %d %d", &a, &b, &c);
    num = (double)b * b - 4 * a * c;
    
    if (num > 0)
        tow_num(a, b, num);
    else if (num < 0)
        imag_num(a, b, num);
    else
        one_num(a, b);
    return 0;
}

void tow_num(int a, int b, double num)
{
    printf("x1=%0.3lf x2=%0.3lf", (double)(-b + pow(num, 0.5)) / (2 * a), (double)(-b - pow(num, 0.5)) / (2 * a));
}

void one_num(int a, int b)
{
    printf("x1=%0.3lf x2=%0.3lf", (double)-b / (2 * a), (double)-b / (2 * a));
}

void imag_num(int a, int b, double num)
{
    double real_num, unreal_num;
    real_num = (double)-b / (2 * a);
    unreal_num = (double)pow(-num, 0.5) / (2 * a);
    printf("x1=%0.3lf+%0.3lfi x2=%0.3lf-%0.3lfi", real_num, unreal_num, real_num, unreal_num);
}


 

 
 
b^2-4ac>0 x=((-b+-``sqrt``（b^2-4ac))/2a b^2-4ac<0``（-b+-``sqrt``（4ac-b^2））i/2a ``b^2-4ac=0 -b/2a`
 

 

# include
int is_Prime();
int main(void){
    is_Prime();
    return 0;
}
int is_Prime(){
    int i,a;
    scanf("%d",&a);
    for (i=2;i<=a/2;i++){
        if (a%i==0){
        printf("not prime");
        break;
        }
        else{
        printf("prime");
        }
    }
}

 

# include
int main(void){
    int a[3][3],i,j;
    for (i=0;i<3;i++){
        for(j=0;j<3;j++){
            scanf("%d",&a[i][j]);
        }
    }
    for(i=0; i<3; i++){
        for(j=0; j<3; j++){
            printf("%d ",a[j][i]);//打印的时候直接行列转换
        }
        printf("n");
    }
    return 0;
}

 

# include
int main()
{
    char arr[1000];
    char *p = arr;
    scanf("%s",&arr);
    while (*p!=''){
        p++;
    }
    while(p!=arr){
        p--;
        printf("%c",*p);
    }
    return 0;
}


 

# include
# include
int main(void){
    char st1[100],st2[100];
    gets(st1);// 获取整行字符输入
    gets(st2);
    strcat(st1,st2);//将st2追加到st1后
    puts(st1);// 输出字符换行
    return 0;
}

 

 
 
补充 gets() 和 scanf()区别 puts() 和 scanf() 区别
 
 
#include
int main()
{
	char a[10],b[10];
	int c,d;
	scanf("%s",a);
	printf("a:%sn",a);
	c = getchar();
	printf("c:%d",c);
	gets(b);
	printf("b:%sn",b);
	d = getchar();
	printf("d:%c",d);
	return 0;
}


 
 
scanf() 当遇到回车，空格和TAB键会自动在字符串后面天加,但是回车，空格和tab键仍会留在输入的缓冲区中，所以 a 的输出 是hello 代表的是字符串的结尾，因为空格保留在缓冲区中，所以c的值为32，空格的ASCII码值，gets()可接受回车键之前输入的所有字符，并用’’替代 ‘n’.回车键不会留在输入缓冲区中，所以 b 输出123 ，空格不在缓冲去所以 d输出 w;puts（）在输出字符串时会将’’自动转换成’n’进行输出，也就是说，puts方法输出完字符串后会自动换行。
 

 

#include
int main()
{
	char a[5]={'a','e','i','o','u'};// 定义元音字母数组
	char b[100];
	scanf("%s",b);
	for(int j=0;j<100;j++){// 双循环遍历
	for (int i=0;i<5;i++){
	        if (a[i]==b[j]){
	            printf("%c",b[j]);
	        }
	        
	    }
	}
	return 0;
}

 

#include
int main()
{
    char a[4];
    scanf("%s",a);
    char *p =a;// 定义指针
    for (int i=0;a[i]!='';i++){// 使用指针进行遍历
        printf("%c ",*(p+i));
    }
	return 0;
}

 

// 方法一 使用ASCII码  有可能超时
#include
int filter();
int main(void)
{
    filter();
    return 0;
}
int filter(){
    
    int number=0,string=0,space=0,others=0,e;
    while((e=getchar())!=10){// getchar() 一个个读取输入的字符 10 为换行的ASCII码
        if(e==32){// 空格 
            space++;
        }else if(e>=48 && e<=57){// 数字
            number++;
        }else if(e>=65 && e<=90 || e>=97 && e<=122){ // 字母
            string++;
        }else{// 其他
            others++;
        }
    }
    printf("%d %d %d %d",string,number,space,others);
}

 

# include
int main(void){
    int a,b,c,d;
    scanf("%d",&a);
    b = a/100;// 百位
    c = a/10%10;// 十位
    d = a%10;// 个位
    if (a== b*b*b+c*c*c+d*d*d){
        printf("%d",1);
    }else{
        printf("%d",0);
    }
    return 0;
}

 

# include
int main(void){
    for(int i=100;i<=999;i++){
        int b = i/100;
        int c = i/10%10;
        int d = i%10;
        if (i== b*b*b+c*c*c+d*d*d){
            printf("%dn",i);
        }
    }
    return 0;
}


 

// 直接暴力求解
#include
int main()
{
int i;
for(i=21;i<2000;i++)
{
if(i%8==1&&i/8%8==1&&i/8/8%8==7&&i%17==4&&i/17%17==15&&i/17/17==i/8/8/8*2)
printf("%dn",i);
}
return 0;
}


 

#include 
int wan(int a) {
    int sum = 1, i;
    for (i = 2; i < a; i++) {
        if (a % i == 0)
            sum += i;// a的全部因子求和
    }
    return sum;
}
int main() {
    int i, j;
    int sum, sam;
    for (i = 1; i <= 3000; i++) {
        sum = wan(i);
        if (sum == 1) continue; //素数
        for (j = i + 1; j <= 3000; j++) {
            if (sum != j) continue; //先判断 i因数和与j 是否相等（省时
            sam = wan(j);
            if (sam == 1) continue; //素数
            if (sum == j && sam == i) {
                printf("(%d,%d)", i, j);
            }
        }
    }
    return 0;
 
}

 

# include
int yinzi();
int main(void){
    yiniz();
    return 0;
}
int yiniz(){
    int i;
    for(i=1;i<40;i++){
        if(i%2!=0 && i%5!=0){
            printf("%d/40,",i);// 格式化输出，注意，
        }
    }
}


 

// 思路使用ASCII码 有可能超时
# include
int lower();
int main(void){
    lower();
    return 0;
}
int lower(){
    int e=0;
    while((e=getchar())!=10){// 10 为换行
        if (e>=65 && e<=90){ //[65,90] A-Z 加32 将大写字母转为小写
            e = e+32;
        }
        printf("%c",e);
    }
}
// 方法二：
# include
# include
int main(){
   char a[100];
    gets(a);
    for(int i=0; i='A'&&a[i]<='Z')
            a[i]+=32;
    }
    puts(a);   
    return 0; 
}

 

// 去设置为1 不去设置为0
# include
int main(void){
    int a,b,c,d,e,f;
    for(a=0;a<=1;a++){
        for(b=0;b<=1;b++){
            for(c=0;c<=1;c++){
                for(d=0;d<=1;d++){
                    for(e=0;e<=1;e++){
                        for(f=0;f<=1;f++){
                            // a 和b 至少去一个 a+b>=1 a和d不能一起去 a+d<=1,要么a去要么 d去，要么都不去, 
                            if(a+b>=1&&a+d<=1&&a+e+f==2&&(b+c==2||b+c==0)&&c+d==1&&(d+e==0||d==1))
                              {
                                if(a)
                                    printf("A,");
                                if(b)
                                    printf("B,");
                                if(c)
                                    printf("C,");
                                if(d)
                                    printf("D,");
                                if(e)
                                    printf("E,");
                                if(f)
                                    printf("F,");
                              }
                        }
                    }
                }
            }
        }
    }
    return 0;
}


 

# include
# include
int main(void){
    char a[50];
    gets(a);
    for (int i=0;i=0;i--){
        printf("%c",a[i]);
    }
    return 0;
}

 


# include
int main(void){
    int a;
    scanf("%d",&a);
    int i = a*a-(a-1);// 获取第一个奇数的值
    printf("%d*%d*%d=%d=",a,a,a,a*a*a);
    for (int j=1;j<=a;j++){
        if(j!=a){
            printf("%d+",i);
           
        }else{
            printf("%d",i); 
        }
        i +=2;
        
    }
    return 0;
}

 

#include
int main(void){
    int i,j,t,a[5];
    for(i=0;i<=4;i++){
        scanf("%d",&a[i]);
    }
    for(i=0;i<5;i++){// 外循环为排序的趟数
        for(j=i+1;j<=4;j++){// 内循环为每趟比较的次数
            if(a[i]>a[j]){
                t =a[i];
                a[i]=a[j];
                a[j]=t;
            }
        }
    }
    for (i=0;i<5;i++){
        printf("%d ",a[i]);
    }
    return 0;
}

 

#include
int main(void){
    int i,j,t,a[10];
    for(i=0;i<=9;i++){
        scanf("%d",&a[i]);
    }
    for(i=0;i<10;i++){// 外循环为排序的趟数
        for(j=i+1;j<=9;j++){// 内循环为每趟比较的次数
            if(a[i] 

# include
# include
int main(void){
    char a[100];
    gets(a);
    int sum=0;
    for(int i=0;i='a'&& a[i]<='z')|| (a[i]>='A'&& a[i]<='Z')){
            sum++;
        }
    }
    printf("%d",sum);
    return 0;
}

 

# include
int fibo(int N);
int main(void){
    int N;
    scanf("%d",&N);
    fibo(N);
    return 0;
}
int fibo(int N){
    int a[N];
    for(int i=0;i 

# include
int main(void){
    int max,n;
    scanf("%d",&n);
    max = n;
    while(n!=-1){
        scanf("%d",&n);
        if(n!=-1){
            if(max<=n){
                max = n;
            }
        }
    }
    printf("%dn",max);
    return 0;
}

 

// 思路使用递归求解
# include
long long fibo(int n);// 设置返回值为 long long int 类型，long long 为long long int 简写
int main(void){
    long long sum=0;// 防止溢出，设置long long 类型
    int n;
    scanf("%d",&n);
    for (int i=1;i<=n;i++){
        sum +=fibo(i);
    }
    printf("%lld",sum);// long long 的格式化输出 %lld
    return 0;
}
long long fibo(int n){
    long long s1;
    if (n==1){
        return 1;
    }else{
         s1 = fibo(n-1)*n;
    }
    return s1;
}

 

#include
int main(void){
    double sum;
    double i=1;
    int j=1;
    // 不知道循环次数使用while 循环
    while(1.0/i>=1e-6){
        if(j%2==0){
            sum -=1/i;
        }else{
            sum +=1/i;
        }
        i +=2;
        j++;
    };
    printf("%.6lf",4*sum);
    return 0;
}

 

# include
int main(void){
    int a,n;
    scanf("%d %d",&a,&n);
    int sum=0,sum1=0;
    for(int i=1;i<=n;i++){
        sum = sum*10+a;
        sum1 +=sum;
    }
    printf("%d",sum1);
    return 0;
}

 

# include
int main(void){
    int s1,s2;
    for (int a=1000;a<=9999;a++){
    // 将数据进行拆分 注意 除法/ 和Python 不一样 Python // 代表整除，
    s1 = a/100;
    s2 = a- (a/100)*100;
    if ((s1+s2)*(s1+s2)==a){
        printf("%d ",a);
    }
    }
    return 0;
}

 

# include
int f(int x);
int main(void){
    int x;
    scanf("%d",&x);
    int sum=0;
    sum = f(x);
    printf("%d",sum);
    return 0;
}
int f(int x){
    if(x==1){
        return 10;
    }else{
        return f(x-1)+2;
    }
}

 


#include 
 
int main()
{
    int sum = 0, Length, Matrix;
    scanf( "%d", &Length );     //阶数
 
    for ( int i = 1; i <= Length; i++ )    //行
        for ( int j = 1; j <= Length; j++ )    //列
        {
            scanf( "%d", &Matrix );
            if ( (i == j) || (i + j - 1) == Length )   //判断
                sum += Matrix;          //求和
        }
    printf( "%d", sum );   //输出
    return(0);
}

 

#include
void out_put(int i);
int main(void){
    int N;
    scanf("%d",&N);
    for (int i=2;i<=N;i++){
        out_put(i);
    }
    return 0;
}
void out_put(int i){
    int j;
    for (j=2;j 

#include
int main()
{
    int a,b,c,d,e;
    int f;
    for(a=95860;a<99999;a++)//因为已经是95859了,所以直接从59860开始
    {
        b=a/10000;// 万位
        c=a/1000%10;//千位
        d=a/10%10;//十位
        e=a%10;//个位
        if(b==e && c==d)
        {
            printf("%dn",a);
            break;
        }
    }
    return 0;
}

 

// 直接暴力求解
# include
int main(void){
    for (int x=0;x<=100;x++){
        for(int y=0;y<=100;y++){
           for(int z=0;z<=100;z++){
               if (5*x+3*y+(z/3.0)==100&& x+y+z==100){
                   printf("cock=%d,hen=%d,chicken=%dn",x,y,z);
               }
           } 
        }
    }
    return 0;
}

 

#include
int main(void){
    int n;
    scanf("%d",&n);
    int sum=0;
    int i=0;
    while(sum<=n){
        i++;
        sum +=i*i*i;
    }
    printf("%d",i-1);// 跳出循环时 i已经自增了，需要往后移一位
    
    return 0;
}

 

// 不考虑 1 2 的情况，默认输入的n >2
# include
int main(void){
    int n;
    scanf("%d",&n);
    int flag=0;// 设置标志位 flag=0 代表不是素数
    for (int i=2;i 


# include
# include
long Figure(long n);// 定义获取数字位数的函数
int main(void){
    for (long i=0;i<=200000;i++){
        long  sum =0;
        sum = i*i;
        long n = 0;
        n =Figure(i);// 得到自然数位数
        long n1 = pow(10,n);// 获取位数的平方
        long n2 = sum-i;// 平方-自然数
        if (fmod(n2,n1)==0){
            printf("%ld  ",i);
        }
    }
    return 0;
}
// 定义求自然数位数的方法
long Figure(long n)
{
	long i = 0; 
	
	while(n!=0)
	{
		n = n / 10;//每次除以10
		i++;//统计循环次数
	}
 
	return i;
}

 

# include
int main(void){
    double h=100;
    double s=0;
    int n;
    scanf("%d",&n);
    for (int i=1;i<=n;i++){
        s += h;
        h/=2;
        s+=h;
    }
   printf("%.4lf",s-h);// 注意最后一次落地不计算反弹了，所以这里要减去
    return 0;
}

 


# include
# include
int main(void){
    double sum;
    for (int i=0;i<64;i++){
        sum +=pow(2,i);
    }
    printf("%lf",sum);// 用double存储超大的数
    return 0;
}

 

# include
int main(void){
    int n;
    scanf("%d",&n);
    while(n!=1){
        if (n%2==0){
            printf("%d/%d=%dn",n,2,n/2);
            n = n/2;
        }else{
           printf("%d*3+1=%dn",n,(n*3)+1); 
           n = n*3+1;
        }
    }
    return 0;
}


 

// 大数阶乘使用数组
#include
int main()
{
    int num[10000],i,j=1,rem=0,n,len=1;
    for(i=0;i<10000;i++)
    {
        num[i]=0;  //初始值为0
    }
    num[0]=1;  //令其第一位为1
    while(j<=1977)  //设置变量当小于等于1977时执行循环
    {
        for(i=0;i<=len;i++)  //len为位数，就是num[i]所存的位数
        {
            rem=rem+num[i]*j;
            num[i]=rem%10;
            rem=rem/10;
            if(rem>0&&i==len)
            {
                len++;
            }
        }
        j++;
    }
    for(i=len;i>=0;i--)  //最后将所以位数倒置，就是所想要输出的数据了
        printf("%d",num[i]);
}

 

# include
int main(void){
    int n;
    scanf("%d",&n);
    int sum=0;
    for (int i=1;i<=n;i+=2){// 步长为2取奇数，避免判断
        sum +=i;
    }
    printf("%d",sum);
    return 0;
}

 

# include
int main(void){
    int n;
    scanf("%d",&n);
    double sum=0;
    for (int i=1;i<=n;i++){
        sum += 1.0/i;
    }
    printf("%.6lf",sum);
    return 0;
}

 

#include 
int main()
{
    int i = 1,n = 0;
    int sum = 1;
    scanf("%d",&n);
    if((n>=0) && (n<=12))
    {
        while(i<=n)
        {
            sum *= i;
            i++;
        }
    }
    printf("%dn",sum);
    return 0;
}

 

#include
int main(void){
    int m;
    scanf("%d",&m);
    double sum=1;// 使用double 的原因是，float精度只有6~7 位，double精度有15位
    for(int i=2;i<=m;i++){
        sum -=1.0/(i*i);
    }
    printf("%.6lf",sum);
    return 0;
}

 

 
 
float 精度 67位，能保证的只有6位，double的精度为1516位,能保证的有15位
 

 

#include
int main()
{
// a b 为张家，c d 为李家
int a,b,c,d;//a+b=6    c+d=7
for(a=6;a>0;a--)
{
    for(b=6;b>0;b--)
    {
        for(c=7;c>0;c--)
        {
            for(d=7;d>0;d--)
            {
                add(a,b,c,d);
            }
        }
    }
}
}
int add(int a,int b,int c,int d)
{
    if(a+b==6&&c+d==7&&a!=b&&a!=c&&a!=d&&b!=c&&b!=d&&c!=d&&a-b!=1&&a>b&&c-d!=1&&c>d)//判断，避免重复，相连
    {
        if(a==1||b==1)printf("L");
        else if(c==1||d==1)printf("W");
        else printf("Z");
    }
}


 

#include
int main(void){
    int count=0;
    for(int i=0;i<=4;i++){
        for (int j=0;j<=3;j++){
            if(3*i+5*j>0){
                count++;
            }
        }
        
    }
    printf("%dn",count);
    return 0;
}

 

#include
#include
int jiechen(int n);
int main()
{
    int i,j,k;
    for(i=1;i<=9;i++)
        for(j=0;j<=4;j++)
            for(k=0;k 

# include
int main(void){
    for(int i=2;i<1000;i++){
        int a = i/100;// 百位
        int b = i/10%10;// 十位
        int c = i%10;// 个位
        if (a*a*a+b*b*b+c*c*c==i){
            printf("%d ",i);
        }
    }
    return 0;
}


 
第八章 数组 
8.1 一维数组的定义和使用 

数组是具有相同数据类型的一组数据。
 

# include
int main(void){
    int a[10]={1,2,3,4,5};
	float b[10]={1.1,2.2,3.3,4.4,5.5};
	char c[256]={'c','1'};
    for (int i=0;i<10;i++){
        printf("%dn",a[i]);
    }
    for (int i=0;i<10;i++){
        printf("%fn",b[i]);
    }
    for(int i=0;i<10;i++){
        printf("%cn",c[i]);
    }
    return 0;
}


 

 
 
当在函数中只定义数组时，数组里的值和函数里定义一个变量的值一样，都是未初始化过的，我们也可以定义的时候并初始化赋值，并且，当给部分元素赋初值的时候，未被赋值的元素将自动赋值为0，更细一些，int类型未被赋值的元素为0，浮点型为小数类型，而字符类型则为’’。
 

 
8.2 二维数组的定义和使用 

// 定义一个三行四列的二维数组按行进行赋值
int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
// 定义一个三行四列的二维数组
int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};

 
8.3 字符数组和字符串 

  •  
    字符数组
     
    用来存放字符的数组称为字符数组，字符数组的各个元素依次存放字符串的各个字符。
     
    # include
int main(void){
    char c[6]={'c','h','i','n','a',''};// 代表字符串的结束符，如果不加，系统会自动加上
    char a[]={'china'};
    for (int i=0;i<6;i++){
        printf("%c",c[i]);
    }
    for(int i=0;i<6;i++){
        printf("%c",a[i]);
    }
    return 0;

}

     
 
8.4 总结&练习 

// 思路矩阵使用二维数组a[x][y] 来存储，主对角线数据特征 x=y 副对角线数据特征 x+y=2
# include
int main(){
    int x,y,sum1=0,sum2=0,a[3][3];
    for(x=0;x<3;x++){
        for(y=0;y<3;y++){
            scanf("%d",&a[x][y]);
            if(x==y){
                sum1 +=a[x][y];
            }
            if (x+y==2){
                sum2 +=a[x][y];
            }
        }
    }
    printf("%d %d",sum1,sum2);
    return 0;
}


 

#include 
int main(){
    int nums[10];
    for(int x=0;x<9;x++){
        scanf("%d",&nums[x]);
    }
    scanf("%d",&nums[9]);
    int i, j, temp;

    //冒泡排序算法：进行 n-1 轮比较
    for(i=0; i<10-1; i++){
        //每一轮比较前 n-1-i 个，也就是说，已经排序好的最后 i 个不用比较
        for(j=0; j<10-1-i; j++){
            if(nums[j] > nums[j+1]){
                temp = nums[j];
                nums[j] = nums[j+1];
                nums[j+1] = temp;
            }
        }
    }
   
    //输出排序后的数组
    for(i=0; i<10; i++){
        printf("%dn", nums[i]);
    }
    //printf("n");
   
    return 0;
}

 

# include
int main(void){
    int nums[10];
    for (int x=0;x<10;x++){
        scanf("%d",&nums[x]);
    }
    for(int i=9;i>=0;i--){
        printf("%d ",nums[i]);
    }
    return 0;
    
}

 

# include
int main(void){
    int num;
    scanf("%d",&num);
    printf("%o",num);
    return 0;
}

 

# include
int main(void){
    int F;
    scanf("%d",&F);
    printf("%.2f",5.0*(F-32)/9);
    return 0;
}

 

# include
int main(void){
    int x;
    scanf("%d",&x);
    float y;
    if(x<1){
        y=x;
    }else if(x>=1 && x<10){
        y = 2*x-1;
    }else{
        y = 3*x-11;
    }
    printf("%.2f",y);
    return 0;
}

 

# include
int main(void){
    int n;
    scanf("%d",&n);
    int a[n];
    for(int i=0;i 

# include
int main(void){
    int n;
    scanf("%d",&n);
    int sum=0;
    int count =1;
    int a =2;
    while(count<=n){
        sum +=a;
        a = a+3;
        count++;
    }
    printf("%d",sum);
    return 0;
}

 

# include
int main(void){
    for (int i=10;i<=1000;i++){
        if (i%2==0 && i%3==0 && i%7==0){
            printf("%dn",i);
        }
    }
}

 

 
 
%42 也可以
 

 

# include
int main(void){
    int a[20];
    int count=0,sum=0;
    for (int i=0;i<20;i++){
        scanf("%d",&a[i]);
    }
    for (int i=0;i<20;i++){
        if (a[i]<0){
            count++;
        }else{
            sum +=a[i];
        }
    }
    printf("%d %.2f",count,sum*1.0/(20-count));
    return 0;
}

 

# include
int gcd(int a,int b);//函数声明
int lcm(int a,int b);//函数声明
int main(void){
    int a,b;
    scanf("%d %d",&a,&b);
    printf("%dn%d",gcd(a,b),lcm(a,b));
    return 0;
}
int gcd(int a,int b){
    if (b==0)
        return a;
    return gcd(b,a%b);//递归调用
}
int lcm(int a,int b){
    return (a*b)/gcd(a,b);// 利用 最大公约数*最小公倍数=两数值乘积
}

 

# include
int main(void){
    int a,c,d,b,e;
    a =c =d =b=0;
    while((e=getchar())!=10)// 10为换行的ASCII码
    {
        if (e>=65 && e<=90 || e>=97 && e<=122){
            a++;// 英文字母 ，a自增
        }else if (e>=48 && e<=57){
            b++;// 遇到数字字符 ，b自增
        }else if(e==32){
            c++;//空格 c自增
        }else{
            d++;// 遇到其他字符，自增
        }
    }
    printf("英文字母%d, 数字%d,空格%d,其他%d",a,b,c,d);
    return 0;
}

 

# include
double fibo(n);
double sum=0;
int main(void){
    for (int i=1;i<=30;i++){
        sum +=fibo(i);
    }
    printf("%.2en",sum);
    return 0;
}
double fibo(n){
    if (n==1){
        return 1;
    }else{
        return n*fibo(n-1);
    }
}

 

 
 
科学计数法的使用 %.2e
 

 
第九章 指针 
9.1 地址 

地址是唯一可以表示某一点的一个编号。在计算机中我们常常使用16进制来表示地址。在32为 *** 作系统下，地址范围0~4,294,967,295之间，在C语言中&代表取地址符
 

#include
int main(void){
    int i;
    int a[9]={1,2,3,4,5,6,7,8,9};
    char b[7]={'a','b','c','d','e','f','g'};
    for (i=0;i<9;i++){
        printf("int Address:0x%x,value:%dn",&a[i],a[i]);
    }
    printf("n");
    for (i=0;i<10;i++){
        printf("char Address:0x%x,value:%dn",&a[i],b[i]);
    }
    printf("int arr address is 0x%x",&a);
    return 0;
    
}


 

在64位系统中，指针占8个字节
 

#include
struct INFO
{
        int a;
        char b;
        double c;
};
int main()
{
        int *p;
        char *p1;
        float *p2;
        double *p3;
        struct INFO *p4;   //struct INFO类型为结构体类型 我们将会在后面的章节中讲解
        void *p5;
        printf("int point size is :%dn",sizeof(p));
        printf("char point size is :%dn",sizeof(p1));
        printf("float point size is :%dn",sizeof(p2));
        printf("double point size is :%dn",sizeof(p3));
        printf("struct point size is :%dn",sizeof(p4));
        printf("void point size is :%dn",sizeof(p5));
        return 0;
}


 
9.3 数组和指针 

数组元素，我们可以使用数组下标进行访问，也可以用指针进行访问。在C语言中规定，数组名代表数组的收地址，也就是数组的地址等于第0号元素的地址。
 

#include
int main(void){
    int *p;//定义 p 为指向整型变量的指针
    int a[10];// 定义a 为包含10个整数数据的数组
    p = &a[0];// 把a[0]元素的地址赋值给指针变量 p
    p = a;// 等价于 p=&a[0]
    //int *p = a;//等价于 int *p=&a[0] 或 p=a
    printf("p = 0x%xn",p);
    printf("*p =%dn",*p); 
    return 0;
}


 

访问数组元素的两种方式
 

# include
int main(void){
    int i;
    int a[10]={1,2,3,4,5,6,7,8,9,0};
    int *p = a;
    for(i=0;i<10;i++){
    	printf("p value:%d a value :%dn",*(p++),*(a+i));
    }
    printf("n");
    return 0;
}


 
9.4 字符串与指针 

字符串指针与字符串数组的区别
 

# include
int main(void){
    char *str = "www.baidu.com";
    char string[] = "www.baidu.com";
    string[0]='h';
    printf("string = %s",string);
    //str[1]='h';
    //printf("string = %s",string);   
    return 0;

}


 
第十章 结构体 
10.1 结构体的定义和使用 

结构体和数组类似，都是由若干元素组成，与数组不同的是，结构体的成员可以是不同类型，可以通过成员名来访问结构体的元素。结构体的定义说明了它的组成成员，以及每个成员的数据类型，定义的一般形式如下：
 

struct 结构类型名
{
数据类型 成员名1;
数据类型 成员名2;
....

}

 

# include
# include

struct _INFO{
    int num;
    char str[256];
};
int main(void){
	struct _INFO A;
	A.num = 2014;
	strcpy(A.str,"www.baidu.com");// strcpy 字符串复制
	printf("This year is %d %s",A.num,A.str);
    return 0;
    }


 
10.2 结构体的高级使用 

结构体数组，结构体数组是一个数组，其数组的每一个元素都是结构体类型，在实际应用中，经常使用结构体数组来，表示具有相同数据结构的一个群体。如一个班的学生。
 

# include
struct address
{
	char name[30];
	char street[40];
	unsigned long tel;
	unsigned long zip;
}student[3]={
{"Zhang","Road NO.1",111111,4444},
{"Wang"," Road NO.2",222222,5555},
{"Li"," Road NO.3",333333,6666}
};
}

 

指向结构体的指针，当一个指针用来指向一个结构提变量时，称之为结构体指针变量。结构体指针变量中的值是所指向的结构体变量的首地址，通过结构指针即可访问该结构体变量。这与数组指针和函数指针的情况相同。结构体指针变量定义的一般形式为
 

struct 结构类型名 *结构指针变量名

 
10.3 共用体的定义和使用 

在C语言中，允许几种不同类型的变量存放到同一内存单元，也就是使用覆盖技术，几个变量互相覆盖。这种几个不同的变量共同占有一段内存的结构，被称为共用体类型结构，简称共用体。一般定义形式为
 

union 共用体名{
数据类型 成员名1;
数据类型 成员2;
....
}

 

共用体和结构体的区别
 

1.变量长度不同
结构体变量所占内存长度是各成员所占内存长度之和，每个成员分别占有其自己的内存单元
共用体变量所占的内存长度等于其最长的成员的长度。
2.占用空间不同
结构体是同时存在的，并一次占用一段连续的内存空间
共用体则是多个共用成员占用同一个开始的内存地址，同时他们只能存在一个，所以空间大小就是最大的那个所需的空间，如果单从一个共用体来讲，我们不知道里面存的是什么内容，需要根据程序上下文才能确定
3.分配储存空间不同
结构体是由一系列具有相同类型或不同类型的数据构成的数据集合，简称结构。在C语言中，可以定义结构体类型，将多个相关的变量包装成为一个整体来使用。在结构体中的变量，可以是相同、部分相同，或完全不同的数据类型。

结构体类型的定义只是由用户构造了一个结构体，但定义结构体类型时系统并不为其分配存储空间。
4.共用体所占的内存要比结构体小 ，C中的结构体有点像类

 

共用体的使用
 

# include
union INFO{
	int a;//不能 int a=1; 在共用体里赋值
	int b;
	int c;
    int d;
};
int main(void){
	union INFO A;
	A.a=1;
	A.b=2;
	A.c=3;
	printf("a:%dn",A.a);
	printf("b:%dn",A.b);
	printf("c:%dn",A.c);
    //printf("d:%dn",A.d);
	return 0;
}


 

 
 
不能对共用体变量名赋值,也不能企图引用变量名来得到一个值,并且,不能在定义共用体变量时对 它进行初始化。
 不能把共用体变量作为函数参数, 也不能是函数返回共用体变量, 但可以使用指向共用体变量的指针。 共用体类型可以出现在结构体类型的定义中,也可以定义共用体数组。反之,结构体也可以出现在共 用体类型的定义中,数组也可以作为共用体的成员。
 

 
10.4 使用typedef定义类型 

在C语言中，除系统定义的标准类型和用户自定义的结构体，共用体等类型之外，还可以使用类型说明语句，typedef 定义新的类型来代替已有的类型，typedef 语句的一般形式是
 

typedef 已定义的类型 新的类型
 

typedef int INTEGER;// 指定使用INTEGER 代表 int 类型
typedef float REAL;//指定使用REAL 代表float 类型
// 在具有上述typedef 语句的程序中，下列语句等价
int i,j;// 等价INTEGER i,j;
float pi;// 等价与REAL pi

 

typedef的使用
 

# include
# include
typedef struct _INFO{
	int num;
	char str[256];
}INFO;
int main(void){
	struct _INFO A;
	INFO B;
	A.num = 2014;
	printf("This year is %d %sn",A.num,A.str);
    printf("This year is %d %sn",B.num,B.str);
    return 0;
}


 

 
 
可以看到typedef 可以为关键字改名，使改名之后的INFO类型等价与struct_INFO类型，让我们在定义这种结构类型时更方便，省事。
 
 
事实上，许多windows开发中的许多我们未见过的数据类型，看起来很难懂，但绝大部分都是通过typedef定义后的基本数据类型，大家可以通过追溯变量的定义来了解。
 

 
10.5 总结 

#include
void mycopy(char a[],char b[],int n,int m)
{
    int i,j=0;
    for(i=m-1;i 

#include
//定义学生结构体数组 
struct student
{
    char num [30];    //注意一下这里学号的类型有字母，所以应该字符类型 
    char name[30];                //姓名用字符数组的方式存储 
    int grade1;                    //三科分数，分别定义为整型 
    int grade2;
    int grade3;
    int score;             //后面要每个学生的总分,这里定义一下比较方便 
};
//输入的函数  需要传入学生的个数和结构体名 
void input(int n,struct student stu[n])       
{
    for(int i=0;i 
第十一章 文件 *** 作 

文件 *** 作的三个步骤
 

  1.  
    打开文件
     
    使用fopen函数来实现，这一步主要是建立程序和文件的关系，获取文件在内存中的文件指针
     
  2.  
    读写文件
     
    分为fprint,fscanf,fwrite,fread,fputs,getss等多组函数实现。
     
  3.  
    关闭文件
     
    使用fclose 函数实现，这一步切断文件指针和文件的关联，避免误 *** 作。如果未关闭文件就对文件进行读写删除等 *** 作，就是出现类似“正在被使用，无法修改”的提示。
     
 

fopen 函数的使用
 

写文件fprintf 函数的使用
 

读文件fcanf函数的用法
 

写文件fwrite函数的用法
 

读文件fread函数的用法
 

关闭文件fclose函数的用法
 
第十二章 预处理 

C语言中提供的预处理功能有三种：
 

  1. 宏 定义
  2. 文件包含
  3. 条件编译
 

 
 
#代表是一条预处理命令 define 为宏定义命令，宏命令和全局变量的区别
 
 
http://c.biancheng.net/view/347.html
 

 

// 宏定义
# include
# define MAX(a,b) (a>b)?a:b

int main(){
int a=12,b=15;
printf("max=%d",MAX(a,b));
return 0;
}

 

// 文件包含
# include "stdio.h"
# include 

 

 
 
# include “文件名” 或者 #include <文件名>但是这两种形式是有区别的:使用尖括号表示在包含文件目录中去查找(包含目录是由系统的环境变 量进行设置的,一般为系统头文件的默认存放目录,比如 Linux 系统在/usr/include 目录下),而不在源文件的存放目录中查找; 使用双引号则表示首先在当前的源文件目录中查找, 若未找到才到包含目录中去查找。
 

 

// 条件编译
#ifdef 标识符
程序段 1
#else
程序段 2
#endif


 

// 其他处理命令
1. #error error-message
强制编译程序停止编译，主要用于程序调试
2.#line
3.#pragma
#pragma 是便宜程序实现是定义的指令,它允许由此向编译程序传入各种指令。

 
12.1 宏定义和函数的区别 

 
12.2总结 

#include 
#include 
#define chang(a,b) t=a,a=b,b=t;
int main()
{
    int a,b,t;
    scanf("%d %d",&a,&b);
    chang(a,b);
    printf("%d %d",a,b);
    return 0;
}

 

# include
# define mod(a,b) a%b;
int main(void){
    int a,b;
    scanf("%d %d",&a,&b);
    int c = mod(a,b);
    printf("%d",c);
    return 0;
}

 

# include
# include
# define s(a,b,c) (a+b+c)/2;
# define area(s,a,b,c) sqrt(s*(s-a)*(s-b)*(s-c));
int main(void){
    float a,b,c,S,area,n,m;
    scanf("%f%f%f",&a,&b,&c);
    S = (a+b+c)/2;
    area = area(S,a,b,c);
    printf("%.3f",area);
    return 0;
}

 

#include
#define LEAP_YEAR(y) ((y%4==0&&y%100!=0)||(y%400==0))
int main()
{
int y;
scanf("%d",&y);
if(LEAP_YEAR(y)==0){
    printf("N");
}else{
   printf("L"); 
}
return 0;
}

 

# include
# define max(a,b,c) (a>b?a:b)>c?(a>b?a:b):c;
int Max(a,b,c);
int main(void){
    int a,b,c;
    scanf("%d %d %d",&a,&b,&c);
    float max_value = max(a,b,c);
    float Max_value = Max(a,b,c);
    printf("%.3fn%.3f",max_value,Max_value);
    return 0;
}
int Max(a,b,c){
    return (a>b?a:b)>c?(a>b?a:b):c;
}

 
第十三章 位运算 

C语言中的位运算，是以数值的二进制位单位进行 *** 作
 

  1. <<左移 向左（即高位）移位，右侧补0
  2. >>右移 向右（即低位）移位，左侧补0
  3. -按位取反 如名，即0变1,1变0
  4. &按位与 相对应的两个位都为1则为1，反之为0
  5. |按位或 相对应的两个位至少有一个为1即为1，反之为0
  6. ^按位异或 相对应的两个位相同为0，相异（不同）为1
 

// 左移 右移
# include
int main(void){
int a,b;
a=13<<2;
b=25>>3;
int d=10;
printf("10<<3=%dn",d<<3);
printf("a=%d,b=%dn",a,b);
return 0;
}


 

 
 
左移N位的被指是乘以2的N次方，右移N位的本质是除以2的N次方
 

 

//& 按位与运算符
#include
int main(void){
int a;
a = 3&5;
printf("a=%dn",a);
return 0;
}

 

 
 
按位与运算符的作用 1.清零，我们可以对某一个数与0进行按位与运算，由于两个位都为1才为1，因此最终全部位都变为0，起到清零的作用。2.取指定位 如某些存储场景下，“第13位表示xxxx“”，我们需要取出13位，则可以让原数值与数字7进行按位与运算，得到的结果即是原数值的1~3位的值。3.判断奇偶 可以发现，数字的奇偶取决于二进制位的最低一位是1还是0，因此只需要与1按位与运算，判断是1是0即可得知奇偶。
 

 

// 按位或运算符
# include
int main(void){
int a;
a = 8|7;
print("a=%dn"，a);
return 0;
}

 

 
 
按位或运算符的作用 ，对一个数字的指定位置为1 如“某个数字的第七位”表示开关，原先是0，需要改为1的状态，即可以将这个数字与64按位或，即可得到第七位变为1，其余位的值依旧不变。
 

 

// 按位异或运算符 不同则为1，相同为0
// 异或 *** 作 交换数字
# include
int sqap(int *a,int *b)
{
    if (*a!=*b){
        *a = *a^*b;
        *b = *b^*a;
        *a = *a^*b;
    }
    return 0;
}


 

 
 
异或运算符的作用 1.指定位数的翻转 如想对某个数字的低4位进行翻转，则可以将这个数字与15（二进制为00001111）进行按位异或运算，既可以将原数字的低四位进行翻转，即高四位不变，低四位0变1,1变0 2.与0异或还是原值 3.交换两个数字
 

 

// ~取反运算符
# include
int main(void){
 	unsigned int a=1;
    printf("~a=%un",~a);
	return 0;
}


					
										


					

						
欢迎分享，转载请注明来源：内存溢出
原文地址: http://outofmemory.cn/zaji/4749750.html
赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
电接点双金属温度计 电接点双金属温度计 一级用户组
0 0
上一篇 2022-11-08
下一篇 2022-11-08

发表评论

登录后才能评论

评论列表（0条）

保存