1.什么是C语言
C语言是一门计算机语言。计算机语言是人和计算机交流的语言。
计算机语言从能直接识别和接受的二进制代码的机器语言到 汇编语言，再到 高级语言。
2.C语言的发展及特点1
C语言是一门功能强大，灵活多变的语言。它深受职业程序员和业余编程爱好者的喜爱。C语言是由肯•汤普逊（Ken Thompson）和丹尼斯•里奇（D.M.Ritchie）合力开发的。最初只是用来编写UNIX操作系统，但后来扩展到了诸如微型计算机，嵌入式处理器等领域。
下面来简单回顾一下C语言的发展历程。
（1）ALGOL 60 语言
C语言最早的原型是ALGOL 60语言，它也称A语言 ，全称Algorithmic Languagelo，ALGOL 60语言是世界最早的高级语言之一，他为以后许多语言的发明奠定了基础（包括C语言）。
（2）CPL语言
CPL(Combined Programming Language)是在ALGOL 60语言的基础上，由英国剑桥大学改进而成。
（3）BCPL
BCPL(Basic Combined Programming Language)是由CPL语言简化而来的，它的缩写第一个字母就代表着Basic，在英语中有简化的意思。它是一种面向过程的高级语言，并且比CPL更加方便易用，更加模块化且容易实现。
（4）B语言
1969年，肯•汤普逊和丹尼斯•里奇在BCPL的基础上继续进行简化，形成了B语言。B语言从BCPL中删除了许多非必要的组件，以便能更好地适应当时日益流行的小型计算机。它在数据类型，内存管理方面依旧有明显的缺点，但仍不失为一种简单易用，功能强大的语言，可以说是C语言的雏形。
（5）C语言
C语言继承了它的祖先们的许多优点，至今仍是一门流行，用途广泛的语言，它的特点主要如下：
-
①兼顾汇编语言与高级语言的特点，能以简易的方式编译，处理低级存储器，操纵地址，又有抽象化编程的特点；
-
②编译后的可执行程序效率较高，仅比汇编语言低10%到20%；
-
③可移植性强，在不用修改代码的情况下，可以从一台计算机移植到另一台计算机上；
-
④使用结构化编程，代码复用性好，可以编写大型程序，且方便修改；
-
⑤代码格式较自由 ，对语法限制不严格，使程序员可以根据自己的风格写程序。
C语言有如此多的优点，使得这种语言很快被广泛运用。1979年，Bjarne Stroustrup 在C语言的基础上，又添加了面向对象特性和泛型编程特性，形成了C++。后来，Sun公司又以C语言为蓝本，发明了JAVA语言。C语言依然影响着许许多多的语言，如Visual Basic，D语言，C#，Object-C等。在编程史上有着重要的地位。
3.编写最简单的一个C语言程序
eg:在屏幕上输出hello world!如下图所示
代码如下：
#include<stdio.h>//编译预处理指令，包含一个叫stdio.h的文件standard input output标准输入输出
int main()//定义主函数——程序的入口，main函数有且只有一个
{ //函数的开始标志
printf("hello world!");//打印函数printf，输出指定的一行信息
return 0;//函数执行完毕时返回函数值0
} //函数的结束标志
//注意：这个“//”后面的文字是注释部分
/*这是另一个注释符*/
4.初识基本数据类型
| 基本数据类型 | 含义 |
|---|---|
| char | 字符数据类型 |
| short | 短整型 |
| int | 整型 |
| long | 长整型 |
| long long | 更长的整型 |
| float | 单精度浮点型 |
| double | 双精度浮点型 |
| bool | 布尔型 |
以下实例显示基本数据类型占用几个字节
#include<stdio.h>
#include<stdbool.h>//没有此头文件，会有错误，bool会显示为声明
int main()//主函数——程序的入口，main函数有且只有一个
{
printf("char占%d个字节\n", sizeof(char));//输出char占用几个字节
printf("short占%d个字节\n", sizeof(short));//输出short占用几个字节
printf("int占%d个字节\n", sizeof(int));//输出int占用几个字节
printf("long long占%d个字节\n", sizeof(long long));//输出long long占用几个字节
printf("long占%d个字节\n", sizeof(long)); //输出long占用几个字节
printf("float占%d个字节\n", sizeof(float));//输出float占用几个字节
printf("double占%d个字节\n", sizeof(double));//输出double占用几个字节
printf("bool占%d个字节\n", sizeof(bool));//输出bool占用几个字节
return 0;//返回零
}
结果如下图
各数据类型输出形式
char–>%c（输出一个字符）
short–>%hd
int–>%d
long–>%ld
float–>%f
double–>%lf
若想保留n位小数可如%.nf或%.nlf这样写
各数据类型输出形式演示如下：
#include<stdio.h>
int main()
{
char ch = 'A';
short a = 1;
int b= 100;
long c = 1000;
float d = 1.0;
double e = 1.0;/*赋值*/
printf("ch = %c\n a = %hd\n b = %d\n c = %ld\n d = %f\n e=%lf\n",ch, a, b, c,d,e );//输出各值
return 0;
}
结果图如下
5.初识常量和变量
数据有两种表现方式：常量和变量
- 常量：值不能改变的量
- 变量：值能改变的量
5.1常量
5.1.1整型常量。
如1000，123，0，-23等都是整型常量。
5.1.2实型常量。
有两种表现形式：
- ①十进制小数形式，由数字和小数点组成。如1.23，0.23，-23.40.0，12.0等。
- ②指数形式。如12.34e3（代表12.34乘以10的3次方）,-12.34e-3(代表-12.34乘以10的-3次方),12.34E3(代表12.34乘以10的3次方)。注意：计算机输入输出规定以字母e或E代表以10为底的指数。
5.1.3字符常量。
两种形式字符常量：
- ①普通字符，用单撇号括起来的一个字符，如：‘a’,‘A’,‘2’,‘?’。
- ②转义字符，一种特殊形式的字符常量，以字符“\”开头的字符序列。
常用以“\”开头的特殊字符见下表：
| 转义字符 | 字符值 | 输出结果 |
|---|---|---|
| \’ | 一个单撇号（'） | 输出单撇号字符’ |
| \" | 一个双撇号（"） | 输出双撇号字符" |
| \? | 一个问号(?) | 输出问号字符? |
| \\ | 一个反斜线(\) | 输出反斜线字符\ |
| \a | 警告(alert) | 产生声音或视觉信号 |
| \b | 退格(backspace) | 将光标当前位置后退一个字符 |
| \f | 换页(from feed) | 将光标当前位置移到下一页的开头 |
| \n | 换行 | 将光标当前位置移到下一行的开头 |
| \r | 回车(carriage return) | 将光标当前位置移到本行的开头 |
| \t | 水平制表位 | 将光标当前位置移到下一个Tab位置 |
| \v | 垂直制表位 | 将光标当前位置移到下一个垂直制表位对齐点 |
| \o、\oo或\ooo(其中o代表一个八进制数字) | 与该八进制码对应的ASCII字符 | 与该八进制码对应的字符 |
| \xh[h···](其中h代表一个十六进制数字) | 与该十六进制码对应的ASCII字符 | 与该十六进制码对应的字符 |
转义字符意思是将“\”后面的字符转换成另外的意义。如“\n”中的“n”不代表字母n而作为“换行”符。
5.1.4字符串常量。
如“boy”，“123”等，用双撇号把若干字符括起来，字符串常量是双撇号括起来的全部字符（不包括双撇号本身）。
5.1.5符号常量。
用#define指令，指定用一个符号名代表一个常量。如：
#define PI 3.1416 //注意行末没有分号。为与变量名区别，习惯上符号常量用大写表示
此处输出试试
#include<stdio.h>
int main()
{
#define PI 3.1416
printf("%.4f", PI);
}
5.2变量
变量必须先定义，后使用。在定义时指定该变量的名字和类型。请注意变量名和变量值。如下图中a是变量名，3是变量a的值，即存放在变量a的内存单元中的数据。
5.3常变量
C99允许使用常变量，方法是在定义变量前，前面加一个关键字const，如const int a=3;定义a为一个整型变量，指定其值为3，而且在变量存在期间其值不能改变。
常变量与常量的异同是:常变量具有变量的基本属性:有类型，占存储单元，只是不允
许改变其值。可以说，常变量是有名字的不变量，而常量是没有名字的不变量。有名字就便于在程序中被引用。
思考:常变量与符号常量有什么不同?
如:#define Pi 3.1415926//定义符号常量与const float pi= 3.1415926;//定义常变量
符号常量Pi和常变量pi都代表3. 1415926,在程序中都能使用。
但二者性质不同: 定义符号常量用井define指令,它是预编译指令，它只是用符号常量代表一个字符串，在预编译时仅进行字符替换,在预编译后,符号常量就不存在了(全置换成3.1415926了)，对符号常量的名字是不分配存储单元的。而常变量要占用存储单元，有变量值，只是该值不改变而已。
从使用的角度看，常变量具有符号常量的优点，而且使用更方便。有了常变量以后，可以不必多用符号常量。
5.4标识符
对变量、符号常量名、函数、数组、类型等命名的有效字符序列统称为标识符（identifier）。
C语言规定标识符只能由字母、数字和下划线 3种字符组成，且第一个字符必须是字母或下划线。
如：mohd zara abc move_name a_123 myname50 _temp j a23b9 retVal
6.初识选择语句
举一个例子：如果你正在为了未来而学习，那么你将来可以有一个好的未来；如果你在玩耍，得过且过，那么你将来就可能成为一名普通屌丝。
下面的是if···else语句
#include<stdio.h>
int main()
{
int s;//定义变量
printf("你是在为了未来学习吗？（0代表否，1代表是）:");//打印这句话
scanf("%d",&s);//输入s的值
if(s==1)//判断s的值是否为1
{printf("拥有一个好的未来");}
else
{printf("屌丝一名");}
break 0;
}
结果图：
7.初识循环语句
一般情况下，语句是按顺序执行的：函数中的第一个语句先执行，接着是第二个语句，依此类推。有时我们需要重复执行一些语句，就需要循环语句，接下来就用while循环语句讲一下
例子：当前有五个同学面临一下选择并做出回答：如果你正在为了未来而学习，那么你将来可以有一个好的未来；如果你在玩耍，得过且过，那么你将来就可能成为一名普通屌丝。
以上语句需要循环五次
#include<stdio.h>
int main()
{
int s;//定义变量
int i = 0;//定义变量并赋初值
while(i<5)//while语句判断i是否小于5，小于5执行下面语句，否则跳出循环，共执行0、1、2、3、4五次
{
printf("你是在为了未来学习吗？（0代表否，1代表是）:");//打印这句话
scanf_s("%d", &s);//输入s的值
i++;//输入一次值i就增加1
printf("第%d名同学选择结果如下：\n", i);//输出i增长后的值
if(s==1)//判断s的值是否为1
{ printf("拥有一个好的未来\n");}
else
{printf("屌丝一名\n");}
}
return 0;
}
结果图：
8.初识函数和数组
8.1初识函数
函数是一组一起执行一个任务的语句。 每个 C 程序都至少有一个函数，即主函数 main() ，所有简单的程序都可以定义其他额外的函数。
函数声明告诉编译器函数的 名称、返回类型 和 参数。
函数定义提供了函数的 实际主体。
定义函数：
C 语言中的函数定义的一般形式如下：
return_type function_name( parameter list )//return_type 是函数返回的值的数据类型;function_name是函数名；parameter list是参数列表
{
body of the function//函数体
}
在 C 语言中，函数由一个函数头和一个函数主体组成。
下面列出一个函数的所有组成部分：
返回类型：一个函数可以返回一个值。return_type 是函数返回的值的数据类型。有些函数执行所需的操作而不返回值，在这种情况下，return_type 是关键字 void。
函数名称：这是函数的实际名称。函数名和参数列表一起构成了函数签名。
参数：参数就像是占位符。当函数被调用时，您向参数传递一个值，这个值被称为实际参数。参数列表包括函数参数的类型、顺序、数量。参数是可选的，也就是说，函数可能不包含参数。
函数主体：函数主体包含一组定义函数执行任务的语句。
以下以max()函数源代码实例说明：
/* 函数返回两个数中较大的那个数 */
int max(int num1, int num2) //int为返回值类型，是整型；max函数名；int num1, int num2参数列表，类型都是整型。
{
int result;//声明局部整型变量
if (num1 > num2)//if语句判断大小
result = num1;//判断为真，赋值于result
else
result = num2;//判断为假，赋值于result
return result; //返回result的值
}
具体操作比大小实例如下：
#include <stdio.h>
int max(int num1, int num2);//函数声明；函数声明会告诉编译器函数名称及如何调用函数
int main()
{
/* 局部变量定义 */
int a = 123;
int b = 456;
int com;
com = max(a, b);//调用函数来获取最大值
printf("Max value is : %d\n", com);
return 0;
}
/* 函数返回两个数中较大的那个数 */
int max(int num1, int num2) //int为返回值类型，是整型；max函数名；int num1, int num2参数列表，类型都是整型。
{
int result;//声明局部整型变量
if (num1 > num2)//if语句判断大小
result = num1;//判断为真，赋值于result
else
result = num2;//判断为假，赋值于result
return result; //返回result的值
}
8.2初识数组
数组可以存储一个固定大小的相同类型元素的顺序集合。
所有的数组都是由连续的内存位置组成。最低的地址对应第一个元素，最高的地址对应最后一个元素。
数组中的特定元素可以通过索引访问，第一个索引值为 0。
数组声明时，要指定元素的类型和数量：type/*元素类型*/ arrayName/*数组名*/[arraySize]/*元素数量*/
实例：int number[10]//int整型 number数组名 数量10现在number可以容纳10个int类型的数字
初始化数组如：int sumber[5] = {12,23,34,45,56};这个是初始化时直接进行了数组赋值
实例：
#include<stdio.h>
int sumber[10];//声明数组
sumber[10] = { 1,2,3,4,5,6,7,8,9,10 };//初始化数组并赋值
int main()
{
printf("索引为5的数组元素:%d",sumber[5]);//打印出索引为5的数组元素
}
下面的是动态赋值：
int main()
{
int sumber[10];//声明数组
int i, j;
/*初始化数组元素*/
for (i = 0; i < 10; i++)
{
sumber[i] = i + 10;
}
/*打印出数组元素*/
for (j = 0; j < 10; j++)
{
printf("sumber[%d]=%d\n",j, sumber[j]);
}
printf("索引为5的数组元素:%d\n", sumber[5]);//打印出索引为5的数组元素
return 0;
}
9.初识运算符
运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。
本节将初识算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符和其他运算符。
9.1算术运算符
假设a值为10，b值为20，则如下表所示：
| 运算符 | 描述 | 实例 |
|---|---|---|
| "+ " | 把两个操作数相加 | a + b 将得到 30 |
| "- " | 从第一个操作数中减去第二个操作数 | a - b 将得到 -10 |
| "* " | 把两个操作数相乘 | a * b 将得到 200 |
| "/ " | 分子除以分母 | b / a 将得到 2 |
| "% " | 取模运算符，整除后的余数 | b % a 将得到 0 |
| "++ " | 自增运算符，整数值增加 1 | a++ 将得到 11 |
| "-- " | 自减运算符，整数值减少 1 | a-- 将得到 9 |
#include <stdio.h>
int main()
{
int a = 10;
int b = 20;
int c;
c = a + b;
printf("a+b的值是 %d\n", c);
c = a - b;
printf("a-b的值是 %d\n", c);
c = a * b;
printf("a*b的值是 %d\n", c);
c = b / a;
printf("b/a的值是 %d\n", c);
c = b % a;
printf("b%%a的值是 %d\n", c);
c = a++; // a初始值为10赋值于c后再加 1为a的值 ，所以c 为 10，a 为 11
printf("a++的值是 %d\n", c);
printf("a的值是 %d\n", a);
c = a--; // a在上一次运算中已经改变a的初始值为11赋值于c后再减 1是a的值 ，所以c 为 11 ，a 为 10
printf("a--的值是 %d\n", c);
printf("a的值是 %d\n", a);
}
结果图
注意：a++与++a前者是先赋值再运算，后者是先运算再赋值，a–与–a亦是。
9.2关系运算符
假设a值为10，b值为20，则如下表所示：
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 检查两个操作数的值是否相等，如果相等则条件为真。 | (a == b) 为假。 |
| != | 检查两个操作数的值是否相等，如果不相等则条件为真。 | (a != b) 为真。 |
| > | 检查左操作数的值是否大于右操作数的值，如果是则条件为真。 | (a > b) 为假。 |
| < | 检查左操作数的值是否小于右操作数的值，如果是则条件为真。 | (a < b) 为真。 |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。 | (a >= b) 为假。 |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。 | (a<= b) 为真。 |
#include <stdio.h>
int main()
{
int a = 10;
int b = 20;
if (a == b)
{
printf("a == b为真则a等于 b\n");
}
else
{
printf("a == b为假则a不等于 b\n");
}
if (a < b)
{
printf("a < b为真则a小于 b\n");
}
else
{
printf("a < b为假则a不小于 b\n");
}
if (a > b)
{
printf("a > b为真则a大于 b\n");
}
else
{
printf("a > b为假则a不大于 b\n");
}
if (a <= b)
{
printf("a <= b为真则a小于或等于 b\n");
}
if (b >= a)
{
printf("b >= a为真则b大于或等于 a\n");
}
}
9.3逻辑运算符
假设变量 a 的值为 1，变量 b 的值为 0，则：
| 运算符 | 描述 | 实例 |
|---|---|---|
| && | 称为逻辑与运算符。如果两个操作数都非零，则条件为真。 | (A && B) 为假。 |
| || | 称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。 | (A||B) 为真。 |
| ! | 称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 | !(A && B) 为真。 |
#include <stdio.h>
int main()
{
int a,b ;
printf("请输入a的值：");
scanf_s("%d", &a);
printf("请输入b的值：");
scanf_s("%d", &b);
if (a && b)
{
printf("a && b条件为真\n");
}
else
{
printf("a && b条件为假\n");
}
if (a || b)
{
printf("a || b条件为真\n");
}
else
{
printf("a || b条件为假\n");
}
if (!(a && b))
{
printf("!(a && b)条件为真\n");
}
else
{
printf("!(a && b)条件为假\n");
}
}
结果图：
9.4位运算符
位运算符作用于位，并逐位执行操作。&、 | 和 ^ 的真值表如下所示：
| p | q | p & q | p | q | p ^ q |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
假设如果 A = 60，且 B = 13，现在以二进制格式表示，它们如下所示：
A = 0011 1100
B = 0000 1101
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011
下表显示了 C 语言支持的位运算符。假设变量 A 的值为 60，变量 B 的值为 13，则：
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 按位与操作，按二进制位进行"与"运算。运算规则请参照上面真值表 | (A & B) 将得到 12，即为 0000 1100 |
| | | 按位或运算符，按二进制位进行"或"运算。运算规则：请参照上面真值表 | (A | B) 将得到 61，即为 0011 1101 |
| ^ | 异或运算符，按二进制位进行"异或"运算。运算规则：请参照上面真值表 | (A ^ B) 将得到 49，即为 0011 0001 |
| ~ | 取反运算符，按二进制位进行"取反"运算。运算规则：~1=-2; ~0=-1; | (~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。 |
| << | 二进制左移运算符。将一个运算对象的各二进制位全部左移若干位（左边的二进制位丢弃，右边补0）。 | A << 2 将得到 240，即为 1111 0000 |
| >> | 二进制右移运算符。将一个数的各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃。 | A >> 2 将得到 15，即为 0000 1111 |
实例：
int main()
{
int a = 60; /* 60 = 0011 1100 */
int b = 13; /* 13 = 0000 1101 */
int c = 0;
c = a & b; /* 12 = 0000 1100 */
printf("a & b 的值是 %d\n", c);
c = a | b; /* 61 = 0011 1101 */
printf("a | b 的值是 %d\n", c);
c = a ^ b; /* 49 = 0011 0001 */
printf("a ^ b 的值是 %d\n~a", c);
c = ~a; /*-61 = 1100 0011 */
printf("~a 的值是 %d\n", c);
c = a << 2; /* 240 = 1111 0000 */
printf("a << 2 的值是 %d\n", c);
c = a >> 2; /* 15 = 0000 1111 */
printf("a >> 2 的值是 %d\n", c);
}
结果图：
9.5赋值运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符，把右边操作数的值赋给左边操作数 | C = A + B 将把 A + B 的值赋给 C |
| += | 加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数 | C += A 相当于 C = C + A |
| -= | 减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数 | C -= A 相当于 C = C - A |
| *= | 乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数 | C *= A 相当于 C = C * A |
| /= | 除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数 | C /= A 相当于 C = C / A |
| %= | 求模且赋值运算符，求两个操作数的模赋值给左边操作数 | C %= A 相当于 C = C % A |
| <<= | 左移且赋值运算符 | C <<= 2 等同于 C = C << 2 |
| >>= | 右移且赋值运算符 | C >>= 2 等同于 C = C >> 2 |
| &= | 按位与且赋值运算符 | C &= 2 等同于 C = C & 2 |
| ^= | 按位异或且赋值运算符 | C ^= 2 等同于 C = C ^ 2 |
| |= | 按位或且赋值运算符 | C |= 2 等同于 C = C | 2 |
实例：
#include <stdio.h>
int main()
{
int a = 21;
int c;
c = a;
printf(" = 运算符实例，c 的值 = %d\n", c);
c += a;
printf(" += 运算符实例，c 的值 = %d\n", c);
c -= a;
printf(" -= 运算符实例，c 的值 = %d\n", c);
c *= a;
printf(" *= 运算符实例，c 的值 = %d\n", c);
c /= a;
printf(" /= 运算符实例，c 的值 = %d\n", c);
c = 200;
c %= a;
printf(" %%= 运算符实例，c 的值 = %d\n", c);
c <<= 2;
printf(" <<= 运算符实例，c 的值 = %d\n", c);
c >>= 2;
printf(" >>= 运算符实例，c 的值 = %d\n", c);
c &= 2;
printf(" &= 运算符实例，c 的值 = %d\n", c);
c^= 2;
printf(" ^= 运算符实例，c 的值 = %d\n", c);
c|= 2;
printf(" |= 运算符实例，c 的值 = %d\n", c);
}
结果图：
9.6其他运算符
下表列出 C 语言支持的其他一些重要的运算符，如 sizeof 和 ? :等。
| 运算符 | 描述 | 实例 |
|---|---|---|
| sizeof() | 返回变量的大小。 | sizeof(a) 将返回 4，其中 a 是整数 |
| & | 返回变量的地址。 | &a; 将给出变量的实际地址。 |
| * | 指向一个变量。 | *a; 将指向一个变量。 |
| ? : | 条件表达式 | 如果条件为真 ? 则值为 X : 否则值为 Y |
实例如下：
#include <stdio.h>
int main()
{
int a=5;
short b;
double c;
int* ptr;//定义一个指向int变量类型的指针变量ptr
/* sizeof 运算符实例 */
/* 此段代码是计算a,b,c所代表数据类型的大小 */
printf("变量 a 的大小 = %d\n", sizeof(a));
printf("变量 b 的大小 = %d\n", sizeof(b));
printf("变量 c 的大小 = %d\n", sizeof(c));
/* & 和 * 运算符实例 */
ptr = &a; //告诉指针ptr指向a, 'ptr' 现在包含 'a' 的地址
printf("a 的值是 %d\n", a);
printf("*ptr 是 %d\n", *ptr);//将指针所指向的变量的值打印出来
/* 三元运算符实例 */
a = 10;
b = (a == 1) ? 20 : 30;
printf("b 的值是 %d\n", b);
b = (a == 10) ? 20 : 30;
printf("b 的值是 %d\n", b);
}
结果图：
10.常见关键字
C语言一共有32个关键字，如下表所示：
1.数据类型关键字(12个)：
| 关键字 | 描述 |
|---|---|
| char | 声明字符型变量或函数 |
| double | 声明双精度变量或函数 |
| enum | 声明枚举类型 |
| float | 声明浮点型变量或函数 |
| int | 声明整型变量或函数 |
| long | 声明长整型变量或函数 |
| short | 声明短整型变量或函数 |
| signed | 声明有符号类型变量或函数 |
| struct | 声明结构体变量或函数 |
| union | 声明联合数据类型 |
| unsigned | 声明无符号类型变量或函数 |
| void | 声明函数无返回值或无参数，声明无类型指针 |
2.控制语句关键字（12个）：
| 关键字 | 描述 |
|---|---|
| ①break | 跳出当前循环 |
| ②continue | 结束当前循环，开始下一轮循环 |
| ③do | 循环语句的循环体 |
| ④for | 一种循环语句 |
| ⑤while | 循环语句的循环条件 |
| ⑥else | 条件语句否定分支（与 if 连用） |
| ⑦goto | 无条件跳转语句 |
| ⑧if | 条件语句 |
| ⑨case | 开关语句分支 |
| ⑩default | 开关语句中的“其他”分支 |
| ⑪switch | 用于开关语句 |
| ⑫return | 子程序返回语句（可以带参数，也可不带参数） |
注：前5个为循环语句关键字，6-8为条件语句关键字，9-11为开关语句关键字，最后一个为返回语句关键字
2.存储类关键字（4个）：
| 关键字 | 描述 |
|---|---|
| auto | 声明自动变量 一般不使用 |
| extern | 声明变量是在其他文件中声明 |
| register | 声明寄存器变量 |
| static | 声明静态变量 |
3.其他关键字（4个）：
| 关键字 | 描述 |
|---|---|
| const | 声明只读变量 |
| sizeof | 计算数据类型长度 |
| typedef | 用以给数据类型取名 |
| volatile | 说明变量在程序执行中可被隐含地改变 |
11.常量和宏
define是一个预处理指令，有两种用途：
1.定义标识符常量
#include<stdio.h>
#define RAPPER/*标识符*/ "说唱歌手"/*常量*/
int main()
{
printf("%s", RAPPER);
}
2.定义宏
#include<stdio.h>
#define SUM(x,y)/*宏名（参数表）*/x+y/*字符串*/
int main()
{
printf("3+7=%d", SUM(3,7));
}
12.初识指针
指针就是内存地址，指针变量是用来存放内存地址的变量。
指针变量声明的一般形式为：type *var_name;//type是指针类型 var_name是指针变量的名称 *是指定一个变量为指针
使用指针时会频繁进行以下几个操作：定义一个指针变量、把变量地址赋值给指针、访问指针变量中可用地址的值。这些是通过使用一元运算符 * 来返回位于操作数所指定地址的变量的值。下面的实例涉及到了这些操作：
#include <stdio.h>
int main()
{
int var = 20; //实际变量的声明
int *ip; //指针变量的声明
ip = &var; //将 var 的地址存储在指针变量中，&用于访问地址
printf("var 变量的地址: %p\n", &var);//打印出变量var的地址
printf("ip 变量存储的地址: %p\n", ip);//打印出在指针变量中存储的地址
printf("*ip 变量的值: %d\n", *ip); //利用存储的地址使用指针访问值
return 0;
}
13.初识结构体
C 数组允许定义可存储相同类型数据项的变量，结构是 C 编程中另一种用户自定义的可用的数据类型，它允许您存储不同类型的数据项。
为了定义结构，您必须使用 struct 语句。struct 语句定义了一个包含多个成员的新的数据类型，struct 语句的格式如下：
struct tag {
member-list
member-list
member-list
...
} variable-list ;
tag 是结构体标签。
member-list 是标准的变量定义，比如 int i; 或者 float f，或者其他有效的变量定义。
variable-list 结构变量，定义在结构的末尾，最后一个分号之前，您可以指定一个或多个结构变量。
下面是声明 Book 结构的方式：
struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
} book;
在一般情况下，tag、member-list、variable-list 这 3 部分至少要出现 2 个。以下为实例：
//此声明声明了拥有3个成员的结构体，分别为整型的a，字符型的b和双精度的c
//同时又声明了结构体变量s1
//这个结构体并没有标明其标签
struct
{
int a;
char b;
double c;
} s1;
//此声明声明了拥有3个成员的结构体，分别为整型的a，字符型的b和双精度的c
//结构体的标签被命名为SIMPLE,没有声明变量
struct SIMPLE
{
int a;
char b;
double c;
};
//用SIMPLE标签的结构体，另外声明了变量t1、t2、t3
struct SIMPLE t1, t2[20], *t3;
//也可以用typedef创建新类型
typedef struct
{
int a;
char b;
double c;
} Simple2;
//现在可以用Simple2作为类型声明新的结构体变量
Simple2 u1, u2[20], *u3;
结构体的初始化：
#include <stdio.h>
struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
} book = {"C 语言", "RUNOOB", "编程语言", 123456};//指定变量初始值
int main()
{
printf("title : %s\nauthor: %s\nsubject: %s\nbook_id: %d\n", book.title, book.author, book.subject, book.book_id);
}
为了访问结构的成员，我们使用成员访问运算符（.）：
#include <stdio.h>
int main()
{
int var = 20; //实际变量的声明
int *ip; //指针变量的声明
ip = &var; //将 var 的地址存储在指针变量中，&用于访问地址
printf("var 变量的地址: %p\n", &var);//打印出变量var的地址
printf("ip 变量存储的地址: %p\n", ip);//打印出在指针变量中存储的地址
printf("*ip 变量的值: %d\n", *ip); //利用存储的地址使用指针访问值
return 0;
}
#include <stdio.h>
struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
};
int main()
{
struct Books Book1 = {"c语言","Nuha Ali" ,"C Programming Tutorial" ,6495407 }; /* 声明 Book1，类型为 Books并赋值 */
struct Books Book2= { "信息安全","张三" ,"科技" ,6789457 }; /* 声明 Book2，类型为 Books并赋值 */
puts("--Book1信息如下--");
printf("Book1 title : %s\n", Book1.title);
printf("Book1 author : %s\n", Book1.author);
printf("Book1 subject : %s\n", Book1.subject);
printf("Book1 book_id : %d\n\n", Book1.book_id);
puts("--Book2信息如下--");
printf("Book2 title : %s\n", Book2.title);
printf("Book2 author : %s\n", Book2.author);
printf("Book2 subject : %s\n", Book2.subject);
printf("Book2 book_id : %d\n", Book2.book_id);
return 0;
}
定义指向结构的指针，方式与定义指向其他类型变量的指针相似，如下所示：
#include <stdio.h>
struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
};
int main()
{
struct Books Book1 = {"c语言","Nuha Ali" ,"C Programming Tutorial" ,6495407 }; /* 声明 Book1，类型为 Books并赋值 */
struct Books Book2= { "信息安全","张三" ,"科技" ,6789457 }; /* 声明 Book2，类型为 Books并赋值 */
puts("--Book1信息如下--");
printf("Book1 title : %s\n", Book1.title);
printf("Book1 author : %s\n", Book1.author);
printf("Book1 subject : %s\n", Book1.subject);
printf("Book1 book_id : %d\n\n", Book1.book_id);
puts("--Book2信息如下--");
printf("Book2 title : %s\n", Book2.title);
printf("Book2 author : %s\n", Book2.author);
printf("Book2 subject : %s\n", Book2.subject);
printf("Book2 book_id : %d\n\n", Book2.book_id);
/*以下代码是指针在结构体中的运用*/
puts("----------------运用指针----------------");
struct Books* b1 = &Book1;
struct Books* b2 = &Book2;
puts("--Book1信息如下--");
printf("Book1 title : %s\n", b1->title);//结构体指针->成员变量名
printf("Book1 author : %s\n", b1->author);
printf("Book1 subject : %s\n", b1->subject);
printf("Book1 book_id : %d\n\n", b1->book_id);
puts("--Book2信息如下--");
printf("Book2 title : %s\n", b2->title);
printf("Book2 author : %s\n", b2->author);
printf("Book2 subject : %s\n", b2->subject);
printf("Book2 book_id : %d\n", b2->book_id);
return 0;
}
若想详细了解C语言请点击菜鸟教程
作者：linyjbaby https://www.bilibili.com/read/cv13257756 出处：bilibili ↩︎
1273
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
