22C代码
.c —— 源文件
.h —— 头文件
程序1：
#include <stdio.h>
#include //include相当于用别人的函数打招呼
<stdio.h> 库函数 c语言本身提供给我们使用的函数
//包含一个叫stdio.h的文件
//std-标准standard i-input o-output
int main（） //主函数——程序的入口——main函数有且仅有一个
{
Printf(“hello world\n”); //函数-printf(print function)-打印函数
Return 0;
}
程序2：
#include <stdio.h>
//int 是整形的意思
//main 前面的int表示main函数调用返回一个整型值
Int main()
{
Return 0; //返回0
}
Void main（） //过时写法
{
}
C语言的数据类型
Char //字符类型数据 （A,B,C…..）
Short //短整型
Int //整型
Long //长整型
Long long //更长整型
Float //单精度浮点数
Double //双精度浮点数
20（整型）
55.5（小数——浮点数）
程序3：
#include <stdio.h>
//char-字符类型
int main()
{
char ch ='A';//内存申请了空间叫ch，给里面放个字符A
printf("%c\n",ch);//%c-打印字符格式的数据
return 0;
}
程序4：
#include <stdio.h>
int main()
{
int age = 20;
printf("%d\n",age);//%d-打印整型十进制数据
return 0;
}
程序5：
#include <stdio.h>
int main()
{
long num = 100; //long-长整型
printf("%d\n",num);//%d-打印整型十进制数据
return 0;
}
%d-打印整型
%c-打印字符
%f-打印浮点型（打印小数）
%p-以地址的形式打印
%x-打印十六进制
%o-
%u-
程序6：
#include <stdio.h>
int main()
{
float f = 5.0;
printf("%f\n",f);//小数点后面能包含5个小数位
return 0;
}
程序7：
#include <stdio.h>
int main()
{
double d = 3.14;
printf("%lf\n",d);//可以用%f打印但是不合适，这里用%lf打印双精度浮点数
return 0;
}
程序8：
Long也有可能为8个字节，因为c语言标准规定 sizeof（long）>=sizeof(int)
字节——计算机中的单位
bit-比特位<byte-字节<kb<mb<gb<tb<pb
计算机是硬件-通电
正电 负电
- 0
计算机能够识别正负电，能够识别1和0的指令，保存1和0的单位就是一个比特位。一个字节是8个比特位的大小，1kb=1024byte 1mb=1024kb 1gb=1024gb 以此类推
3个比特位能表示的数是2的三次方个数
Short能表示的比特位 2个字节 16个比特位
0000000000000000——1111111111111111 一共有2的16次方个数
为什么有短整型、长整型、长长整型？而浮点型只有单精度与双精度？
例如：
int age=20; //4个字节 32个比特位
Short int age=20;//2个字节 16个比特位 最大表示到2^16-1这个数
加了short 更加合理更加节省空间，这就是为什么细化出数据类型的目的
程序9：
#include <stdio.h>
int main()
{
//年龄
short age = 20;//向内存申请2个字节，用来存放20
float weight = 95.6f;//向内存申请4个字节用来存放小数
//添加f的原因，95.6默认编辑器会认为double类型，发生精度丢失。会产生警告
return 0;
}
变量和常量
定义变量的方法 类型+变量名+赋值
例如： int age = 150;
变量：
程序10：
#include <stdio.h>
int a = 100;//全局变量——定义在大括号（也被称之为代码块）之外的变量
int main()
{
int a =10;//局部变量——定义在大括号内部的变量
printf("%d\n",a);
return 0;
}
全局变量和局部变量可以同时存在，局部变量和全局变量的名字建议不要相同，容易误会产生bug
当全局变量和局部变量同时存在时，局部变量优先
放在main函数内部的变量是局部变量，但不能说局部变量都放在main函数内部
程序11：
#include <stdio.h>
int main()
{
{
int a =10;
}
printf("%d\n",a);
//会发现代码有错误，因为局部变量的使用范围有限制
return 0;
}
程序12：
#include <stdio.h>
int main()
{
//计算两个数的和
int num1 = 0;
int num2 = 0;
//输入数据——使用输入函数scanf
scanf("%d%d",&num1,&num2);//取地址符号&，意思就是把%d的数字取出来存放在num1的地址处
int sum = 0;//语法错误缺少；在类型的前面，这个错误属于无意义的错误
//c语言语法规定，变量要定义在当前代码块（大括号）的最前面
sum = num1 + num2;//整型变量让它等于两个数相加的和
printf("sum=%d\n",sum);
return 0;
}
故上述代码是错误代码。
改正代码：
#include <stdio.h>
int main()
{
//计算两个数的和
int num1 = 0;
int num2 = 0;
int sum = 0;
//输入数据——使用输入函数scanf
scanf("%d%d",&num1,&num2);//取地址符号&，意思就是把%d的数字取出来存放在num1的地址处
sum = num1 + num2;//创建整型变量让它等于两个数相加的和
printf("sum=%d\n",sum);
return 0;
}
这句话的意思当我们在用scanf时，警告我们尽量不去使用scanf而去使用scanf_s函数，因为scanf不安全，因为scanf是c语言提供的，而scanf_s不是标准c语言提供的，而是VS编译器提供的，如果拿到其他编译器可能无法识别，这时候我们的代码就不具有跨平台性和可移植性。
后面的语句说如果想让警告失效，在源文件的第一行加上
#define _CRT_SECURE_NO_WARNINGS 1意思就是让警告失效，我们再次启动代码，可以发现警告消失
类似代码还有 strcpy、strlen、strcat、…这些按传统意义上来讲都属于不安全的代码。
程序13：局部变量的作用域
#include <stdio.h>
int main()
{
int num = 0;
printf("num = %d\n",num); //num的作用域就是大括号范围
return 0;
}
假设代码为以下就会报错：
#include <stdio.h>
int main()
{
{
int num =0;
}
printf("num = %d\n",num);
//num的作用域就是大括号范围，在对应的大括号内才能进行操作否则就会报错
return 0;
}
程序14：全局变量的作用域
#include <stdio.h>
int global = 2020;
void test()
{
printf("test()--%d\n",global);//创建函数
}
int main()
{
test();//调用test函数
printf("%d\n",global);
return 0 ;
}
//全局变量的作用域整个工程，任何地方都可以用
全局变量与局部变量冲突，局部变量优先
程序15：
重新建立一个c的源文件如图所示
然后在sum.c中写如下代码：
int g_val = 2021;
然后再重新回到test.c中写如下代码;
#include <stdio.h>
int main()
{
//未声明的标识符g_val
//声明
extern int g_val;//extern用来声明外部符号
printf("g_val=%d\n",g_val);
return 0 ;
}
//全局变量的作用域整个工程，任何地方都可以用,倘若在其他c文件中定义了全局变量，在另外的c1文件中也可以调用，不过需要加extern用来声明外部来的变量。
程序16：生命周期
#include <stdio.h>
int main()
{
{
int a = 10;//局部变量生命周期的开始进作用域开始，到出作用域结束
printf("a= %d\n",a);//正确
}
printf("a= %d\n",a);//错误
return 0;
}
全局变量的生命周期和main函数的生命周期一样，main函数的生命周期就是整个程序的生命周期
倘若想在每个源代码之前都加上一段代码，你需要找到vs2010的安装路径中的newc++file用记事本方式打开，把自己想要在每个源代码加的代码输入进去，并替换掉原来的newc++file文件即可。之后创立的源文件开头都会有你想要加的代码。
常量
程序17：
#include <stdio.h>
int main()
{
int num=4;
3;//字面常量
100;
3.14;
return 0;
}
程序18：
#include <stdio.h>
int main()
{
//const -常属性
//const修饰的常变量——num，const只是让它不能变，但是它本质还是变量。
const int num=4;
//num不能被修改了，虽然有const有常属性。但是num的本质属性还是一个变量
printf("%d\n",num);
num =8; //这儿num不能再被赋值了
printf("%d\n",num);
return 0;
}
程序19：
#include <stdio.h>
//#define定义的标识符常量
#define MAX 10 //MAX为10
int main()
{
printf("%d\n",MAX);
return 0;
}
程序20：
#include <stdio.h>
//枚举常量——一一列举
//性别：男，女，保密
//三原色：红，绿，蓝，
//星期：一二三四五六七
//枚举关键字——enum
enum Sex
{
MALE, //枚举常量，男，女，保密
FEMALE,
SECRET
};
int main()
{
//enum Sex s = MALE;
printf("%d\n",MALE); //0
printf("%d\n",FEMALE);//1
printf("%d\n",SECRET);//2
return 0;
}
程序21：
#include <stdio.h>
enum COLOR
{
RED, //枚举常量，红，绿，蓝
GREEN,
BLUE
};
int main()
{
enum COLOR color = BLUE; //color为变量，通过枚举类型创造出来的变量是可以改变的
color = RED;
//BLUE = 6; //枚举常量无法改变,此处的BLUE本身的值应该是2
return 0;
}
字符串类型，由双引号引起的一串例子
"abcde";
"hello cecil";
"";//空字符串
程序22：
#include <stdio.h>
int main()
{
//把abc存起来
char arr1[]="abc";//数组(一组数)
//可以把一个字符串放到数组当中去
printf("%s\n",arr1);//%s可以打印出来数组
return 0;
}
程序23：
#include <stdio.h>
int main()
{
//把abc存起来
char arr1[]="abc";//数组(一组数)
//可以把一个字符串放到数组当中去
//"abc"--'a''b''c''\0' 相当于末尾放了一个\0,\0的值为0，\0相当于字符串的结束标志
char arr2[]={'a','b','c',0};//单个字符放进去是字符，多个字符是字符串。此处在arr中放了三个字符
//第二种写法打印完a，b，c，因为没有结束标志，所以打印的都是一些随机值，就是“烫烫烫”如果主动放个\0或者0都可以让字符串结束
//\0只是字符串结束的标志，不是字符串结束的内容，
//数据在计算机上存储的时候，存储的是二进制
//给字符编值
//'a'--97 'A'--65 ...
//上述就是ASCII编码,所对应的值叫ASCII码值，如有需要可以查ASCII吗表
printf("%s\n",arr1);
printf("%s\n",arr2);
return 0;
}
程序24：
#include <stdio.h>
int main()
{
char arr1[] = "abc";
char arr2[] = {'a','b','c'};
printf("%d\n",strlen(arr1));//strlen - string length字符串长度--用来计算字符串长度的
//abc有三个字符所以答案显示为3
printf("%d\n",strlen(arr2));
//因为arr2后面没有\0结束，所以strlen还要向后寻找随机值，直到找到\0才可以结束，
//通过答案可以看出找了15个字符串才找到的，但是答案为随机值。因为abc之后没有人知道什么时候才能遇到\0，\0是转义字符，转变原来的意思
//如果主动在{'a','b','c'}后加个\0，结果显示就是3了
return 0;
}
程序25：
#include <stdio.h>
int main()
{
printf("abc\n");
//在abc后加\n，\n的意思就是换行符号，
return 0;
}
程序26：
各种字符号的作用（转义字符）
\? 在书写连续多个问号时使用，防止多个问号与后面代码被电脑解析为三字母词
PS:??+)à在c语言早期称之为三字母词,导致了本来想表达??)，但是机器却编译成了】，如果想改成小括号，就需要改成\?\?)
\\ 用于表示一个反斜杠，方式它被解释为另一个转义序列符号 【程序27】
\” & \’ 在双引号或者单引号前面加一个斜杠，都表明这个斜杠只是简单的字符斜杠
【程序28、29】
程序27：
#include <stdio.h>
int main()
{
printf("c:\\test\32\\test.c");
//此时在\test\32\test.c中添加了两个斜杠，前一个斜杠用来转义后面的斜杠，让后面的斜杠变为普通斜杠
//\t——为水平制表符，意思就是Tab键空出来的空间大小
return 0;
}不懂见程序30
程序28：
#include <stdio.h>
int main()
{
printf("%c\n",'\'');
//想把单引号作为字符打印出来，
return 0;
}
程序29：
#include <stdio.h>
int main()
{
printf("%s\n","\"");
//想把双引号作为字符打印出来，
return 0;
}
程序30：
#include <stdio.h>
#include <string.h> //使用strlen这个函数需要引这个头文件
int main()
{
printf("%d\n",strlen("c:\test\32\test.c"));
//\t属于转义字符，在这儿属于一个字符
//\32也属于转义字符
//当我们遇到\后跟三个数字的时候,这一个或者三个数字表示八进制数字
//\32--32是指两个八进制数字，是32作为8进制代表的那个十进制数字，作为ASCII码值对应的字符
//32-->十进制26->作为ASCII码值代表的字符，查ASCII表，看出为一个向右的箭头——>
printf("%c\n",'\32');
//输出便可以看出
printf("%c\n",'\132');
//132转化为10进制为90，查ASCII表得知90为Z,输出便可。
//8进制都是0-7组成的，不能出现8
printf("%c\n",'\x61');
//当我们遇到\X后跟两个数字的时候,这一个或者两个数字表示十六进制数字转换十进制，与上述相同
//61->十进制97 查ASCII表可知97代表的值为a，输出便可
return 0;
注释”//”是c++的注释风格，可以注释一行或者多行
/* …（注释内容） */是c语言的注释，缺点是不能嵌套注释
程序31：
#include <stdio.h>
/*
int main()
{
/*
int a =10;
*/
return 0;
}
*/—— 只要/*遇到了*/就注释结束了，所以最后这个*/不是注释内容。
Ctrl c+k注释 ctrl k+u取消注释
注释在代码难懂的地方使用
程序32：
#include <stdio.h>
int main()
{
int input = 0;
printf("问你个问题\n");
printf("贾鹏昊是不是我儿子(1/0)>:");
scanf("%d",&input);
if(input == 1)//c语言中的判断语句
printf("确实\n");
else
printf("瞎了你的狗眼\n");
return 0;
}
C语言的循环语句
While循环 、 for语句 、 do… while语句
程序33：
#include <stdio.h>
int main()
{
int line = 0;
printf("加入比特\n");
while(line<20000)//括号里是判断条件
{
printf("敲一行代码: %d\n",line);
line++;//计数加一行代码
}
if(line>=20000)
printf("睾手\n");
return 0;
}
程序34：
int ADD(int x, int y)//函数的参数
{
int z=x+y;//函数的返回类型
return z;
}//函数体
#include <stdio.h>
int main()
{
//计算两个数的和
int num1 = 0;
int num2 = 0;
int sum = 0;
int a =100;
int b =200;
scanf("%d%d",&num1,&num2);
sum=ADD(num1,num2);//sum = num1 + num2;
sum=ADD(a,b); //sum = a+ b;把加法简化成了add，这个add称之为函数
//函数也就是
printf("sum=%d\n",sum);
return 0;
}
函数分为库函数（系统自带）与自定义函数（自己独立创造）
数组：一组相同类型元素的集合
程序35：
#include <stdio.h>
int main()
{
/* int a =1;
int b =2;
int c =3;
*/
int arr[10]={1,2,3,4,5,6,7,8,9,10};//定义一个存放10个整型数字的数组arr
//数组每个下标 0,1,2,3,4,5,6,7,8,9，下标从0开始，下标为了访问数组元素
//打印0-9个10个元素
int i =0;
while(i<10)
{
printf("%d\n",arr[i]);
i++;
}
//printf("%d\n",arr[4]);//结果是5，arr[下标]
//char ch[20];//
//float arr2[5];//
return 0;
}
操作符
算数操作符： + - * / %(取模)
移位操作符：<< >>
位操作符： & | ^
赋值操作符：+= -= &= |= …
单目操作符：
！（逻辑反操作） - （负号） &（取地址）
sizeof（计算的变量/类型所占空间的大小，单位是字节）
双目操作符：
三目操作符：
程序36：
#include <stdio.h>
int main()
{
int a = 5%2;//取模
printf("%d\n",a );//5除2会余1 1为模
return 0;
}
程序37：
#include <stdio.h>
int main()
{
//移（二进制）位操作符
//<<左移
//>>右移
int a = 1;
//整型1占4个字节-32bit位
//000000000000000000000001
int b= a<<2;//挪动位数
printf("%d\n",b);//将最后一位的1向前移动一位，于是答案变成了4
return 0;
}
程序38
#include <stdio.h>
int main()
{
//（2进制）位操作
//& 按位与
//| 按位或
//^ 按位异或
int a =3;
int b =5;
int c= a&b;
//3->011 5->101
//对应的二进制与 c=1&0 1&0 1&1=001二进制 =1十进制 同一则1
//或的话是有一则一
//异或是位相同则为0，相异则为1
printf("%d\n",c);
return 0;
}
程序39：
#include <stdio.h>
int main()
{
int a =10;
a = 20;//= 赋值 == 判断相等
a= a+10; //也可以这样写：a+= 10;
a= a-20; //也可以这样写：a-=20;
a=a & 2;
a &= 2;
//复合赋值符号
//+= -= ...
return 0;
}
程序40：
#include <stdio.h>
int main()
{
//int a =10;
//int b =20;
//a+b;//+双目操作符（有两个操作数）顾名思义可知单目和三目
int a =10;
printf("%d\n",a);
printf("%d\n",!a);//!——逻辑反操作符
//c语言中我们要表示真假 0-假 一切非0-真
//倘若a为0，则！a为1
return 0;
}
程序45：
#include <stdio.h>
int main()
{
//字符串的结束标志是"\0"
//"\0"——转义字符 ASCII码值为0
//0——数字0
//"0"——字符0，ASCII码值为48
//EOF---文件结束标志----1
return 0;
}
程序46：
#include <stdio.h>
int main()
{
int num1 = 10;
int num2 = 20;
if(num1>num2)
printf("较大值是：%d",num1);
else
printf("较大值是：%d",num2);
return 0;
}
程序47：【46的函数写法】
#include <stdio.h>
int MAX(int x,int y)
{
if(x>y)
return x;
else
return y;
}
int main()
{
int num1 = 0;
int num2 = 0;
int max = 0;
max= MAX(num1,num2);
printf("max = %d\n",max);
return 0;
}
程序48：
#include <stdio.h>
#include <string.h>
int main()
{
int a= 10;
int arr[]={1,2,3,4,5,6};//6个元素，每个元素都是一个整型，一个整型4个字节
printf("%d\n",sizeof(a));//整型变量占4个字节
printf("%d\n",sizeof(int));//4，等于上面的
printf("%d\n",sizeof a);//等价与第一种写法
printf("%d\n",sizeof(arr));//计算数组大小，
printf("%d\n",sizeof(arr)/sizeof(arr[0]));//总大小除单个大小就是数组的元素个数
return 0;
}
程序49：
#include <stdio.h>
int main()
{
int a =10;
int b =a++;//后置++;先使用a的值，再让a++，a=11，b=10
printf("a=%d b=%d\n",a,b);
return 0;
}
程序50：
#include <stdio.h>
int main()
{
int a =10;
int b =++a;//前置++，先++，再使用；a=11，b=11
printf("a=%d b=%d\n",a,b);
return 0;
}
程序51：
#include <stdio.h>
int main()
{
int a =10;
int b =a--;//后置--，先使用，再--，a=9，b=10
printf("a=%d b=%d\n",a,b);
return 0;
}
（类型）--强制类型转换
程序52：
#include <stdio.h>
int main()
{
int a = 3.14; //若不想看到警告要进行强制类型转换
//int a =(int)3.14 为强制类型转换
return 0;
}
关系操作符（大于>=，小于<=，用于测试是否等于==,用于测试是否不等于!=）
逻辑操作符（&& 逻辑与，||逻辑或）
程序53：
#include <stdio.h>
int main()
{
//真（非0） 假（0）
//逻辑与
int a =3 ;
int b =5;
int c = a && b;//左边为3，右边为5，二者同时为真，结果也为真（1）
printf("c=%d\n",c);
return 0;
}
程序54：
#include <stdio.h>
int main()
{
//真（非0） 假（0）
//逻辑与
int a =0 ;
int b =5;
int c = a && b;//左边为0(假)，右边为5，结果为假（0）
printf("c=%d\n",c);
return 0;
}
程序55：
#include <stdio.h>
int main()
{
//真（非0） 假（0）
//逻辑或
int a =0 ;
int b =5;
int c = a || b;//左边为0(假)，右边为5，两者只要有真就为真
printf("c=%d\n",c);
return 0;
}
条件操作符(三目操作符，因为有三个操作数)：（exp1 ? exp2 : exp3;）
程序56：
#include <stdio.h>
int main()
{
int a = 10;
int b =20;
int max =0;
max=(a>b? a:b); //三目操作符应用示例
//如果a>b表达式的结果为真，那么表达式2(a:b)就要被执行
if (a>b) //这个式子a小于b，为假，b就要赋值给max，反之的话，a就要赋值给max
max =a ;
else
max =b;
return 0;
}
下标引用操作符[]、函数调用操作符()、结构成员 . ->
程序57：
#include <stdio.h>
int Add(int x, int y)
{
int z=0;
z = x+y;
return z;
}
int main()
{
int a =10;
int b= 20;
int sum = Add(a,b);//（）-函数调用操作符
return 0;
}
只要是整数，内存中存储的都是二进制的补码
正数--原码，反码，补码相同
负数—补码
原码是直接按照正负写出的二进制序列
反码是原码符号位不变，其他位按位取反得出来的
补码是反码+1得到的
例子：
-2
原码：10000000000000000000000000000010 一共32位（最高位论正负）
反码：11111111111111111111111111111101 按位取反即可
补码：11111111111111111111111111111110 反码+1得到
内置常见关键字：（不可与变量名冲突）
Auto break case const continue default do else enum extern fo goto if register return voliatile sizeof static struct switch typeof union while
Char double int lonog short unsigned void
计算机 存储数据
寄存器
高速缓存
内存
硬盘
金字塔由下到上，访问速度由慢到快，空间是越来越小
CPU:中央处理器（从内存中拿数据）
早期CPU处理速度和内存访问速度是相匹配的
如今CPU处理速度越来越快，内存访问速度跟不上，所以高速缓存，寄存器出现。
如今甚至未来CPU都从寄存器中提取数据，寄存器提取完了依次高速缓存这样提取
程序58：（register 关键字使用）
#include <stdio.h>
int main()
{
register int a = 10;//把a定义成寄存器变量（快一些），仅提建议作用，因为寄存器有限
return 0;
}
程序59：（unsigned int 关键字使用）
#include <stdio.h>
int main()
{
int a =10;
a = -2;
//int 定义的变量是有符号的 其实是signed int 省去了前面
//unsigned int num=0 num被称之为无符号数，无论怎样都是正数
return 0;
}
程序60：（typedef关键字使用）
#include <stdio.h>
int main()
{
//typedef-类型定义-类型量定义
typedef unsigned int u_int;
unsigned int num = 20;
u_int num2 = 20; //将unsigned改为u_int (类似昵称) 所以num与num2是一样的
return 0;
}
程序61：
#include <stdio.h>
void test()
{
int a = 1; //a为局部变量
a++;
printf("a=%d\n", a);
} //a的作用范围结束
int main() //从这里开始
{
int i = 0;
while (i < 5)
{
test();//从这里开始进行上面的函数内容
i++; //判断是否小于5
}
return 0;
}
程序62：（static关键字修饰局部变量使用）
#include <stdio.h>
void test()
{
static int a = 1; //a为静态局部变量
a++;
printf("a=%d\n", a);
} //static 修饰局部变量 局部变量 出了作用域不销毁了
int main() //从这里开始
{
int i = 0;
while (i < 5)
{
test();//从这里开始进行上面的函数内容
i++; //判断是否小于5
}
return 0;
}
程序63：（extern声明外部符号）
注：提前在外部添加源文件 int g_val = 2020;//全局变量 若前方加static则发生错误 见末尾
#include <stdio.h>
int main()
{
{
//extern -声明外部符号
extern int g_val;
printf("g_val=%d\n", g_val);
}
return 0;
}
变量有两个作用范围，一个是生命周期，一个是作用域
static修饰局部变量，类似程序62，局部变量的生命周期变长
static修饰全局变量 改变了变量的作用域 让静态全局变量只能在自己的源文件内部使用，出了源文件就没办法再使用了
static可以修饰函数 也是改变函数的链接属性 普通函数是有外部链接属性 本来声明一下就可以使用 但是static修饰就变成了内部链接，声明后无法使用
程序64：
另一个源文件的程序为：
//定义一个函数
int Add(int x, int y)
{
int z = x + y;
return z;
}
主程序的函数：
//声明外部函数，依然是extern
#include <stdio.h>
extern int Add(int, int);
int main()
{
int a = 10;
int b = 20;
int sum = Add(a, b);
printf("sum=%d\n", sum);
return 0;
}
程序65：(#define 定义宏) 注:#define 定义常量见程序19
此段代码报错 但是老师可正常运行
#include <stdio.h>
//函数实现
int Max(int x, int y)
{
if (x > y)
return x;
else
return y;
}
//宏的定义方式
#define MAX (int X,int 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;
}
指针：
通过地址的方式找到空间
将内存切成小格子 每个格子都会有个编号
首先问题就是： 如何产生地址？ 如何产生编号？
32位 ：32根物理地址线或者数据线 通电就有正负电之分
正负电用1 0表达 32个0与1编号
00000000000000000000000000000000
00000000000000000000000000000001
... 大内存块划分内存单元
11111111111111111111111111111111
一共有2的二十三次方个二进制序列 产生2的32次方个内存编号
1小格子是一个字节的大小
64位的计算器同理
指针大小在32位平台是4个字节，64位平台是8个字节
程序66：
#include <stdio.h>
int main()
{
int a = 10;//4个字节
&a;//&：取地址符号 取a的地址
printf("%p\n", &a);
return 0;
}
程序67：
#include <stdio.h>
int main()
{
int a = 10;//4个字节
int* p =&a;//&：取地址符号 取a的地址 并存在p中
printf("%p\n", &a);
printf("%p\n", p);
return 0;
}
程序68：
#include <stdio.h>
int main()
{
int a = 10;//4个字节
int* p =&a;//&：取地址符号 取a的地址 并存在p中
printf("%p\n", &a);
printf("%p\n", p);
* p=20;//*--解引用操作符
//有一种变量用来存放地址---指针变量
printf("a=%d\n", a);
return 0;
}
0x0012ff40
Int a =10; 10 |20 a
Int* p =&a; 0x0012ff40 p
*p=20;
程序69：
#include <stdio.h>
int main()
{
char ch = 'w';
char* pc = &ch;
*pc = 'a';
printf("%c\n", ch);
return 0;
}
程序70：
#include <stdio.h>
int main()
{
int a = 10; //申请了4个字节的空间
printf("%p\n", &a);
int* p = &a;//p是一个变量 也告诉我们p是一个指针变量
printf("%p\n", p);
*p = 20;//*--解引用操作符 间接访问操作符
printf("a=%d\n", a);
return 0;
}
程序71：
#include <stdio.h>
int main()
{
double d = 3.14;
double* pd = &d;
*pd = 5.52;
printf("d=%lf\n", d);
printf("*pd=%lf\n", *pd);
return 0;
}
程序71：
#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);
return 0;
}
程序72：
#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);
return 0;
}
与程序71相同
. 结构体变量.成员
-> 结构体变量->成员
程序78：
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
//创建一个结构体类型
struct book
{
char name [20]; //C语言程序设计
short price; //55
};
int main()
{
//利用结构体类型创建一个该类型的结构体变量出来
struct book b1 = { "C语言程序设计",55 };
strcpy(b1.name, "C++");//strcpy---字符串拷贝 是一个库函数--需要头文件 -string.h
b1.price = 15; //price是变量，而name是数组，所以数组不能这样改
printf("%s\n", b1.name);
printf("%d\n", b1.price);
return 0;
}
626
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
