C语言初识

   嘿嘿,家人们,今天咱们来初识C语言,今天的内容都是点到为止哦,更多的详细内容后面会说滴,好啦,废话不多讲,开干！​​​​​​​​​​​​​​

---

1:什么是C语言

  C语言是一门通用的计算机编程语言,就好比我们人与人之间的交流可以有中文,英文等等语言来作为桥梁,那么同理,C语言也可以作为我们与电脑之间进行沟通的桥梁,C语言被广泛用于底层开发。

       C语言是一门面向过程的计算机编程语言,与C++,java,python等面向对象的语言有所不同,很多其他编程语言都是在C的基础上进行衍生的,像python的解释器就是用C语言写滴。

底层开发

 2:第一个C语言程序

写程序呢就要用到编译器啦,博主在这里用到的是Vistual Studio 2022。VS2022是一个具有集成开发环境的工具,具有编辑、编译、链接、运行、调试等等功能。

(1)点击新建项目。

(2)点击空项目,然后点击下一步。

(3)然后命名项目名称,以及选择项目的存储路径;这里博主建议命名项目名称最好不要使用中文哦,使用英文,数字以及下划线,这样子方便编译器识别,命名好了以后,我们点击创建。

 (4):创建以后我们就来到了这样一个界面,我们右击那个源文件,点击添加,然后点击新建项,然后选择第一个C++文件,接着对文件名称进行命名,并将后缀改为.c,最后点击添加就可以啦,然后我们就可以创建的源文件里头编写代码啦

 

 (5):博主在这里编写的是让电脑输出hello world这段英文。

#include 
int main()
{
	printf("hello world");
	return 0;
}

(6):编写好了以后,我们运行代码,结果正如同我们预料滴一样,电脑在屏幕上输出了hello world。

 可能小伙伴们对这段代码还有一点点小迷糊,博主在这里简单解释下。

1:#include为预处理指令,用于包含外部的文件。#include 指令告诉编译器在编译过程中将指定的头文件内容插入到当前的源文件中,这样可以在源文件中使用被包含头文件中定义的函数、变量和类等资源。

2:这里写的main是一个固定的名字,它是主函数,是程序的入口,我们所写的C语言代码都是从main函数的第一行开始执行滴,main函数是必须要写的,但是在一个项目中有且仅只能有一个

main函数,

3: int是一种数据类型,代表整型.

4:printf为库函数 -C语言的标准库中提供的一个现成的函数---可以直接使用

   功能是在屏幕上打印信息;

    库函数的使用是需要包含头文件的,而printf函数需要包含头文件

5:return:用于返回函数的结果。这里返回0代表程序正常结束。

3:数据类型

在生活中,咱们有各种各样的事物,我们会用各种各样的方式去描述这些事物,譬如描述一个商品,我们会用它的价格,名字,生产日期等等,而在C语言要能描述这些信息,就得有数据类型,C语言中常见的数据类型有如下这些。

char       //字符形
short      //短整型
int        //整型
long       //长整型
long long  //长长整型
float      //单精度浮点型
double     //双精度浮点型   

数据类型的大小以及功能

每一种数据类型都有自己的大小,在这里我们使用单目操作符sizeof来计算每种数据类型的大小。

#define  _CRT_SECURE_NO_WARNINGS
#include 
int main()
{
	printf("字符型所占的字节大小为:%d\n",sizeof(char));
	printf("短整型所占的字节大小为:%d\n", sizeof(short));
	printf("整型所占的字节大小为:%d\n", sizeof(int));
	printf("长整型所占的字节大小为:%d\n", sizeof(long));
	printf("长长整型所占的字节大小为:%d\n", sizeof(long long));
	printf("单精度浮点型所占的字节大小为:%d\n", sizeof(float));
	printf("双精度浮点型所占的字节大小为:%d\n", sizeof(double));
	return 0;
}

 补充:(1):sizeof为单目操作符,用于计算类型创建的变量在内存中所占的大小,单位为字节.

          (2):计算机中常见的单位

bit - 比特位

byte - 字节           1byte = 8bit      

KB                        1KB = 1024byte

MB                       1MB = 1024KB        

GB                        1GB = 1024MB

TB                         1TB = 1024GB

PB                         1P8 = 1024TB        

        (3):类型功能:用于创建变量,丰富各种值.

4:变量与常量

4.1:定义

变量:可发生改变的值;像我们生活中的名字,价格,日期等等。

常量:不可发生改变的值;像我们生活中的身份证,性别,血型等等。

4.2:创建变量的方法

//数据类型 变量名 = 变量值;
int age = 150;
float weight = 45.5f;
char ch = 'w';

4.3:变量的命名规则

(1):只能由字母(包括大写和小写)、数字和下划线(_)组成。

(2):不能以数字开头。

(3):长度不能超过63个字符。

(4):变量名中区分大小写的。

(5):变量名不能使用关键字。

4.4:变量的分类

• 局部变量(在{}内部定义的变量)
• 全局变量(在{}外边定义的变量)

#include 

//全局变量(在{}外边定义的变量}
int a = 25;
//当局部变量和全局变量在一个地方使用的时候,局部变量优先
int main()
{
	//局部变量(在{}内部定义的变量为局部变量)
	int a = 30;
	{
		int b = 20;
		printf("b = %d\n", b);
	}
	printf("a = %d\n", a);

	return 0;
}

PS:当局部变量和全局变量在一个地方使用的时候,局部变量优先。

 4.5:变量的作用域与生命周期

作用域

概念:程序设计概念,通常来说,一段程序代码中所用到的名字并不总是有效的;而限定这个名字的可用性的代码范围就是这个名字的作用域。(通俗来讲,变量在哪里使用,那么这个地方就叫该变量的作用域)

(1)局部变量的作用域是变量所在的局部范围。

(2)全局变量的作用域是整个工程。

 

 PS:在自身源文件里面使用其他源文件里面定义的全局变量时,需要使用extern关键字进行声明。

生命周期

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

(1):局部变量的生命周期:从进入作用域则生命周期开始,到离开作用域则生命周期结束。

(2):全局变量的生命周期:整个程序的生命周期。

4.6:常量

常量的分类

字面常量

#include 
int main()
{
    3;
    "852";
    's';
    return 0;
}

const修饰的常变量

#include 
int main()
{
    //const修饰的常变量;但本质上还是变量,此时a的值不可改变
    const int a = 5;
    return 0;
}

 #define定义的宏常量

#include 
#define M 520
int main()
{
    int a = M;
    printf("%d\n",a);
    return 0;
}

枚举常量

#define  _CRT_SECURE_NO_WARNINGS
#include 
//在{}内的均为枚举常量
enum Fmaily
{
	father,
	monther,
	son,
	daughter,
};
int main()
{
	//通过枚举所创建的变量可以发生更改
	enum  Family boy = son;
	printf("%d\n", father); //0
	printf("%d\n", monther);//1
	printf("%d\n", son);//2
	printf("%d\n", daughter);//3
	printf("%d\n", boy);//2
	return 0;
}

 

 5:字符串+转义字符+注释

5.1:字符串

定义:由双引号引起来的一串字符称为字符串字面值,或者简称字符串。

PS:字符串的结束标志是一个\0的转义字符。在计算字符串长度的时候\0是结束标志,不算作字符串的内容。字符串可以用数组进行存储。

#define  _CRT_SECURE_NO_WARNINGS
#include 
#include 
int main()
{
	//字符串结束标志为\0的转义字符
	char arr1[] = "abc";
	char arr2[] = { 'a','b','c' };
	char arr3[] = { 'a','b','c','\0' };
	printf("%s\n", arr1);
	printf("%s\n", arr2);
	printf("%s\n", arr3);

	//strlen为一个库函数--用于求字符串长度,统计的是\0之前的字符个数
	int a = strlen(arr1);
	int b = strlen(arr2);
	int c = strlen(arr3);
	printf("%d\n", a);//3
	printf("%d\n", b);//随机值
	printf("%d\n", c);//3
	return 0;
}

 %s为格式控制符,用于表示字符串。

5.2:转义字符

概念:转变原本的意义/意思。

转义字符	含义
\a	触发蜂鸣
\b	退格----相当于键盘中的backspace键
\f	换页,将当前位置移到下页开头
\n	换行
\r	回车,将当前位置移动到本行开头
\t	水平制表符(相当于一个tab键)
\v	垂直制表
\\
\’
\"
\?
\0
\ddd	d d d 表示1~3个八进制转义字符,d范围为0-7,例如:\130表示X
\xhh	h h 表示2个16进制转义字符,h范围0-9,a-f,A-F,如:\x30

#define  _CRT_SECURE_NO_WARNINGS
#include 
#include 
int main()
{
	//  使用\对其进行转义
	printf("c:\\today\\is\\tuesday.c\n");
	printf("\'\n");
	printf("\"\n");
	//退格符;
	printf("a\bcdefg");
	//触发蜂鸣
	//printf("\a");

	//字符的八进制表示形式
	printf("%c\n",'\130');
	printf("%c\n", '\152');

	//字符的16进制表示形式
	printf("%c\n", '\x70');


	//转义字符算一个字符
	printf("%d\n", strlen("c:\test\120\test.c"));//13
	printf("%d\n", strlen("c:\test\180\test.c"));//15
	return 0;
}

 补充说明:%c是格式控制符,用于输出字符(字符在内存是以ASCII码的方式进行存储的,因此字符型本质也属于整型数据)

5.3注释

注释有两种风格: 

• C语言注释的风格:/* xxxxxx */(缺陷:不能嵌套注释)
• C++风格的注释: // xxxxxxxx (可以注释一行,也可以注释多行)

6:选择语句

在生活中,会有各种各样的选择,例如:如果好好学习,高考时考个好成绩,就能拿到名校录取通知书

                                                         如果你不学习,就只能从事体力劳动来谋生。

这就是选择！

C语言是一种结构化的程序设计语言----分三种结构---(1)顺序结构。(2)选择结构。(3)循环结构。这里咱们讲选择语句,那当然是选择结构啦！

分类

• if语句
• switch语句

博主在这里先简单的讲一下if语句,后面会针对这两种语句进行详解滴。

if语句

语法形式

#include 
int main()
{
    if(表达式)
    {
        语句1;
      	语句2;
        ....
    }

#define  _CRT_SECURE_NO_WARNINGS
#include 
int main()
{
	int input = 0;
	printf("是否要好好学习:0/1:");
	scanf("%d", &input);
	if (1 == input)
	{
		printf("拿名校录取通知书");
	}
	else
	{
		printf("去从事体力劳动");
	}
}

 我们在这里进行对应的输入,如果我们选择1,代表要好好学习,那么就能拿到名校录取通知书,选择0,代表不想好好学学,那么代表要去从事体力劳动。

7:循环语句

在生活中,我们会日复一日地去做同一件事,譬如每天要睡觉,吃饭,老师每天要日复一日地讲课。那么在C语言中如何实现循环呢？首先先讲一下C语言中循环语句的分类

分类

• while语句
• for语句(后期详解)
• do....while语句(后期详解)

博主在这里先简单地讲解下while循环,后面会对所有的循环语句进行详解

while循环

语法形式

#includer 
int main()
{
while(表达式)
    循环语句:
}

#define  _CRT_SECURE_NO_WARNINGS
#include 
int main()
{
	int	topic = 0;
	while (topic < 30000)
	{
		printf("坚持刷题:%d\n", topic);
		topic++;
	}
	if (30000 == topic)
	{
		printf("拿名校录取通知书");
	}
}

 如果表达式为真,则进入循环语句,为假则不进入。

PS:在C语言中,0为假,非0为真

8:函数

数学中有函数,例如 y = 2x + 1;描述的是y与x之间的关系,在C语言中也有函数,用于封装代码,方便日后调用。例如,我们在这里用函数实现两数相乘并返回结果。

#define  _CRT_SECURE_NO_WARNINGS
#include 

//函数定义
int Product(int x,int y)
{
	int z = x * y;
	return z;
}

int main10()
{
	int num1 = 0;
	int num2 = 0;
	int value = 0;
	printf("请输入两个整数:");
	scanf("%d %d", &num1, &num2);
    //函数调用
	value = Product(num1, num2);
	printf("乘积结果为:%d",value);
	return 0;
}

 函数的特点:简化代码,类似于将代码封装在一个小盒子里头,方便日后复用。

9:数组

概念:一组相同类型元素的集合。

9.1:数组的创建

#include 
int main()
{
    //数组的数据类型 + 数组名 +要存储的元素数量 + 元素值
    //完全初始化(元素个数全部使用)
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    //不完全初始化,剩下的默认为0;
    int arr[10] = {1,2,3,4,5,6,7,8};
    return 0;
}

 9.2:数组的下标

C语言规定:数组的每个元素都有一个下标,且下标从0开始的

数组可以通过下标来进行访问的。

#define  _CRT_SECURE_NO_WARNINGS
#include 
int main()
{
	//下标范围为0-9
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int i = 0;
	while (i < 10)
	{
		//访问下标为i的元素
		printf("%d ", arr[i]);
		i++;
	}
	return 0;
}

10:操作符

操作符这块,博主在这里简单介绍下,后面会有详解滴。

10.1:算术操作符

+

-

*

/

%(两边的操作数必须均为整数)

#define  _CRT_SECURE_NO_WARNINGS
#include 
int main()
{
	//除法,得到的是商
	printf("%d\n", 17 / 4);
	//取余,得到的是余数;两边必须都为整数
	printf("%d\n", 17 % 4);
	//直接写出的浮点数,会被编译器识别为double类型
	printf("%lf\n", 17.0 / 4);
	return 0;
}

10.2:移位操作与位操作符(使用的是二进制位进行计算)

>>

<<

&

^

|

10.3:赋值操作符

=

+=

-=

*=

/=

&=

^=

|=

>>=

<<=

#define  _CRT_SECURE_NO_WARNINGS
#include 
int main()
{
	//进行初始化
	int a = 0;
	//赋值
	a = 250;
	//等价于a = a + 5(复合操作符)
	a += 5;
	printf("%d\n", a);
	return 0;
}

10.4:单目操作符

概念:只有一个操作数的操作符。例如: 3 + 2;这里的+是有两个操作数的,因此在这里,+号为二元操作符。

博主在这里先讲解逻辑反与前置，后置++(--)以及强制类型转换这三种操作符,剩下的后期会有详解滴。

!	逻辑反操作符
-	负值
+	正值
&	取地址
sizeof	操作数的类型长度(以字节为单位)
~	对一个数的二进制位进行取反
--	前置--与后置--
++	前置++与后置++
*	解引用操作符
(类型)	强制类型转换

10.4.1:逻辑反操作符

#define  _CRT_SECURE_NO_WARNINGS
#include 
//逻辑反操作符
int main()
{
	//C语言中,0为真,非0为假
	int a = 25;
	//对a进行逻辑取反
	int b = !a;
	//对a进行两次逻辑取反
	int c = !!a;
	printf("%d\n", b);
	if (!b)
	{
		printf("%d\n", b);
	}
	if (c)
	{
		printf("hello world\n");
		printf("%d\n", c);
	}
	return 0;
}

在C语言中,0为假,非0为真,这里对a进行逻辑取反然后赋值给b,最终我们打印b,得到b的结果为0。对a进行两次取反然后赋值给c,第一次取反此时c的值为0,再对0进行取反,此时c的值为1,由于1为真,所以判断成立,因此我们运行代码,屏幕上会打印hello world以及C的值。

10.4.2:++与--操作符

#include 
//++与--操作符
int main()
{
	int a = 0;
	//前置++(先+1,再使用)
	int b = ++a;
	int c = 5;
	printf("%d %d\n", a, b);//1 1
	//后置++(先使用,再+1
	c = a++;
	printf("%d %d\n", a, c);//2,1
	return 0;
}

前置++的窍门:先+1后使用,在这里,先对a进行+1然后再将其赋值给b,那么此时a的值为1,b的值也为1。

后置++的窍门:先使用后+1,在这里,先将a的值赋值给c,由于前面对a进行了一次前置++,因此此时c的值为1,使用完了以后a再+1,此时a的值为2。

 

 10.4.3:强制类型转换

概念:就是将一种数据类型强制转换另外一种数据类型

#include 
int main()
{
	//将a进行强制类型转换为整形
	int a = (int)3.1415926;
	int b = (int)4.9648;
	printf("%d %d\n", a, b);
	return 0;
}

在这里,我们将a和b这两个double类型的变量使用强制类型转换,那么此时在屏幕上打印的时候,只会打印整数,不遵循四舍五入哦！只保留整数部分。

PS:在C语言中,直接写出浮点数,会被编译器识别为double类型,例如17.0就会被编译器识别为double类型,如果要令其为float类型,则应表示为17.0f。

 

10.5:逻辑操作符 

• &&:逻辑与(两者为真且为真)
• | |:逻辑或(其一为真则为真)

&&:什么叫两者为真且为真呢?就好比老师叫李华,小明两个人都来办公室,只有两个人都来办公室了,那么才符合老师的需求。

| |:同理,其一为真则为真就好比老师叫李华或者小明其中一个来办公室就可以了,就是说,只要李华或者小明其中一个人来了就符合老师的需求,另外一个人来不来都可以。

#define  _CRT_SECURE_NO_WARNINGS
#include 
int main()
{
	int grade1 = 0;
	int grade2 = 0;
	scanf("%d %d", &grade1, &grade2);
	//逻辑与
	if ( grade1 >=60 && grade1 <=70)
	{
		printf("成绩合格\n");
	}
	//逻辑或
	if (grade2 >=80 || grade2 >= 90)
	{
		printf("成绩优良\n");
	}
	return 0;
}

  我们看这段代码,第一个是逻辑与,就是说,我的成绩既要大于等于60又要小于等于70,这两个条件同时满足时,屏幕上才会打印成绩合格,如果我的成绩是75,那么屏幕上就不会打印成绩合格。

                            第二个是逻辑或,就是说,我的成绩大于等于80或者大于等于90,满足这两个条件的其中之一,屏幕中就会打印成绩优良。

 

 10.6:逗号表达式

形式:exp1,exp2,exp3,.....epxN

特点:从左向右依次计算,整个表达式的结果为最后一个表达式的计算结果。

#define  _CRT_SECURE_NO_WARNINGS
#include 
int main()
{
	int a = 9;
	int b = 5;
	int c = 4;
	//特点:从左向右依次计算,整个表达式的结果为最后一个表达式计算结果
	//a--4,b--8,c---12,d---12
	int d = (a = a - 5, b = b + 3, c = a + b);
	printf("%d\n", d);
	return 0;

}

我们看这段代码,首先对a进行-5,此时b的值为4,然后再对b进行+3,此时b的值为8,最后将a+b赋值给c,那么此时c的值为12,由于c=a+b为最后一个表达式且计算结果为12,那么d的值为12。

 

10.7:下标引用操作符,函数调用操作符,成员访问操作符

成员访问操作符这个在下面讲结构体的时候会说滴。

#define  _CRT_SECURE_NO_WARNINGS
#include 

int product(int x, int y)
{
	return x * y;
}
int main()
{
	int arr[10] = { 5,8,5,4 };
	//[]为下标引用操作符
	printf("%d\n", arr[3]);
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	//()为函数调用操作符,a,b为操作数
	int c = product(a, b);
	printf("乘积为:%d", c);
	return 0;
}

[]为下标引用操作符,在这里,通过这个操作符来访问数组arr下标为3的元素。

()为函数调用操作符,在这里,通过这个操作符来调用函数add。

 

 11:常见关键字

概念:C语言预留给自己的一些特殊符号,有特殊的意义,这些符号被称为关键字。

博主在这里简单地讲解几个关键字,剩下在后期会慢慢详解滴。

PS:程序员不能自己创建关键字

类型:auto   char  double  enum  short  int  long  signed  unsigned  typedef  union

循环:break  continue  do....while  for  while
分支:break  switch  case  default  if  else  goto

其他:extern  register  static  volatile  return(函数)

11.1:typedef关键字

作用:顾名思义将类型重命名。

#define  _CRT_SECURE_NO_WARNINGS
#include 
//将unsigned int重命名为uint
typedef unsigned int uint;
typedef float flt;
int main()
{
	//变量a与b为同一数据类型
	unsigned int a = 0;
	uint b = 0;
	printf("a = %d b = %d\n", a, b);

	float c = 17.0f;
	flt d = 18.0f;
	printf("c = %d d = %d\n", c, d);
	return 0;
}

uu们如果对于一些数据类型的名称不是很熟悉的话,在敲代码的时候,可以将那个不熟悉的数据类型的名称命名为自己熟悉的,例如在这里我们将unsigned int重命名为uint,将float命名为flt

 

11.2:static关键字

作用:在C语言中,static是用来修饰变量与函数的。

(1):修饰局部变量----称为静态局部变量。

(2):修饰全局变量----称为静态全局变量。

(3):修饰函数-----称为静态函数。

①:修饰局部变量

一个普通的局部变量进入函数被创建,出函数被销毁。

但被static关键字修饰之后,进入函数时已经创建好了,出函数的时候也不被销毁,多次调用函数时,共享一个变量。

主观感受:生命周期变长,但作用域不变,还是只能在局部范围内使用。

本质:普通的局部变量是放在栈区上的,但被static修饰后,是放在内存的静态区,静态区的变量的生命周期和全局变量的生命周期一样。

#define  _CRT_SECURE_NO_WARNINGS
#include 
void test()
{
	//由于使用了static关键字,此时变量b的生命周期变长,但作用域不变
	//此时变量b为静态局部变量,放在内存中的静态区
	static int b = 0;
	b++;
	printf("%d ",b);
}
int main()
{
	int a = 0;
	while (a < 10)
	{
		test();
		a++;
	}
	return 0;
}

在这里由于使用了static关键字,所以变量b的生命周期变长,每次调用test函数时,是在原有基础上进行变化。如果不使用的话,那么屏幕上就会打印10个1。

②:修饰全局变量

• 一个全局变量被static修饰,此时这个全局变量只能在本源文件使用,不能在其他的.c文件中使用。

我们看一下这段代码,这是没有使用static关键字之前的情况,此时我们使用extern关键字对外部文件的变量进行声明,此时在屏幕上能够打印。

当我们使用static关键字声明时,此时我们运行代码,会发现编译器给我们报错了。

本质:全局变量具有外部链接属性,这种属性决定了全局变量在多个文件之间相互使用

        当使用static关键字修饰全局变量的时候,此时外部链接属性变成了内部链接属性。

        即此时gloval_varible只能在内部使用,不能在其他的.c文件使用

③:修饰函数

这里static修饰函数跟修饰全局变量也是一样滴，函数也是具有外部链接属性的,此属性决定了函数可以跨文件使用。

当static修饰函数的时候,将函数的外部链接属性改成了内部链接属性,令函数只能在自己.c文件中使用。

12:#define定义常量和宏

语法格式

//定义常量
#define 变量名  数值

//定义宏
#define  宏名,参数,宏体
 

#define  _CRT_SECURE_NO_WARNINGS
#include 
//定义常量
#define M 145
//定义宏---宏名,参数,宏体
#define Add(x,y)(x+y)
int main()
{
	int a = M;
	int b = 0;
	int c = 0;
	scanf("%d %d", &b, &c);
	printf("a = %d\n", a);
	int d = Add(b,c);
	printf("Add----%d\n",d);
	return 0;
}

 这段代码呢,定义常量M为145,然后我们将M赋值给a,那么此时a的值为145。

然后定义宏,可以类比定义函数,调用Add,然后对其进行传参,这里我们返回的是x+y的值,博主在这里输入的是5和8,因此返回的是13。

13:指针

13.1:内存

(1):内存是电脑上十分重要的存储器,计算机程序的运行都是在内存中运行的。

(2):内存空间为了有效地使用内存,就把内存划分成一个个小的内存单元,每个内存单元的大小是一个字节。为什么是一个字节呢?

原因如下:我们返回到计算机中的最小单位bite，假设一个内存单员为一个bite,若要存储一个字节的数据类型,则需要8个内存单元,因为1个字节是8个bite,那就显得太多了,复杂化了。如果一个内存单元的大小为1Kb,要存储一个字节的数据类型,由于1KB = 1024byte,那么会有1023个byte会被浪费,若一个内存单元空间的大小为1个字节,对于short,char,int等数据类型而言刚刚好。

(3):内存单元的编号称为地址(地址也叫指针)。

在C语言中,指针就是地址,地址就是编号

指针就是内存单元的编号。

访问内存---首先得有地址,有了地址才能找到内存单元。

那么地址从哪里来呢?

解释如下:

在计算机中,有地址线,物理的电线会产生电信号,然后会转换成数字信号0或者1,在

32位平台上,有32根地址线,那么就总共有2的32次方种可能,那如果我们把地址线出来的信号当成地址编号的话,这样的地址编号就有2的32次方个,一个编号与之匹配一个内存单元。

总共有2的32个地址,一个地址管理一个字节,那么就有2的32次方个字节,由于1KB = 1024byte,那么就是4194304KB,1MB = 1024KB,那么就是 4096MB;1GB = 1024MB,那么就是4GB,因此2的32次方个地址管理4GB的内存空间。

#define  _CRT_SECURE_NO_WARNINGS
#include 
int main()
{
	int value = 20;
	printf("%d\n", 20);
	//0x0000005F832FFC64 ---内存的编号 == 地址 ==指针,pv为指针变量
	// * 在说明pv是指针变量,int 在说明pv指向的是int类型的变量
	int* pv = &value;
	// *为解引用操作符 - 通过地址找到地址所指的对象, *pv等价于 value
	*pv = 50;
	printf("%d\n", value);
	return 0;
}

总结

1. 内存会被划分以字节为单位的一个个的内存单元,每个内存单元的大小是一个字节。
2. 每个内存单元都有编号,编号 = 地址 = 指针。
3. C语言中创建的变量,其实是向内存申请一块空间,比如:int value = 20,就是向内存申请4个字节的空间,每个字节都有地址。
4. &value的时候,拿出的是4个字节中地址较小的那个字节的地址(编号)。
5. 这个地址要存储起来,给一个变量,这个变量是用来存放地址(指针),所以叫指针变量:int * pv = &value。
6. pv中存放的是value的地址,要通过pv中的地址找到value,怎么写？----> *pv--->通过pv中的地址找到value; *pv = 50(本质是修改value)。
7. 指针变量:用于存放地址的变量即放任何东西都会被认为是地址,比如：int * a = 5(这个5会被认为是地址)
8. 口头语中说的指针:一般指的是指针变量

13.2:指针变量的大小

指针变量是用来存放地址的;指针变量的大小,就取决于存放一个地址需要多大的空间;

32位平台下:一个地址的大小是32bit位,需要4个字节,所以一个指针变量的大小是4个字节

64位平台下:64根地址线,一个地址的大小是64bit位,需要8个字节,所以一个指针变量的大小是8个字节。

#define  _CRT_SECURE_NO_WARNINGS
#include 
int main()
{
	int* pi;
	short* ps;
	char* pc;
	float* pf;
	double* pd;
	printf("%d\n",sizeof(pi));
	printf("%d\n",sizeof(ps));
	printf("%d\n",sizeof(pc));
	printf("%d\n",sizeof(pf));
	printf("%d\n",sizeof(pd));
	return 0;
}

x64代表是在64位平台下

x86代表在32位平台下

14:结构体

概念:可以从让C语言从多角度描述一个复杂的事物,例如描述一个人(姓名,年龄,性别等等)

语法格式

这里就要谈到成员访问操作符了,一个是.操作符,还有一个是->指向操作符。举个例子

#define  _CRT_SECURE_NO_WARNINGS
#include 

//定义一个结构体,命名为Personal
struct Personal
{
	char name[20];
	char sex[20];
	int age;
};
int main()
{
	//创建结构体变量
	struct Personal p1 = { "李华","男",18};
	struct Personal p2 = { "琳达","女",18};
	//定义一个指针变量存放结构体变量p1在内存中的地址
	struct Personal* p3 = &p1;
	//使用.操作符访问结构体变量p1所对应的属性的属性值
	printf("%s %s %d\n", p1.name, p1.sex, p1.age);
	printf("%s %s %d\n", p2.name, p2.sex, p2.age);

	//使用->操作符访问指针变量p3所对应的属性的属性值
	printf("%s %s %d\n", p3->name, p3->sex, p3->age);
	return 0;
}

为什么说这里有的用.操作符,有的用->操作符呢?

创建了结构体变量,那么我们在访问成员的时候就要使用.操作符进行访问。

而通过指针变量来创建结构体变量,即存放结构体变量在内存中的地址,这个时候就需要通过->操作符找到所指的地址,然后来进行访问。

结构体的定义要在所有函数之前,预处理指令之后。

  家人们，C语言的初识部分就到这里啦,之后呢会出C语言每个部分的详解,尽请期待,如果觉得博主写的符合你们心意的话,请家人们动动你们滴小手点个赞,我会将你们滴赞化为我的动力！！

---