一篇文章带你了解C语言:入门基础(2)
时间：2022-02-23 09:41:40 | 栏目：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语言的内容就讲完了，非常感谢您的观看，创作着实不易。