初识C语言

最新推荐文章于 2024-01-19 20:25:00 发布
最新推荐文章于 2024-01-19 20:25:00 发布
阅读量4.3k 收藏 21
点赞数 4
分类专栏： C语言学习 文章标签： 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a7671773/article/details/121385141
版权

c初识C语言

1.1hello world

c语言是从主函数的第一行开始执行的

所有C语言代码都得有main函数–入口

#include <stdio.h>// #include的意思是“包含”，包含stdio.h的文件
                  //stdio -standard input output标准输入输出 （std- standard）（i- input）（o- output）。

//int就是整型的意思；main前面的int表示main函数调用以后返回一个整型值。
int main()//主函数-main，是程序的入口，main函数有且有一个。
{
	printf("hello,cccc\n");//等于print function--打印函数, "\n" 表示输出后换行
	//printf是库函数，是C语言本身提供给我们使用的函数。所以要调用 #include <stdio>
	return 0;//return就是返回的意思，返回 整数int 0。
}

1.2数据类型

  • 为什么出现这么多类型？
char         //字符数据类型
short        //短整型 
int          //整型
long         //长整型
long long    //更长整型
float        //单精度浮点数
double       //双精度浮点数
  • 每种类型的大小是多少？
char         //1
short        //2 
int          //4
long         //4 or 8
long long    //8
float        //4
double       //8

1.2.1 为什么出现这么多类型？

char         //字符数据类型
short        //短整型 
int          //整型
long         //长整型
long long    //更长整型
float        //单精度浮点数
double       //双精度浮点数
 
  //%c--打印字符
  //%d--打印整型
  //%f--打印浮点数字
  //%p--以地址的形式打印
  //%x--打印16进制数字
  //%lf---打印双精度浮点型数字，打印double类型最好使用这个  %lf
  //%s----打印字符串
    
 //char-字符类型
 int main()
{
    char ch ='A';//向内存申请了一块空间，空间的名称叫 ch，用这块空间来存放 “A”
    printf("%c\n",ch);// %c--打印字符格式的数据,打印结果为：A
    return 0;
}

//int--整型
int main()
{
    int age=20;
    printf("%d\n",age);//  %d--打印整型十进制数据，打印结果为:20
    return 0;
}

//short int--短整型

//long--长整型
int mian()
{
    long num=100;
    printf("%d\n",num);打印结果也是：100
    return 0;
}

//float--单精度浮点类型
int main()
{
    float f = 2.0;
    printf("%f\n", f);//打印结果为：5.00000。float类型能包含五个小数点。
    return 0;
}

//double--双精度浮点类型
int main()
{
    double f = 3.14;
    printf("%f\n", f);//这里的打印可以用 %f，但是最好还是使用 %lf，表示使用双精度打印。
    return 0;
}

1.2.2每种类型的大小是多少？

计算机中的单位
bit-比特位 < byte-字节 < kb < mb < gb < tb < pb

一个bit（比特位）只能存放一个 二进制0或1。所以学一下二进制和十进制的转换。

1byte=8bit

1kb=1024byte

1mb=1024kb

1tb=1024mb

1pb=1024mb

//计算各个类型占用空间
int main()
{	//sizeof这个函数是计算大小的函数，如下，可以测试以下数据类型和变量所占空间的大小。
    //sizeof 的单位是 字节 byte。
    printf("%d\n", sizeof(char));// 1byte
    printf("%d\n", sizeof(int));// 4byte
    printf("%d\n", sizeof(long));// 4byte，long可以是4 or 8byte.
    printf("%d\n", sizeof(short));// 2byte
    printf("%d\n", sizeof(long long));// 8byte
    printf("%d\n", sizeof(float));// 4byte
    printf("%d\n", sizeof(double));// 8byte
   
    short int age=20 //short对应两个字节，向内存申请两个字节，也就是16个bit位。能存放的数 2^16-1=65535。
        //如果数据不是很大推荐使用小整型，bit位越少，越能节省空间。
}//打印出来的这些数字就是“byte--字节”

#include <stdio.h>
int main()
{
    //    年龄 20
    short age = 20;//向内存申请2个字节=16bit位，用来存放20
    float weight = 95.6f;//可能系统会报错，因为系统把95.6当作双精度浮点归到double类型；在95.6后面加一个“f”，说明为单精度浮点即可解决。向系统申请4个字节，存放小数。
    
   //据C语言标准 sizeof(long) >= sizeof(int),根据平台不同，long可能是4或8.
    return 0;
}

1.3 变量、常量

常量：

生活中有些值是不会变的（圆周率，身份证号，血型，性别等等）

变量：

有些值是可以变的（年龄，体重，薪资等）

1.3.1 定义变量的办法

类型 + 变量名 + 赋值

int age=150;
float weight=45.5f;
char ch='w';

1.3.2 变量的分类

  • 局部变量
  • 全局变量
  1. 全局变量–定义在“代码块（{}）”之外的变量
  2. 局部变量–定义在“代码块（{}）之内的变量”
  3. 局部变量名和全局变量名相同时，不会有冲突，但是局部变量优先。
    建议全局变量和局部变量的名字不要相同，容易产生bug。
    局部变量只能在自属局部的代码块{}中使用。
#include <stdio.h>
int num2=20;//全局变量--定义在“代码块（{}）”之外的变量
int main()
{
    int num1=10;//局部变量--定义在“代码块（{}）之内的变量”
    return 0;
}

int a = 20;
int main()
{
    int a = 10;
    printf("%d\n", a);//打印结果为：10
    return 0;
}//局部变量名和全局变量名相同时，不会有冲突，但是局部变量优先。
//建议全局变量和局部变量的名字不要相同，容易产生bug。
//局部变量只能在自属局部的代码块{}中使用。

int main()
{
    //计算两个数的和
    int num1 = 0;
    int num2 = 0;
    int sum =0;

    //输入数据--使用输入函数scanf，而vs2019或其他版本可能会报错，需要在文件开头输入以下指令，#define _CRT_SECURE_NO_WERNINGS 1   只能加在文件的第一行。

    scanf("%d%d", &num1, &num2);//取地址符号“&”；意思就是num1和num2是没有值的，需要我们输入后会根据取地址符&放到我们取得地址内。scanf是标准C语言提供；scanf_s是vs2019编译器提供，只能在vs的编译器使用，尽量使用标准C语言提供的，可以执行更强。
    //int sum = 0;//这里是错误的，C语言语法规定，变量要定义在当前代码块最前面。
    sum = num1 + num2;
    printf("sum=%d", sum);
    return 0;
}

1.3.3 变量的作用域和生命周期

作用域:

限定这个变量的可用性的代码范围就是这个名字的作用域。

  • 局部变量的作用域，是变量所在的局部范围
  • 全局变量的作用域，就是整个工程
#include <stdio.h>
int main()
{
    int go=20;//局部变量的作用域是变量所在的局部范围
    printf("go+%d",go);
    return 0;
}


int go=20;//全局变量的作用域就是整个工程
int main()
{
    printf("go+%d",go);
    return 0;
}

int main()
{
    //extern函数是声明外部文件符号的
    extern int g_val;// g_val是其他文件的全局变量
    printf("g_val=%d\n",g_val);
    return 0;
}
生命周期

变量的生命周期值的是变量的创建到变量的销毁之间的一个时间段。

  1. 局部变量的声明周期是：进入作用域 生命周期开始，出作用域 生命周期结束。
  2. 全局变量的生命周期是：整个程序的生命周期。
#include <stdio.h>
int main()
    int golang = 110l;//全局变量的生命周期就是整个程序的生命周期
{
    int go=20;//局部变量的生命中周期就是它的作用域
    printf("go+%d",go);
    return 0;
}

1.3.4 常量

常量分为以下几种

  • 字面常量
  • const修饰的常变量
  • #define定义的标识符常量
  • 枚举常量
int main()
{
    int num=4;
    3;//字面常量，就是直接的一个值。
    100;//字面常量
    3.14;//字面常量
    'w';//字面常量
    "abcd";//字面常量
    3=5；//这不是常量，3不可能等于5.
    return 0;
}
常变量
字面常量
int main()
{
    int num=4;
    printf("%d",num);
    num=8;
    printf("%n",num);
    return 0;
}
 //输出效果为4 和 8，变量不受影响。
const修饰的常变量

const修饰变量以后，虽然具有了常量属性，但本质还是变量。

int main()
{    //const常属性
     const int num=4;//const表示为变量添加常属性，num虽然拥有了常量属性，但本质上还是变量。
    printf("%d",num);
    num=8;
    printf("%n",num);
    return 0;
}//输出结果错误，因为num具有了常属性4，所以就不能改为8了。


int main()
{   
    int arr[10]={0};//arr表示数组，表示这个数组里有10个元素。所有元素都是0。arr[只能使用常量]
    return 0;
}

  
int main()
{   
    int n=10;
    int arr[n]={0};
    return 0;
}//运行错误，因为数组内只能放常量，就算n是常变量也不行，常变量的本质还是变量。

int main()
{   
    const int n=10;
    int arr[n]={0};//n是变量，但是又是常属性，所以我们说n是常变量
    return 0;
}//运行错误，因为数组内只能放常量，就算n是常变量也不行，常变量的本质还是变量。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6V38YgAh-1637146412779)(C:\Users\admin\Pictures\捕获.PNG)]

#define定义的标识符常量
#define MAx 10   //定义MAX常量值为10，注意：这个#difine 常量后面不能加分号 ；

int main()
{
    int arr[MAX]={0}//因为MAX是常量，所以arr数组可以输出
    printf("%d\n",MAX)
    return 0;
}

想要定义常量可以用#define表示符定义常量

image-20210722124638007

输出成功

枚举常量

枚举 就是 “一一列举”的意思。

性别：男，女，其他。

三原色：红，黄，蓝。

星期：1，2，3，4，5，6，7

枚举常量的关键字为：enum

enum Color
{//这种枚举类型的变量的  
    red,//需要有 , 号
    yellow,
    blue
};   //最后这个大括号后面必须有 ；
//这是enum的语法格式

使用方法

enum Sex4
{
    male,
    female,
    secret
};
int main()
{
    enum Sex hang=male; //描述 hang 是男人还是女人。
    hang=female;//枚举常量是可以改变的
    //error：male=6或其他值。枚举常量的数值是有顺序且固定的
    return 0;
}

枚举的数值

​ 枚举常量是有常量数值的

enum Sex
{
    male,//常量 0
    female,//常量 1
    secret//常量 2
};
int main()
{
    enum Sex hang=male;
    printf("%d\n",male);//0
    printf("%d\n",female);//1
    printf("%d\n",secret);//2
    return 0;
}

枚举常量会根据你定义enum，排列各个常量的值，顺序为“0，1，2，3…”

enum Sex {
	MALE=3,  //如果赋初值为3，之后的值都会跟着加1.
	FAMALE,//4
	SECRET//5
};

int main() {
	enum Sex meng = SECRET;//结果为5
	printf("%d", meng);
}

1.4 字符串+转义字符+注释

1.4.1字符串

由这种双引号（Double Quote）"" 引起来的一串字符称为字符串字面值（String Literal），或简称字符串。

注：字符串的结束标志是一个 \0 的的转义字符。在计算机字符长度的时候 \0 是结束标志，不算作字符串内容。

int main()
{
	"abcd";
    "hsd8wh";
    "hahwudhau";
    ""; //就算双引号中无任何数据，但也是字符串不过叫 空字符串,有由双引号 ”“ 引起来的就是字符串
	return 0；
}
字符串的使用
int main()
{
	char arr1[] = "abc"; //字符数组-数组是一组形同类型的元素。
    					//字符串在结尾位置隐藏了一个 \0 的字符。
    					// \0时字符串的结束标志。
	char arr2[] = { 'a','b','c' };
	printf("%s\n", arr1);// %s表示打印字符串
	printf("%s\n", arr2);
	return 0;
}

打印结果如下

image-20210722124756392

原因如下

int main()
{
	char arr1[] = "abc"; //字符串"abc"中分别包含：'a','b','c','\0'
    					// 而 '\0' 是字符串的结束标志。
	char arr2[] = { 'a','b','c' }; //因为没有结束标志'\0',所以它还在继续打印，在字符数据中加个 0 或'\0'就可解决。
	printf("%s\n", arr1);
	printf("%s\n", arr2);
	return 0;
}

image-20210722125019623

测试字符串的长度

int main()
{
    char arr1[]="abc"; 
    char arr2[]={'a','b','c'};  
    printf("%d\n",strlen(arr1));  //3, \0 是一个结束标志，不算字符。
    printf("%d\n",strlen(arr2));  //15 虽然是15，但它是一个随机值，因为在‘a’，‘b’，‘c’，三个数中不断排序，知道找出 \0 才停止，所以是随机数。
    			//strlen函数表示 str--string，len--length，也就是string lenth（字符串长度）。
 				//如果出现 “strlen未定义”，那就是需要导入头文件  #include <string.h>
    return 0;
}

注：字符串的结束标志是一个 \0 的的转义字符。在计算机字符长度的时候 \0 是结束标志，不算作字符串内容。

1.4.2 转义字符

转义字符就是转变字符的含义。

转义字符表

image-20210722125131897

案例1

这是打印 abcn

image-20210722125328651

但如果我们在n字母的前面加个\就会如下：

image-20210722125515630

这就是转变n的含义，\n表示换行。

案例2

如果我们要打印路径c:\test\32\test.c,结果如下：

image-20210722125557511

因为转义字符，所以打印的时候，自动转义为转义表上的意思

\t 是 水平制表符，也就是Tab键，有\t的地方就空了一个tab键的距离。

案列3

如果要打印字符'

int main()
{
    printf("%c\n",''')；//这会报告错误的，想要打印 ’ ，必须把中间的单引号转义。
	return 0;
}

把中将的单引号‘加个\转义符号，就可以打印了。

image-20210722125807938

打印字符串也一样

image-20210722125858951

案例4；

如果打印c:\test\32\test.c的长度

int main()
{
    printf("%d\n",strlen("c:\test\32\test.c"));//输出结果为13
	return 0;
}

image-20210722130107663

输出结果为13，因为转义的部分算是一个字符，\t, \32, \t 算是三个字符，所以strlen为13.

\32 也就是\ddd ddd表示1~3个八进制的数字，如：\130。 需要把八进制130换算为十进制数字，然后作为ASCII码值，对应的字符。

32是两个八进制数字
32-->十进制 26-->作为ASCII码值对应的字符

image-20210722130337309

image-20210722130407986

\xdd的使用，dd表示2个十六进制数字。 如： \x30

\x61 将十六进制61-->十进制 97-->ASCII码值 a

image-20210722130551204

ASCII码对照表

ASCII码表

1.5 注释

  • 代码中有不需要的代码可以直接删除，也可以注释掉
  • 代码中有些代码比较难懂，可以加一下注释文字

注释有两种风格：
C语言风格的注释 /*xxxxxxxx*/,缺陷：不能嵌套注释

c++风格的注释 //xxxxxxxxx。优点：可以注释一行也可以多行。

当 /* 遇到 第一个*/ 的时候就会停止注释，所以它不能嵌套式注释，最好选择c++风格注释。

1.6 选择语句

如果你好好学习，校招拿一个好offer，走上人生巅峰。

如果你不好好学习，毕业等于失业，回家卖红薯。

这就是选择。

image-20210722131142748

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

int main()
{
	int input = 0;
	printf("学吗？");
	scanf("%d", &input);
	if (input == 1)
	{
		printf("好样的");
	}
	else
	{
		printf("加油吧");
	}
	return 0;
}

image-20210722131316086

image-20210722131344575

1.7 循环语句

image-20210722131409067

C语言的三种循环

  • while语句
  • for语句（后期）
  • do…while语句（后期）
int main()
{
	int code = 0;
	printf("敲代码吧！");
	while (code < 20000 )
	{
		printf("敲一行代码！！累计代码=%d\n",code);
		code++;
	}
	if (code >= 20000)
	{
		printf("你已经是个大师了！");
	}
	else
	{
		printf("你还是个菜鸟，加油吧！！");
	}
	return 0;
}

intimage-20210722131457961

1.8 函数

函数分为：

  • 自定义函数。就是自己设定的函数

  • 库函数。C语言自带的函数，如printf，scanf等。

Add(int x, int y)
{
	int z = x + y;
	return z;
} //这就是自定义函数

int main()
{
	int c = 0;
	int b = 0;
	int sum = 0;
    printf("输入想要相加的连个数...\n")
	scanf("%d%d", &c, &b);
	sum = Add(c, b);
	printf("sum=%d\n", sum);
	return 0;
}

1.9 数组

要存储1—10的数字，怎么存？

C语言给数组的定义：一组相同类型元素的集合

int arr[10] 定义一个存放10个整数数字的数组，也可以定义其他数据类型的数组char ch[] , float arr2[]等。

C语言数组中每个元素都有下标，从0依次排列。

image-20210722132130249

如果要打印第五个元素，要用到下标 4 。

int main()
{
	int arr[10]= { 1,2,3,4,5,6,7,8,9,10 };
    char ch[5]={'a','b','c'};//不完全初始化，剩余的默认为0
	printf("%d\n", arr[4]);//下标的方式访问元素  arr[下标]
	return 0;
}

image-20210722132211164

如果要打印所有元素，可以用while语句

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int a = 0;
	while (a < 10)
	{
		printf("%d ", arr[a]);//因为 a为零，所以打印下标0开始，而下标0就是数组里面的1。
		a++;
	}
	return 0;
}

image-20210722132912601

2.0 操作符

简单介绍为主，后面课件重点讲。

  • 算术操作符+ - * / %
  • 移位操作符>> < <
  • 位操作符 & ^ |
  • 赋值操作符 = += -= *= /= &= ^= |= >>= <<=
  • 单目操作符image-20210722132944563
  • 关系操作符image-20210722133003227
  • 逻辑操作符image-20210722133026959
  • 条件操作符 exp1 ? exp2 : exp3
  • 逗号表达式 exp1,exp2,exp3...expN
  • 下标引用、函数调用和结构成员[] () . ->
2.0.1 移位操作符

位操作符表示二进制向左或向右 移位 >> < <

int main()
{
	int a = 1;
	int b = a << 2;//移动的位数是由移位操作符后面的数字决定的，这里是2，所以移两位
	printf("%d\n", a);
	printf("%d\n", b);
	return 0;
}
//解析：因为是int数据类型所以有32bit位，十进制的1==二进制的0000000000000000000000000000001
//而移位操作符就是控制二进制向左或向右 移位
//上面代码移位的位数是2，所以向左移两位，得到二进制00000000000000000000000000000100，翻译为十进制就是4.
2.0.2 位操作符
  • & 按位与 按位与& 的的意思是，只要两个相对应的二进制数里，有一个为假，结果就为0，两个都为真就是1。
  • ^ 按位异或 按位异或^ 同性相斥为假，异性相吸为真
  • | 按位或 按位或| 的意思是：只要两个相对应二进制数里，只要有一个为真，那就是真。

在二进制中 真为 1， 假为 0

按位与 &

image-20210722133259616

解析：a=5 ，b=3
转化为二进制
101
011
有一个为假，结果就为0，两个都为真 就是1，所以得出以下：
001
转为十进制就是1

按位或 |

image-20210722133328187

解析：按位或   只要两个相对二进制数里，只要有一个为真，那就是真
解析：a=5 ，b=3
转化为二进制
101
011
只要两个相对二进制数里，只要有一个为真，那就是真
111
转化为十进制就是 7

按位异或 ^

image-20210722133426269

解析：解析：a=5 ，b=3
转化为二进制
101
011
异性相吸为真，同性相斥为假
110
转换为十进制的结果为  6
2.0.3 赋值操作符

= += -= *= /= &= ^= |= >>= <<=

int main()
{
    int a =10;
    a=a+10:
    a+=10;//这是赋值操作符 的方式，比较简洁
    
    a=a-20;
    a-=20;//赋值操作符
    
    a=a&2;
    a&=2;//赋值操作符
    return 0;
}
2.0.4 单目操作符

除了单目操作符 还有双目操作符，三目操作符

int main()
{
    int a =10;
    int b=20;
    a+b;//  + 有两个操作数，就是左边的a和右边的b，所以+是双目操作符
    return 0;
}
逻辑反操作 !

C语言中我们表示真假 0表示 假， 非0表示 真

int main()
{
    int a =10;
    printf("%d\n",a);
    printf("%d\n",!a); // C语言中我们表示真假 0表示 假， 非0表示 真
                       // !逻辑反操作就是把假变成真，真变成假。
    return 0;
}

image-20210722133633907

image-20210722133727095

- + 负值和正值
int main()
{
    int a = -3;
    int b = -a;
    int c = +2;// +号一般省略
    printf("%d\n", b);
    return 0;
}
sizeof 操作数类型长度（以字节byte为单位）
int main(){
    int a =10;
    printf("%d\n",sizeof(int));
    printf("%d",sizeof(a));//当sizeof求变量时，括号（）是可以省略的。求数据类型不行
    return 0;
} //结果都是4

image-20210905094039014

计算数组的元素个数

int main()
{
    int arr[10]={0};//十个整型元素的数组
    //10*sizeof（int）=40 byte
    printf("%d\n",sizeof(arr));//40 byte
    //计算个数
    //个数=总空间/一个单位的空间
    int gs=sizeof(arr)/sizeof(0);
    print("gs=%d",gs);//10个
    return 0;
}

image-20210722134004428

~ 对一个数的二进制位 按位取反

把二进制位中的数字，1变成0, 0变成1。

int main(){
    int a = 0;
    printf("%d",~a);// -1
    return 0;
}

二进制：

00000000000000000000000000000000

11111111111111111111111111111111

整数在内存中储存的是补码

一个整数的二进制表示有三种

原码

反码

补码

这是针对负数的

-1：
10000000000000000000000000000001 //（原码） 最前面的1表示 符号位
11111111111111111111111111111110 //（反码） 符号位不变，其他取反，0变1,1变0.
11111111111111111111111111111111 //(补码)，加了1后就成了补码

正整数：原码，反码，补码 相同

img

++ 前置、后置
int main(){
    int a = 10;
    int b = ++a;//前置++, 先++，后使用。
    printf("%d\n",b);
    printf("%d\n",a)
    return 0;
}

image-20210905102157798

int main(){
    int a = 10;
    int b = a++;//后置++, 先使用，后++。
    printf("%d\n",b);
    printf("%d\n",a)；
    return 0;
}

image-20210905102335092

-- 前置、后置

-- 的前后置效果和 ++一样

（类型） 强制类型装换
int main(){
    int a = 3.14;
    printf("%d\n",a);//这样使用会报错，因为3.14不是int类型
    return 0;
}

因改为：

int main(){
    int a = （int）3.14;
    printf("%d\n",a);
    return 0;
}

image-20210905103147726

2.0.5 关系操作符

image-20210722133003227

2.0.6 逻辑操作符
&&			逻辑与		两个为真，才是真
||			逻辑或		一个为真，便是真

int main(){
    int a = 3;
    int b = 5;
    int c = a && b;
    printf("%d\n",c);
    return 0;
}

image-20210905103734876

int main(){
    int a = 3;
    int b = 0;
    int c = a && b;
    printf("%d\n",c);
    return 0;
}

image-20210905103808375

int main(){
    int a = 3;
    int b = 0;
    int c = a || b;
    printf("%d\n",c);
    return 0;
}

image-20210905104006330

2.0.7 条件操作符（三目操作符）

exp1 ? exp2 : exp3

exp1成立，exp2计算，整个表达式的结构是：exp2的结果

exp1不成立，exp3计算，整个表达式的结构是：exp3的结果

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

​ 上面的结果等于

int main(){
    int a =0;
    int b = ;
    int max = 0;
    a > b ? a : b; //exp1 ? exp2 : exp3
    return 0;
}
逗号表达式

exp1,exp2,exp3...expN

逗号表达式是：逗号隔开的一串表达式

int main(){
    int a = 0;
    int b = 3;
    int c = 5;
    		//a=5   c=1   b=3 
    int d = (a=b+2,c=a-4,b=c+2);//这就是逗号表达式
    						//整个表达式的结果是最后一个表示结果
    printf("%d\n",d);
    return 0;
}

image-20210905131421716

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

[] () . ->

下标引用操作符 []

image-20210905132259504

函数调用操作符 ()

int main() {
			//调用函数时，函数后面的（）就是函数调用操作符
    printf("hehe\n");
    return 0;
}

&

.

->

这个几个操作符之后再讲。

2.1 常用关键字

C语言提供的关键字

1.C语言提供的，不能自己创建关键字

2.变量名不能做关键字

image-20210905163828957

auto

auto 是自动的–每个局部变量都是auto修饰的

int main(){
    {
        int a = 10;//自动创建，自动销毁的——自动变量，
        //省略了auto
        //auto在新的C语言语法中也有其他用法--暂时不考虑
    }
    return 0;
}
entern

entern是用来申明外部符号的

register

register 寄存器关键字

int main(){
    register int a = 100;//建议将a的值存放在寄存器中
    return 0;
}

补充知识

计算机数据可以储存到哪里了？

寄存器 更小

高速缓存 几十MB

内存 8G——16G

硬盘 500G 买的

网盘 2T—免费的

signed

有符号的

unsigned

无符号的

union

联合体（共用体）

void

void是“无-- --空”的意思

不是关键字的

defiene -是不是关键字？ no  是 预处理指令
include -是不是关键字？ no  是 预处理指令
typedef

typedef 类型重定义，这里应该理解为类型重命名

typedef unsigned int u_int;//将unsigned int重定义为 u_int;

int main(){
    unsigned int num = 100;//用typedef将unsigned int重定义为 u_int.
    u_int num = 100;//重定义为u_int投入使用
    return 0;
}
static

在C语言中：

static是用来修饰变量和函数的

1.修饰局部变量——静态局部变量

2.修饰全局变量——静态全局变量

3.修饰函数——静态函数

1.static修饰局部变量
void test() {
    int a = 1;//不加static
    a++;
    printf("%d\n", a);
}
int main() {
    int i = 0;
    while (i < 10) {
        test();
        i++;
    }
    return 0;
}

image-20210905190434069

void test() {
    static int a = 1;//加static
    a++;
    printf("%d\n", a);
}
int main() {
    int i = 0;
    while (i < 10) {
        test();
        i++;
    }
    return 0;
}

image-20210905190504197

static修饰了局部变量，改变了局部变量的生命周期（本质上是改变里变量的储存类型）

静态变量的生命周期 和 全局变量的生命周期一样

2.static修饰全局变量

image-20210906211543805

image-20210906211602769

static修饰的全局变量，使得这个全局变量只能在自己所在的源文件（.c）内部使用，其他源文件不能使用！！

全局变量，在其他源文件内部可以使用，是因为全局变量具有外部链接属性，但是被static修饰之后，就会变成了内部链接属性，其他源文件就不能链接到这个静态的全局变量了！！

3.static修饰函数

image-20210906212603516

image-20210906212741023

static修饰的函数，使得函数只能在自己所在的源文件内部使用，不能在其他源文件内部使用

本质上：static是将函数的外部链接属性变成内部链接属性！！（和static修饰全局变量一样）

2.2#define 定义常量和宏

#define是一个预处理指令

1.#define 定义常量
#define MAX = 1000;
int main(){
    printf("%d", MAX);
    return 0;
}//输出就是1000
2、#define 定义宏
#define ADD(x,y) ((x)+(y))//不带外边这个大括号的话，打印结果是4*2+3=11
int main(){
    printf("%d\n",4*ADD(2,3));
    return 0;
}// 20

2.3 指针

内存

内存是电脑中的特别重要的储存器，计算机中的所有程序的运行都是在内存中进行的

为了有效的使用内存，就把内存划分成了一个个小的内存单元，每个内存单元的大小的 1byte。

为了能有有效的访问到内存的每个单元，就给内存单元进行了编号，这些编号称为该内存单元的地址

int main() {
	int a = 10;//a在内存中要分配空间 —— 4byte
	printf("%p\n", &a);//%p专门用来打印地址的
    int* pa = &a;//pa是用来存放地址的，在C语言中pa叫指针变量
    			// * 说明pa是指针变量
    			//int 说明pa执行的对象是int类型的
	return 0;
}

int main(){
    char w = 'w';
    char*pc = &w;
    return 0;
}

解引用操作 *

int main(){
    int a =10;
    int* pa = &a;
    *pa = 20;//这里的 * 是解引用操作，*pa就是通过pa里边的地址，找到a
    printf("%d\n",a);//a 为20
    return 0;
}

image-20211007202020948

指针c的大小（以字节byte为单位）

int main(){
    printf("%d\n",sizeof(char*));//4
    printf("%d\n",sizeof(int*));//4
    printf("%d\n",sizeof(short*));//4
    printf("%d\n",sizeof(long*));//4
    printf("%d\n",sizeof(long long*));//4
    printf("%d\n",sizeof(float*));//4
    printf("%d\n",sizeof(double*));//4
    
    return 0;
}

image-20210908184612795

指针的大小是相同的！！用为指针是用来存放地址的

指针需要多大空间，取决于地址的存储需要多大空间

32位机器 32bit —— 4byte

64位机器 64bit —— 8byte

image-20210908184502380

结论：指针大小在32位平台是4个byte，64位平台是8个byte。

2.4 结构体

结构体非常重要，结构体使得C语言有能力描述复杂类型。

比如描述学生，学生包括名字+年龄+性别+学号 这几项信息。就可以用结构体来表示

struct Stu
{
    char name[20];
    int age;
    char sex[5];
    char id[15]
};

//创建一个 学生的类型
struct Stu
{
	char name[20];
	int age;
	double score;
};

//创建一本书的类型
struct Book
{
	char name[20];
	float price;
	char id[30];
};

int main() {
	struct Stu s = { "李四",20,99.9 };//结构体的创建和初始化
	printf( "1: %s  %d  %lf\n", s.name, s.age, s.score);//第一种方法

	struct Stu* ps = &s;
	printf("2: %s  %d  %lf\n",(*ps).name,(*ps).age,(*ps).score); //第二种方法

	printf("3: %s  %d  %lf\n", ps->name, ps->age, ps->score);//第三种方法
    							// “->”的使用    结构体指针-> 成员量名
	return 0;
}

return 0;

}




```c
int main(){
    char w = 'w';
    char*pc = &w;
    return 0;
}

解引用操作 *

int main(){
    int a =10;
    int* pa = &a;
    *pa = 20;//这里的 * 是解引用操作，*pa就是通过pa里边的地址，找到a
    printf("%d\n",a);//a 为20
    return 0;
}

[外链图片转存中…(img-odoVXNbf-1637146412805)]

指针c的大小（以字节byte为单位）

int main(){
    printf("%d\n",sizeof(char*));//4
    printf("%d\n",sizeof(int*));//4
    printf("%d\n",sizeof(short*));//4
    printf("%d\n",sizeof(long*));//4
    printf("%d\n",sizeof(long long*));//4
    printf("%d\n",sizeof(float*));//4
    printf("%d\n",sizeof(double*));//4
    
    return 0;
}

[外链图片转存中…(img-rnAO8mov-1637146412806)]

指针的大小是相同的！！用为指针是用来存放地址的

指针需要多大空间，取决于地址的存储需要多大空间

32位机器 32bit —— 4byte

64位机器 64bit —— 8byte

[外链图片转存中…(img-4oP82O5t-1637146412806)]

结论：指针大小在32位平台是4个byte，64位平台是8个byte。

2.4 结构体

结构体非常重要，结构体使得C语言有能力描述复杂类型。

比如描述学生，学生包括名字+年龄+性别+学号 这几项信息。就可以用结构体来表示

struct Stu
{
    char name[20];
    int age;
    char sex[5];
    char id[15]
};

//创建一个 学生的类型
struct Stu
{
	char name[20];
	int age;
	double score;
};

//创建一本书的类型
struct Book
{
	char name[20];
	float price;
	char id[30];
};

int main() {
	struct Stu s = { "李四",20,99.9 };//结构体的创建和初始化
	printf( "1: %s  %d  %lf\n", s.name, s.age, s.score);//第一种方法

	struct Stu* ps = &s;
	printf("2: %s  %d  %lf\n",(*ps).name,(*ps).age,(*ps).score); //第二种方法

	printf("3: %s  %d  %lf\n", ps->name, ps->age, ps->score);//第三种方法
    							// “->”的使用    结构体指针-> 成员量名
	return 0;
}
衡一兄
关注
  • 4
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C入门01
weixin_46362333的博客
05-16 1314
** 1.main（） ** int main（）有返回值，要写return 0； void main（）无返回值，不写return 0； A.解释： 以int main()为例 1、int main()是C语言main函数的一种声明方式； 2、int表示函数的返回值类型，表示该主函数的返回值是一个int类型的值； 3、main表示主函数，是C语言约定的程序执行入口，其标准的定义格式为int main(int argc, char *argv[])； 在int main()中，（）中没有数值表示入参为空，等
C语言main函数标准格式：int main(int argc, char * argv[]);
Janskid的博客
07-12 1638
int main(int argc,char *argc[]) { int i; for(i = 0;i < argc;i++) { printf("%s\n",argv[i]); } return 0; } 标准的main函数格式为：int main(int argc, char * argv[]);
C语言入门 函数调用 main函数 int main 是什么
橘子冰的博客
07-25 1万+
目录引入函数main 函数其他 引入 学任何编程语言的时候，大家应该写的第一个程序都是输出“Hello, world!”。 我学python，Java的时候都是，现在学C语言也不例外。 于是就有了以下代码： int main(){ cout << "Hello, world!" << endl; return 0; } 运行上述代码，就会输出Hello, world!了。 我知道 cout 是输出的意思，endl 是换行的意思，但 int main 是啥呢？ 为啥return
int main() 作用详解
m0_74195174的博客
01-19 6981
在C语言中，int main() 函数是程序的入口，承担着启动整个程序执行的关键角色。这个小小的函数却有着巨大的影响，决定着程序的执行流程和最终的返回状态。本文将深入探讨 int main() 函数的作用，解析其基本形式和参数，以及它在程序中的核心地位。
C语言基础知识学习总结
alone_l的博客
08-17 1840
C语言基础知识学习内容总结
初识C语言.pdf
03-11
初识C语言.pdf
初识c语言思维导图 pdf版
08-08
C语言是一种基础且强大的...这些是初识C语言的基础知识，深入学习还需要理解更复杂的概念，如指针操作、内存分配、动态内存管理、文件I/O、函数指针、结构体指针等。掌握这些概念是成为一名熟练的C程序员的必要步骤。
初识C语言.xmind
12-24
初始C语言-主要介绍相关知识 大致可了解其内容 比较齐全
第1节-初识C语言.pdf
11-23
第1节-初识C语言.pdf
从初识C语言到C语言进阶.zip
最新发布
04-19
C语言诞生于美国的贝尔实验室，由丹尼斯·里奇（Dennis MacAlistair Ritchie）以肯尼斯·蓝·汤普森（Kenneth Lane Thompson）设计的B语言为基础发展而来，在它的主体设计完成后，汤普森和里奇用它完全重写了UNIX，...
《C语言学习笔记》初识C语言1
08-08
《C语言学习笔记》初识C语言1 C语言是一种广泛应用的高级编程语言，它以其简洁、高效的特点深受程序员喜爱。本章节将介绍C语言的基本概念以及如何开始编写C语言程序。 1. 基本概念 - **程序**：程序是由一系列...
《C语言学习辅导》初识C语言21
08-08
《C语言学习辅导》初识C语言21 C语言是一种强大的编程语言，广泛应用于系统软件、应用软件、嵌入式系统以及游戏开发等领域。本章节将引导初学者逐步走进C语言的世界，通过使用Visual Studio 2012这一流行的集成开发...
《C语言学习辅导》初识C语言11
08-08
【C语言学习辅导】初识C语言11 在学习C语言的过程中，了解其基本概念和编程流程至关重要。本章节主要介绍了以下几个知识点： 1. **程序的含义**：程序是用某种编程语言编写的指令集合，它告诉计算机执行特定任务。...
main()、int main()、int main(void)、void main()、void main(void)
stmPeter的博客
03-01 2304
分辨几种main函数的用法
void main和int main的区别
热门推荐
m0_62520055的博客
04-13 3万+
其实main也是一个函数； #include<stdio.h> void main(){ } 如上代码所示，void main() 这样定义只是说明main函数没有返回值。 #include<stdio.h> int main(void){ return 0; } 如上代码所示，int main(void)和int main()是一样的（括号里没有东西就相当于void） 说明main函数有一个int类型的返回值。 int main()是C语言的规范，要求main函...
int main(int argc,char* argv[])详解
主要记录嵌入式学习与开发过程。
06-14 2万+
int main(int argc,char* argv[])也可以写成int main(int argc,char** argv) argc是命令行的参数个数； argv[]是字符指针数组，它的每个元素都是字符指针，指向命令行中每个参数的第一个字符。比如在linu系统下使用vim编写以下代码，并保存为sample.c。 然后用“gcc sample.c -o sample.out”编译得到sample.out后，输入“./sample.out aa bb cc”执行。 从结果argc=4可知，可执行程序也

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值