亲宝软件园·资讯

展开

C语言入门基础 一篇文章带你了解C语言:入门基础(2)

AKA你的闺蜜 人气:0
想了解一篇文章带你了解C语言:入门基础(2)的相关内容吗,AKA你的闺蜜在本文为您仔细讲解C语言入门基础的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:C语言入门,C语言基础,下面大家一起来学习吧。

本节将结束对初识C语言的概述,只追求大概,不求精细。

本节包括的内容有操作符,常见关键字,#define定义常量和宏,指针以及结构体。

操作符

首先第一部分操作符

分类如上,具体不再用文字阐述。

算术操作符

首先算术操作符,有除号值得一讲,若想得浮点数,两端操作数至少有一个为浮点数,否则就算变量用float定义也不行。

int main()
{
	//除号任意两端有浮点数则,进行浮点数除法
	//全为整数则进行整数除法
	float a = 5 / 2;
	printf("%f\n", a);//2.0000
	float b = 5.0 / 2;
	printf("%f\n", b);//2.5000
	float c = 5 / 2.0;
	printf("%f\n", c);//2.5000
	float d = 5.0 / 2.0;
	printf("%f\n", d);//2.5000
 
	return 0;
}

移位操作符

接下来是移位操作符,分为左移和右移,右移较复杂先不讲,先讲左移。按二进制位向左移动一位,即把32个bit的二进制序列写出来,整体向左移动一位,左侧移出去就删去,右侧补零。

当然如果你写的多的话就可以看出来左移一位即十进制数字乘以二。

具体看代码

int main()
{
	//00000000 00000000 00000000 00001100 - 12
	//00000000 00000000 00000000 00011000 - 24
	int a = 12;
	int b = a << 1;
	printf("%d\n", b);
	//00000000 00000000 00000000 00000110 - 6
	//00000000 00000000 00000000 00001100 - 12
	int c = 6;
	int d = c << 1;
	printf("%d\n", d);
	//00000000 00000000 00000000 00000010 - 2
	//00000000 00000000 00000000 00000100 - 4
	int e = 2;
	int f = e << 1;
	printf("%d\n", f);
	//由2^0左移一位为2^1;
	//由2^1左移一位为2^2;
	//由2^2+2^3左移一位为2^3+2^4;
	//二进制左移一位即十进制乘以二
	return 0;
}

位操作符

接下来是位操作符,有按位与,按位异或和按位或,按位与和按位或是反义的。

具体方法是将两个操作数的二进制位写出来,相应位对比。

按位与:有0则0,全1则1。

按位异或:相同为0,相异为1。(异或嘛~)

按位或:有1则1,全0才0。

具体看代码

int main()
{
	int a = 3;
	int b = 5;
	//00000000000000000000000000000011 - a
	//00000000000000000000000000000101 - b
	//00000000000000000000000000000001 - a & b
	//对应的二进制位有0就为0,全是1则为1
	int c = a & b;
	printf("%d\n", c);//1

	//00000000000000000000000000000011 - a
	//00000000000000000000000000000101 - b
	//00000000000000000000000000000110 - a ^ b
	//对应的二进制位相同为0,相异为1
	int d = a ^ b;
	printf("%d\n", d);//6

	//00000000000000000000000000000011 - a
	//00000000000000000000000000000101 - b
    //00000000000000000000000000000111 - a | b
	//对应二进制位有1就是1,全为0才得0
	int e = a | b;
	printf("%d\n", e);//7
	return 0;
}

赋值操作符没什么好讲的,也就把a=a+1简写成了a+=1这样差不多的操作符。

单目操作符

接下来是单目操作符

逻辑反操作!

首当其冲是逻辑反操作!,这就涉及到了真假的问题。C语言中规定非0就是真,只有0是假。所以!上一个任意不为零的数都是0,但!0呢,规定!0就为1。

sizeof是个操作符,这也是很多人会忽略的一点。

按位取反~,经过上面移位和位操作符的讲解,应该不难得出按位取反的含义,就是把二进制位列出来然后1变0,0变1。

当然不止上面这么简单,正数是这样,那负数呢?

首先负整数时有符号的整数,二进制位最高位如果是0,则该数为正数,如果时1,则为负数。

其实计算机在内存中存储整数的时侯呀,存储的是二进制,这大家都知道。然而一个整数的二进制的表示形式有三种分别是 原码,反码,补码

如果是正数,那么原码反码补码相同,那如果是负数呢,它的原反补是需要计算的。

其次我们应该知道原反补是如何计算的。反码,原码符号位不变,其他位按位取反。补码,反码+1。

但是最重要也是最容易让初学者混淆的一点是,计算机存储整数时,往内存里存的是补码,而不是大多数人想象的原码,这就需要我们反过来计算原反补了。

可以以0为例,0的二进制位全为0,所以可以看成是个正数,所以其原反补相同。

如果我们想知道~0(对0按位取反)是个什么结果的话,

1.先对0的补码按位取反的~0的补码,

2.再反过来计算,补码-1得反码,

3.然后再符号位不变,其他按位取反得其原码,

4.这样就得到了~0的原码,就可计算其十进制数了

由此可得的重要结论,对一个数按位取反,反的是二进制位的补码!

int main()
{
	//整数在内存中存储的时候,存储的是二进制
	//一个整数的二进制表示有3种形式:原码,反码,补码
	//正整数:原码,反码,补码相同;
	//负整数:原码,反码,补码需计算;
	//有符号的整数,最高位是0,表示为正,
	//              最高位是1,表示为负;
	//eg: 
	//  int a = 1;
	//00000000000000000000000000000001 - 原码
	//00000000000000000000000000000001 - 反码
	//00000000000000000000000000000001 - 补码
	//  int a = -1;
	//10000000000000000000000000000001 - 原码
	//11111111111111111111111111111110 - 反码 - 符号位不变,其他位按位取反
	//11111111111111111111111111111111 - 补码 - 反码+1
	//内存存储整数时,存储的是二进制的补码
	//计算时也是从补码开始计算
	//~按(二进制)位取反
	int b = 0;
	printf("%d\n", ~b);//-1
	//00000000000000000000000000000000 - 0的补码
	//11111111111111111111111111111111 - ~0的补码
	//11111111111111111111111111111110 - ~0的反码
	//10000000000000000000000000000001 - ~0的原码
	//故由0的补码得~0的补码,补码-1得反码,再(符号位不变)按位取反得原码;
	//最后原码代表的就是结果的二进制序列;
	return 0;
}

操作符++,--

操作符++,--,值得一提。很多学校喜欢考各种各样的奇葩++--题,不同的编译器得到的结果可能不同,所以那就是道错题。

在真正编程时,使用++,--就老老实实使用。别搞别人看不懂的那一套,没意思的,实力不是靠那个体现出来的。就分为前置和后置,也就是先++,在使用,还是先使用,再++的区别。

int main()
{
	int a = 2;
	//a = a + 1;
	//a += 1;
	//printf("%d\n", a);
	//前置++;后置++;
	int c = ++a;//前置++;先++,后使用
	printf("++a=%d\n", c);//3
	printf("  a=%d\n", a);//3
	a = 2;
	int d = a++;//后置++;先使用,后++
	printf("a++=%d\n", d);//2
	printf("  a=%d\n", a);//3
	a = 2;
	int e = --a;//前置--;先--,后使用
	printf("--a=%d\n", e);//1
	printf("  a=%d\n", a);//1
	a = 2;
	int f = a--;//后置--;先使用,后--
	printf("a--=%d\n", f);//2
	printf("  a=%d\n", a);//1

	return 0;
}

取地址操作符和解引用操作符是一对,放在指针部分再讲。

关系操作符没什么好讲的,和数学上一个含义。

逻辑操作符

逻辑操作符嘛,就如同数学里的逻辑真假一样,逻辑与和逻辑或,分别是并且和或者的关系,他们两边分别是两个条件,如果两个都为真,逻辑与表达式就为真。如果两个有一个真的,逻辑或表达式就是真。

int main()
{
	//逻辑与 - &&(并且)
	//逻辑或 - ||(或者)
	int a = 1;
	int b = 4;
	if ((a = 1) && (b = 4))
	{
		printf("&&\n");
	}
	if ((a = 3) || (b = 4))
	{
		printf("||\n");
	}
	return 0;
}

条件操作符

条件操作符,x?y1:2,?的两边分别是两个条件,前面的成立则整个表达式的值为1,反正则2。

逗号表达式

逗号表达式,( , , ,) ,如这样的一个例子,每一个表达式都是一个算式,从左向右依次计算,最后一个表达式的结果作为整个逗号表达式的值。

//条件操作符(三目操作符)
int main()
{
	int a = 10;
	int b = 0;
	//if (a == 5)
	//{
	//	b = -6;
	//}
	//else
	//{
	//	b = 6;
	//}
	b = (a = 5) ? (6) : (-6);
	printf("%d\n", b);
	return 0;
}

//逗号表达式
//( , , ... , );
//表达式从左向右计算,整个表达式的结果为最后一个表达式的值
int main()
{
	int a = 0;
	int b = 3;
	int c = -1;
	int d = (a = b - 5, b = a + c, c = a + b, c -= 5);
	printf("%d\n", d);
	return 0;
}

OK,关于操作符的内容就先介绍到这儿。

下面是关键字的内容。

常见关键字

上图为常见关键字的思维导图,接下来请随我一同探讨。

这些是C语言里常见的各种关键词,下面将对其部分稍作讨论。

typedef

首先是typedef,翻译来就是类型重命名。顾名思义,就是将定义变量的类型的名字如int,char等,重新取个名字代替。当然一般用于非常长的类型名如unsigned int这样,或者是结构体类型。 如此之后就可以把unsigned int 改写成 unint了。

//typedef 变量类型重命名
typedef unsigned int unint;

extern

然后是extern,翻译过来就是外部的意思,故用于声明引用外部(其他.c文件)的文件或者是函数等,但由于函数自带外部链接属性,所以一般不用于声明外部函数。用法如extern int g_val;(g_val是外部的变量)

static

紧接着是static,它分别有修饰局部变量,修饰全局变量和修饰函数三种不同的用法,但个人认为修饰全局变量和函数的意义相同。

修饰局部变量

修饰局部变量时,使其出作用域不会被销毁,准确的来说就是延长了他的生命周期,但不影响作用域。

修饰全局变量和函数

修饰全局变量和函数时,会使其外部链接属性失效,也是就使其不可以再其他源文件中被使用。

void test()
{
	//修饰局部变量
	//改变其生命周期,不影响作用域
	static int a = 1;
	a++;
	printf("%d ", a);
}
int main() 
{
	int i = 0;
	while (i < 10)
	{
		test();
		i++;
	}
	//static修饰全局变量
	printf("%d\n", g_val);

	int a = 10;
	int b = 20;
	//static修饰的函数
	int c = Add(a, b);
	printf("%d\n", c);

	return 0;
}
//static修饰全局变量
//使其不可跨文件使用(外部链接属性失效)
static int g_val = 2021;
//static修饰的函数
//函数被static修饰,使其外部链接属性变内部链接属性
static int Add(int x, int y)
{
	return x + y;
}

其它

其它如,auto,goto,register,union,稍微了解一下。

#define定义常量和宏

定义常量

定义常量时,也是非常简单,例如:#define N 10; 就定义了一个不可被修改的常量其值为10。

定义宏

#define MAX(x,y) (x>y?x:y)

类似于函数,但又有别于函数,MAX(x,y)是宏,(x>y?x:y) 是宏体。MAX(x,y),像是函数名和传参放在一块,()就像是函数内容。

//定义常量
#define NUM 100
//定义宏
#define MAX(X,Y) (X>Y?X:Y)
int main()
{
	printf("%d\n", NUM);
	int a = 0;
	int b = 10;
	int c = MAX(a, b);
	//实际操作,替换宏体
	//int c = (a > b ? a : b);
	printf("%d\n", c);
	return 0;
}

指针

指针一直是我之前自学的时候最害怕的内容,但这次初识C语言让我消除了对指针的恐惧,一步步的了解指针。

指针嘛,指向变量的内存地址,故讲指针之前必须把内存搞清楚。

内存单元

为了可以有效使用内存,我们把内存划分了一个个小的内存单元,每个内存单元的大小为1byte。

我们需对内存进行编号,当然需要二进制位序列表示(默认我们是32位机器)。

每个二进制序列有32个bit,从数学全排列角度看,一共有2的32次方种排列可能(32个全0到32个全1)。

所以若想对其进行编号,不如一人一个码(一个内存单元用一个二进制序列表示)。并且我们把这些编号成为地址。

当然,二进制也可以转化为十进制或者十六进制,所以我们再调试时调用内存会看到自动显示为十进制数字。

我们了解了内存,现在我们看看如何取出内存的地址

int main()
{
    int num = 1;//先创建一个变量
    #//然后取出它的地址
    printf("%p",&num);//最后以%p的形式打印地址
return 0;
}

这样我们就得到了num的地址,以十六进制数字展示。

指针变量

我们讲清楚了内存,现在再来看看指针。

我们既然已经得到了地址,那我们如何去储存这些东西呢,这是程序员们就想到了一种东西叫指针变量,它用于存放地址。

关于该(指针)变量如何定义看下列代码。

#include <stdio.h>
int main()
{
    int num = 10;
    int *p = #
    *p = 20;
return 0;
}

上述代码中我们可以看到,指针变量的类型时 int * 。而有了指针变量后,在其前面加上*有个可以改变原变量的值。当然之所以是int*而不是char*,是因为原变量是int型的。

&取地址操作符,*解引用操作符

这里我们介绍一下,两个操作符分别是&取地址操作符和*解引用操作符。

&+变量名 可以取出变量的地址。

*+指针变量名 就可以把它当作原变量使用,通过这样就可以进行改变原变量的这样一系列的操作

可以说 pa = &a , *pa = a。

类型所占空间

那么我们既然知道了有种变量叫指针变量,那么他们的类型大小是多少呢?

答案是每种指针变量类型大小都为4个字节(32位机器),因为指针变量存放地址,地址为二进制序列,32个bit,正好占4个byte。当然64位机器就是8个字节。

结构体

结构体的出现使得C语言具有了描述复杂类型的能力。

C语言的类型int,char,float等可以描述很多东西,但是这毕竟太单一,使用结构体可以描述更复杂的对象。

比如最经典的例子,如学生,书籍等。

定义结构体

描述学生的信息有名字,性别,年龄,学号等,下面且与我一同欣赏如何定义学生结构体。(记得大括号后面有个分号,vs2019自动带上)

struct stu
{
	char name[20];//姓名
	int age;//年龄
	char sex[5];//性别
	char id[20];//学号
};

或者是针对书籍的描述,有书名,价格,作者名等

struct book
{
	char name[20];
	int price;
	char author[20];
};

注意,struct stu 这一整个相当于 int float double 。

这样我们就完成了结构体变量类型的定义。

下面我们定义一个个的学生(结构体)变量。

//创建结构体变量
	struct stu s1 = {"芜湖大司马",40,"男","2020313222"};
	struct stu s2 = {"lisa",22,"女","2020313232"};
	struct book b1 = {"C语言详解",55,"谭浩强"};

使用结构体变量

创建好了我们如何去使用呢?最简单的输出方式,使用操作符 .

形式上是 结构体变量.成员名。

	//输出1
	printf("name: %s,age: %d,sex: %s,id: %s\n", s1.name, s1.age, s1.sex, s1.id);
	printf("书名: %s,价格: %d,作者: %s\n", b1.name, b1.price, b1.author); 

既然这样可以的话,我们还可以定义指针变量代替变量名,用(*pb)代替b1。

	struct book * pb = &b1;
        //先定义一下指针变量
	printf("%s %d %s\n", (*pb).name, (*pb).price, (*pb).author);
        //指针变量解引用,就可以当作原变量使用

当然有更方便的操作符 ->,这样我们可以直接使用指针啦,如结构体指针->成员名。

	struct book * pb = &b1;
	//别忘了定义指针
	printf("%s %d %s\n", pb->name, pb->price, pb->author);
        //指针变量名直接加 —> 再加成员名

直到这里我们初识C语言的内容就讲完了,非常感谢您的观看,创作着实不易。

总结

本篇文章就到这里了,希望能给你带来帮助,也希望您能够多多关注的更多内容!

加载全部内容

相关教程
猜你喜欢
用户评论