program--4

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

int main()
{
    //字符串的结束标志:"\0"
    //"abcdef"
    //"\0"-转义字符-0
    //0->数字0
    //"0" -> 48
    // "a" "b" "c" "0" "1" "2"
    //EOF ---end of file --文件结束标志 -1
    return 0;
}

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

int main()
{
    int a = 0;
    int b = 0;
    printf("请输入两个数\n");
    scanf("%d %d",&a,&b);
    if(a>b)
        printf("%d 大一些",a);
    else if(a=b)
        printf("一样大");
    else
        printf("%d 大一些",b);
    return 0;
} */

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

int MAX(int a,int b)
{
    int c = 0; 
    if(a>b)
        c = a;
    else
        c = b;
    return c;
}

int main()
{
    int num1 = 10;
    int num2 = 20;
    int max = 0;
    max = MAX(num1,num2)
    printf("较大值为 %d\n",max);
    return 0;
} */


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

int main()
{
    int a = 10;
    int arr[] = {1,2,3,4,5,6};//6*4=24 ->int[6]
    printf("%d\n"sizeof(a));//打印4
    printf("%d\n"sizeof(int));//打印4
    printf("%d\n"sizeof a);//打印4 sizeof是个操作符,如果是函数,括号不能省略。
    printf("%d\n"sizeof int);//报错
    printf("%d\n"sizeof(arr));//打印24,计算数组大小,单位是字节。
    printf("%d\n",sizeof(arr)/sizeof(arr[0]));//打印6
    return 0;
}

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

int main()
{
    int a = 0;//4个字节,32bit
    int b = ~a;//-1  b是有符号的整型
    //~ 按位(二进制)取反
    //00000000000000000000000000000000
    //11111111111111111111111111111111  --> 
    //只要是整数,内存中存储的都是二进制的补码
    //正数的原码、反码、补码相同(三码合一)
    // 原码   反码(原码符号位不变,其他位按位取反得到反码)   补码(反码加一得到补码)
    //补码减一得到反码,反码符号位不变,其他位按位取反得到原码
    //负数在内存中存储的时候,存储的是二进制的补码
    //反码(原码符号位不变,其他位按位取反得到反码)补码(反码加一得到补码)
    
    //-2
    //10000000000000000000000000000010 -> -2的原码
    //11111111111111111111111111111101 -> -2的反码
    //11111111111111111111111111111110 -> -2的补码
    
    //11111111111111111111111111111111
    printf("%d\n",b);//使用的,打印的是这个数的原码
    //11111111111111111111111111111111(补码)
    //11111111111111111111111111111110(反码)
    //10000000000000000000000000000001(原码)-1
    return 0;
    
}


#include<stdio.h>

int main()
{
    int a = 10;
    int b = a++;//后置++,先使用a的值给b赋值,再让a自加1。
    printf("a = %d\n",a);// 11
    printf("b = %d\n",b);// 10
    return 0;
}

#include<stdio.h>

int main()
{
    int a = 10;
    int b = ++a;//前置++,先让a自加1,再让a赋值。
    printf("a = %d\n",a);// 11
    printf("b = %d\n",b);// 11
    return 0;
}

#include<stdio.h>

int main()
{
    int a = 10;
    int b = a--;
    printf("a = %d\n",a);// 9
    printf("b = %d\n",b);// 10
    return 0;
}

#include<stdio.h>

int main()
{
    int a = 10;
    int b = --a;
    printf("a = %d\n",a);// 9
    printf("b = %d\n",b);// 9
    return 0;
}

#include<stdio.h>

int main()
{
    //3.14是double类型
    int a = (int)3.14;//(类型) -- 强制类型转换,让某一个类型强制转换为另一种类型。
    return 0;
}


关系操作符

>
>=
<
<=
!=  用于测试不相等
==  用于测试“相等”


逻辑操作符

&& 逻辑与

|| 逻辑或

#include<stdio.h>

int main()
{
    // 真  -- 非0
    // 假  -- 0
    // && -- 逻辑与
    // || -- 逻辑或
    int a = 3;
    int b = 5;
    int d = 0;
    int c = a && b;
    int e = a && d;
    int f = a || d;
    int g = a || b;
    printf("c = %d\n",c); //打印 1
    printf("e = %d\n",e); //打印 0
    printf("f = %d\n",f); //打印 1
    printf("g = %d\n",g); //打印 1
    return 0;
}

条件操作符

exp1 ? exp2 : exp3

//表达式1的结果如果为真,那表达式2将被执行,且运行的结果将为整个表达式的结果;
//表达式1的结果如果为假,那表达式3将被执行,且运行的结果将为整个表达式的结果;

#include<stdio.h>

int main()
{
    int a = 10;
    int b = 20;
    int max = 0;
    if(a > b)
        max = a;
    else
        max = b;
    
    return 0;
}

#include<stdio.h>

int main()
{
    int a = 10;
    int b = 20;
    int max = 0;
    max = (a > b ? a : b)
    
    return 0;
}

逗号表达式

exp1 , exp2 , exp3 ,...expn


下标引用、函数调用和结构成员

[] () . ->

#include<stdio.h>

int Add(int x, int y)
{
    int z = 0;
    z = x + y;
    return z;
}
int main()
{
    int arr[10]={0};
    arr[4];//[]-->下标引用操作符
    int a = 10;
    int b = 20;
    int sum = Add(a,b);//()-->函数调用操作符
    return 0;
}

常见关键字

auto break (循环里面可以停止循环) case char const continue default do double else enum 
extern (引入外部符号) float for goto if int register (寄存器关键字) return short signed sizeof
static struct (结构体关键字) switch typedef union (联合体/共同体关键字) unsigned void volatile while 

#include<stdio.h>

int main()
{
    auto int a = 10;//局部变量前面都有一个自动变量auto,常常省略。
    register int a = 10;//建议把a设置为寄存器变量里,由编译器决定。
    return 0;
}

计算机存储数据

 ^    寄存器    |

 |    高速缓存  | 

 |      内存      |  8G/4G/16G

 |      硬盘      v    500G

访问速度从下往上依次增高,容量大小由上往下依次增大。

int 定义的变量是有符号的
        signed int ;//signed常常省略
        unsigned int ;//定义无符号数,永远是正数。
        
自定义的变量符号不可以和关键字冲突。

#include<stdio.h>

int main()
{
    //int float ;error
    //typedef -类型定义 - 类型重定义
    typedef unsigned int u_int;
    unsigned int num = 20;
    u_int num2 = 20;
    return 0;
}


关键字 static

在C语言中:static 是用来修饰变量和函数的
1、修饰局部变量,静态局部变量
2、修饰全局变量,静态全局变量
3、修饰函数,静态函数

#include<stdio.h>

void tset()
{
    int a = 1;
    a++;
    printf("a= %d\n",a);
    
}

int main()
{
    int i = 0;
    while(i < 5)
    {
        test();
        i++;
    }
    return 0;
}

//打印 2 2 2 2 2 


#include<stdio.h>

void tset()
{
    static int a = 1;//a 是一个静态的局部变量,使生命周期变长
    a++;
    printf("a= %d\n",a);
    
}

int main()
{
    int i = 0;
    while(i < 5)
    {
        test();
        i++;
    }
    return 0;
}

//打印 2 3 4 5 6 

重新创建一个文件add.c

int g_val = 2020;//全局变量

#include<stdio.h>

int main()
{
    //extern -- 声明外部符号的
    extern int g_val;
    printf("g_val= %d\n",g_val);
    return 0;
}//打印 2020

只要用关键字extern 去声明全局变量,就可以使用。

重新创建一个文件add.c

static int g_val = 2020;//静态全局变量

#include<stdio.h>

int main()
{
    //extern -- 声明外部符号的
    extern int g_val;
    printf("g_val= %d\n",g_val);
    return 0;
}//报错

//g_val变为静态全局变量,改变了变量的作用域,让静态的全局变量只能在自己所在的源文件内部使用。
//出了源文件就没办法使用。

重新创建一个文件add.c

//static int g_val = 2020;//静态全局变量
//定义一个函数
int Add(int x, int y)
{
    int z = x + y;
    return z;
}

#include<stdio.h>

//使用add.c中的Add函数时,必须先声明。声明外部函数。
extern int Add(int,int);
int main()
{
    int a = 10;
    int b = 20;
    int sum = A(a,b);
    printf("sum = %d",sum);
    return 0;
}//打印30

重新创建一个文件add.c

//static int g_val = 2020;//静态全局变量
//定义一个函数
static int Add(int x, int y)//static修饰函数,改变了函数的作用域
{
    int z = x + y;
    return z;
}
//static修饰函数,改变了函数的链接属性,
//外部链接属性 --> 内部链接属性
#include<stdio.h>

//使用add.c中的Add函数时,必须先声明。声明外部函数。
extern int Add(int,int);
int main()
{
    int a = 10;
    int b = 20;
    int sum = A(a,b);
    printf("sum = %d",sum);
    return 0;
}//无法找到Add。


#define 定义常量和宏

//define 定义标识符常量

#include<stdio.h>

#define MAX 100

int main()
{
    int a = 100;
    int a = MAX;
    return 0;
}

//define 定义宏--带参数

#include<stdio.h>

#define MAX 100

Max(int x, int y)
{
    if(x > y)
        return x;
    else
        return y  ;
}

#define MAX(X,Y) (X>Y?X:Y)

int main()
{
    
    int a = 10;
    int b = 20;
    int max = Max(a, b);
    printf("max = %d\n",max);
    //宏的方式
    max = MAX(a, b);
    //max = (a>b?a:b)
    printf("max = %d\n",max);
    return 0;
}

指针

内存是电脑上特别重要的存储器,计算机中所有程序的运行都是在内存中进行的。所以为了有效的使用内存,就把
内存划分成一个个小的内存单元,每个内存单元的大小是1个字节。为了能够有效的访问到内存的每个单元,就给内
存单元进行了编号,这些编号被称为该内存单元的地址。

                                   内存
                                 一个字节    0XFFFFFFFF
                                 一个字节    0XFFFFFFFE        
                                 一个字节
                                 
                                 
                                 
                                 一个字节    0X00000002
                                 一个字节    0X00000001
                                 一个字节    0X00000000
怎么给空间编号?
空间有多大?
如何产生地址?
32位:32根地址线/数据线
正电和负电的区别
 1      0
00000000000000000000000000000000     0
00000000000000000000000000000001     1
00000000000000000000000000000010     2 
...                                  .
01111111111111111111111111111111     .
10000000000000000000000000000000     .
...                                  .
11111111111111111111111111111111 2的32次方
以上共2的32次方种二进制序列排列

2的32次方为4,294,967,296 bit --> (除以8得字节byte)536,870,912 byte -->(除以1024得字节Kb)524,288 Kb
--> (除以1024得字节Mb)512 Mb -->(除以1024得字节Gb)0.5 Gb 

int a = 10;
//申请4个字节的空间

#include<stdio.h>

int main()
{
    int a = 10;//向内存申请4个字节
    int* p = &a;//&a;取a的地址
    //printf("%p\n",&a);
    //printf("%p\n",p);
    *P = 20;//解引用操作符
    printf("a = %d\n",a);
    //有一种变量是用来存地址的--->指针变量
    //printf("%p\n",&a);//%p取地址
    return 0;
}

#include<stdio.h>

int main()
{
    char ch = 'w';
    char* pc = &ch;
    printf("%d\n",sizeof(pc));
    *pc = 'a';
    printf("%c\n",ch);
    return 0;
}//打印a

指针大小在32位平台是4个字节,64位平台是8个字节。


结构体

结构体是C语言中特别重要的知识点,结构体使得C语言有能力描述复杂类型。
比如描述学生,学生包含:名字+年龄+性别+学号 这几项信息。
这里只能使用结构体来描述了。

复杂对象
人:名字 身高 年龄 身份号码
书:书名 出版社 定价 书号
复杂对象--结构体--我们自己创造出的一种类型
#include<stdio.h>
//创建一个结构体类型
struct Book
{
    char name[20];//C语言程序设计
    short price;//55
};//创建了书的类型

int main()
{
    //利用结构体类型创建一个该类型的结构体变量
    struct Book b1 = {"C语言程序设计",55};
    struct Book* pb = &b1;
    //利用Pb打印出我的书名和价格
    printf("%s\n",pb->name);
    printf("%d\n",pb->price);
    // -> 结构体指针->成员
    //printf("%s\n",(*pb).name);
    //printf("%d\n",(*pb).price);
    // .  结构体变量.成员
    //printf("书名:%s\n",b1.name);
    //printf("价格:%d\n",b1.price);
    strcpy(b1.name,"C++");//strcpy是库函数,字符串拷贝,需要引用头文件--string.h
    b1.price = 15;
    printf("修改后的价格:%d\n",b1.price);
    printf("修改后的书名:%s\n",b1.name);
    return 0;
}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值