Misaki`s blog

学习是一种态度


  • 首页

  • 关于

  • 标签

  • 分类

  • 归档

【C语言】第三章-函数-1

发表于 2018-11-08 | 分类于 C语言初阶
字数统计: 1.4k

第三章 函数

第1节

  之前有简单介绍过函数,函数时C语言中不可缺少的一环,可以极大的将代码重复利用,提高我们的工作效率,也会使代码的可读性更高,使代码更加好看。因此这个章节我们将详细讲讲C语言中的函数。

函数的分类

库函数

  C语言基础库中有一些大佬们提前写好的函数放在文件中,一共我们进行更方便更快捷的使用,要使用对应的库函数只需要在文件开头引入对应的头文件即可,这可对我们程序编写带来了不少方便。例如#include <stdio.h>;#include <string.h>。

  有些同学或许会有疑问,那么库函数这么方便那么我们需不需要把库函数背下来呢?答案当然是不需要的。 因为常用的库函数我们用多了自然就熟记于心,然而不常用的库函数等我们需要用他们的时候再去查看官方文档即可,注意我这里是的是官方的文档,作为一个程序员要养成多看文档,及时看文档的习惯,相比把库函数背下来冒着有可能出错的风险我们不如到用的时候花一些时间去查看官方文档。在此我推荐一个网址:

      http://www.cplusplus.com/

  这个是C语言国际委员会官方编写的文档,也是最为准确的文档。也许有的同学更喜欢上MSDN查看文档,但是我要说的是,MSDN是微软发布的,和官方的比谁更有权威相信大家都能轻易评判出来的吧!

  对于C语言的基础库函数来说,我只能用一个字来形容:弱。 弱爆了的弱,而且C语言要是想要添加第三方库函数还及其麻烦,十分不辩解,相比下JAVA简直是一股清流啊。因此既然库函数无法满足我们的日常需求,就得要我们自己动手了,接下来我接着介绍自定义函数。

自定义函数

  自定义函数,正如其名,就是我们自己定义的函数,那么自定义函数需要遵循什么格式呢?

1
2
3
4
ret_type fun_name(para 1,* )
{
statement;//语句项
}

  没错以上这个就是自定义函数的模版了,返回值+函数名+(括号内参数)+大括号包含语句项的方式即可定义出一个供我们自己使用的函数。下面是一个判断数字大小的简单的例子。

1
2
3
4
int get_max(int x, int y)
{
return (x > y) ? x : y;
}

  在这个函数中我用了一个三目运算符,用来判断x, y中更大的值并且返回。于是这么一个比较大小的函数就被我定义出来了。

函数的参数

  在函数被调用的时候,函数中的参数会发生一些微妙的改变。在调用的时候传给函数的值,这样的参数我们称之为实参,而在函数定义时,后面括号的值我们则称之为形参,这里十分容易搞混,简单来说就是函数定义时的参数是形参,调用时的参数是实参。为什么我们要区分实参和形参呢?

  在函数调用过程中,我们将函数值传递进函数体中的时候,实际在函数体内形成了一份新的内存空间用来存储我们传递进去的值,因此形参在函数体内无论再怎么改变都不会影响调用函数时使用的实参。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>//添加头文件
#include <stdlib.h>
void exchange(int num1, int num2)
{
int t = num1;
num1 = num2;
num2 = t;
}
int main()//主函数,函数入口
{
int num1 = 1;
int num2 = 2;
exchange(num1, num2);
printf("num1 = %d,num2 = %d\n", num1, num2);
system("pause");
}

  运行以上的代码就会发现在函数内部我们明明已经交换num1和num2的值但是为什么在主函数中却没有任何改变呢?这就是我们所说的实参与形参以及函数副本传递参数的特性,大家只需要记住一句话即可:传给函数的形参不过是实参的一个副本。

  但是如果我们要是想在函数中对实参进行改变我们该怎么做呢?没错这里我们就要用到C语言的灵魂工具——指针。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>//添加头文件
#include <stdlib.h>
void exchange(int* num1, int* num2)
{
int t = *num1;
*num1 = *num2;
*num2 = t;
}
int main()//主函数,函数入口
{
int num1 = 1;
int num2 = 2;
exchange(&num1, &num2);
printf("num1 = %d,num2 = %d\n", num1, num2);
system("pause");
}

  我们将代码稍作修改,将函数类型转为指针型,大家就会发现,num1和num2的值已经交换了,这其中能够交换都得多亏我们使用指针找到了实参的地址,才能在函数内对其进行修改。

  关于函数的调用在下一节会有详细讲解。

【C语言】第二章-分支和循环语句-2

发表于 2018-11-05 | 分类于 C语言初阶
字数统计: 2k

第二章 分支和循环语句

第2节

  在本节中,我会用代码实现几个例子,来供大家深入了解和学习分支以及循环语句。

查找

  查找的含义就是在一个表中找出关键字与所给值相同的元素,如果找到了则返回下标,找不到则返回-1。

  这里先演示最为普通的查找,逐个查找,这是最为普通的算法思想。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>//添加头文件
#include <stdlib.h>
int main()//主函数,函数入口
{
int index = -1;
int num = 5;//假设我们要查找的元素是5
int arr[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
for (int i = 0; i < 10; i++)//通过循环遍历数组
{
if (arr[i] == num)
{
index = i;//找到目标元素将下标赋值给index
}
}
printf("%d\n", index);
system("pause");
}

  但是往往这种普通的遍历查找过为复杂,因此在有序的数组中,我们给出第二种更为简单的查找方式,叫做折半查找,这种查找只适用于在有序的素组中,利用减而制之的思想,每次只将目标区域最中心的元素与目标元素(mid)进行对比,如果目标元素大于mid,则将下界更为mid + 1,如果小于mid则将上界改为mid - 1.每一次循环之后都将目标查找区域缩小一半,直到找到目标元素,或是退出循环。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>//添加头文件
#include <stdlib.h>
/*
二分查找
参数:数组,目标区间,目标值
返回值:找到则返回元素下标,未找到返回-1
*/
int binFind(int* arr, int low, int high, int num)
{
int mid = 0;
int index = -1;
while (low <= high)
{
mid = (low + high) >> 1;
if (num > arr[mid])
{
low = low + 1;
}
else if (arr[mid] > num)
{
high = high - 1;
}
else
{
index = mid;
break;
}
}
return index;
}
int main()//主函数,函数入口
{
int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
printf("5在数组中的下表为:%d\n", binFind(arr, 0, 10, 5));
system("pause");
}

  很显然这是极为聪明的一种查找方法,极大的缩短了我们查找的时间,如果学过数据结构的同学自然可以明白其在算法分析上的美妙。这两个查找的示例也同时让我们感受到,一样的目标不一样的程序编写方法,会给我们的程序带来更快的便捷。除此之外,我们还有归并查找,抽样查找等等,对算法感兴趣的同学可以深入了解。

猜数字游戏

  我相信很多同学小时候可能都会玩过一个游戏,规则是由系统随机给出一个数,而我们则在目标区间内进行猜测,知道猜中系统给定的数字为止,那么今天我们就来实现这么一个小游戏。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>//添加头文件
#include <stdlib.h>
#include <windows.h>
#include <time.h>
int menu()//开始菜单
{
int choice;//选择
printf("1、开始游戏\n");
printf("0、退出\n");
printf("请选择:");
scanf_s("%d", &choice);
return choice;
}
void game()//游戏主逻辑
{
srand(time(0));//设置随机数种子(需要time.h头文件)
int riddle = 0;//用户猜的数字
int num = rand() % 101;//设置随机数,范围0 - 100(需要windows.h头文件)
while (1)
{
printf("请输出你猜的数字:");
scanf_s("%d", &riddle);
if (riddle < num)
{
printf("低了!\n");
}
else if (riddle > num)
{
printf("高了!\n");
}
else
{
break;
}
}
printf("恭喜你猜中了!\n");
}
void gameNumRiddle()//游戏总逻辑
{
while (1)
{
if (menu() == 1)//调用菜单函数
{
game();//游戏开始
}
else
return;//退出游戏
}
}
int main()//主函数,函数入口
{
gameNumRiddle();
system("pause");
}

  在这个游戏的实现中,我们引入了随机数rand()的使用方法,rand()是随机生成一个随机数列,范围是0~至少是65535,也就是说如果我们想让他生成某个范围内的数,我们就用这个随机数列%范围的上界,比如说我们此时需要0 ~ 100的数,我则使用给他% 101,那么问题来了,rand() % 100 + 1的范围是多少呢?我相信很多同学或许猜的出来,就是1 ~ 100。是的关于rand()还有很多灵活的用法,大家可以自行琢磨,但是在使用之前都千万不要忘记加上srand(time(NULL)),那么这句话又有什么含义呢?其实很简单,我们用rand()每次生成的随机数列都是固定的,就是说如果rand()的参数不变那么产生的随机数也不会变,大家在这个程序里可以试一下,我们如果去掉srand()我们每次执行程序所猜的第一个数字永远都只会是一个唯一值。并不会改变。为了改变随机数,我们就要不停地改变参数,但是有什么参数是会一直改变的?时间。因此我们srand()的参数给的正是时间这个参量。但是time()函数准确的来说并不是返回当前的时间。大家可以去参考这个函数的官方文档。

  The value returned generally represents the number of seconds since 00:00 hours, Jan 1, 1970 UTC (i.e., the current unix timestamp). Although libraries may use a different representation of time: Portable programs should not use the value returned by this function directly, but always rely on calls to other elements of the standard library to translate them to portable types (such as localtime, gmtime or difftime).(摘自官方文档)

  总的来说我们用srand()和rand()两个函数创造了随机数,并且赋值利用循环和分支语句让用户进行猜数字,整个程序的算法逻辑还是很简单的。

ATM系统

  最后是一个ATM的密码验证系统,密码输入正确则通过,三次错误退出系统。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>//添加头文件
#include <stdlib.h>
#include <string.h>
void atmPassword()//ATM登陆系统
{
char password[7] = "123456";//默认密码是“123456”
int turn = 0;
char enter[7];
while (turn < 3)//通过循环控制三次输入密码的机会
{
printf("请输入密码:");
scanf("%s", enter);
if (strcmp(enter, password) == 0)//字符串对比函数,如果前后相同返回0
{
break;
}
turn++;
printf("密码输入错误,还有%d次机会!\n", 3 - turn);
}
if (turn < 3)
{
printf("密码正确!\n");
}
else
{
printf("登陆失败!\n");
}
}
int main()//主函数,函数入口
{
atmPassword();
system("pause");
}

  这个程序的逻辑也十分简单,其中借用了一个string.h的库函数字符串对比函数int strcmp ( const char * str1, const char * str2 );,这个函数里有两个参数,分别是指向两个字符串的指针,如果两个字符串相同返回0,如果前面的字符串大于后面的返回大于0的数,反之返回小于0的数,具体比较方法大家也可以去看官方说明文档。

  今天举得几个例子一是为了熟悉分支与循环语句的使用,二是说明一个道理,只凭我们自己手写是无法快捷的写出代码的,因此我们有时需要借助C语言贫瘠的库函数,而使用库函数的具体方法大家一定要多去官方文档查看,看得久了对英文有帮助,同时也可以是我们对库函数的使用有更深的理解。

【C语言】第二章-分支和循环语句-1

发表于 2018-11-03 | 分类于 C语言初阶
字数统计: 2.1k

第二章 分支和循环语句

第1节

什么是语句

  在C语言中由一个;隔开的就是一个语句。例如printf("Misaki");;1 + 2;等等。

分支语句

if语句

  分支语句又叫选择结构,之前为大家演示过的if语句就是一个分支语句,在C语言逻辑中有着大量的使用范畴,是不可或缺的一部分。

  接下来为大家演示if的几种使用形式。

  形式一:

1
2
if (表达式)
语句;

  形式二:

1
2
3
4
if (表达式)
语句1;
else
语句2;

  形式三:

1
2
3
4
5
6
if (表达式)
语句1;
else if (表达式)
语句2;
else
语句三;

  简单解释一下,如果if括号中的表达式成立则执行语句1,如果不成立则进入else if表达式进行判断,如果还不成立直接执行else。而在C语言中可没有定义真假的变量,因此我们只好拿整数进行替代。在C语言中0表示真,非0表示假,进行条件判断的表达式的值都会用0和非0进行替代(但是一般多拿1来进行表示真的替代)。

  同时我建议在写if语句的时候下面条件执行的语句都能用{}来将他们括起来,表示这是一个代码块,这样我们不仅可以在代码块中写多个执行语句,也使程序更加可读。

1
2
3
4
5
6
7
8
9
10
11
12
13
if (表达式)
{
语句列表1;
}
else if (表达式)
{
语句列表2;
}
else
{
语句列表3;
}
system("pause");

  同时有一点需要强调,else永远与上面离它最近的if进行匹, 大家不要被缩进格式所迷惑。接下来进行几个实例演示。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>//添加头文件
#include <stdlib.h>
int main()//主函数,函数入口
{
int coding = 0;
printf("你会好好敲代码每天三小时,一次500行,不敲够不睡觉,像对待女朋友一样对待她么?\n");
scanf("%d", &coding);
if (coding == 1)
{
printf("加油坚持你会成功!\n");
}
else if(coding == 0)
{
printf("回家种田吧!\n");
}
else
{
printf("犹豫不决你在等什么?\n");
}
system("pause");
}

  我们的if语句就讲到这里,if语句使用十分简单却也十分灵活,但是大家千万注意尽量少的使用选择嵌套可以增强代码可读性。

switch语句

  switch语句也是一种分支语句,多用于多分支的情况。在某些情况下使用switch往往有着好的效果。

  比如说如果我们要根据用户输入的1-7来打印相应的星期,比如说用户输入1,我们则打印“星期一“”。在这种多分支的情况下,往往是switch语句的拿手好菜。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>//添加头文件
#include <stdlib.h>
int main()//主函数,函数入口
{
int choice = 0;
printf("请输入数字:");
scanf("%d", &choice);
switch (choice)
{
case 1:
printf("星期一\n");
break;
case 2:
printf("星期二\n");
break;
case 3:
printf("星期三\n");
break;
case 4:
printf("星期四\n");
break;
case 5:
printf("星期五\n");
break;
case 6:
printf("星期六\n");
break;
case 7:
printf("星期日\n");
break;
default:
break;
}
system("pause");
}

  switch的语法很简练,switch(整形表达式),下方的大括号中是一些case语句,case 整形常量表达式: 语句;当case后的常量==switch中的整形表达式的值时,case后的语句就会被执行,而switch语句一般都会配备一个default: 语句;这是在case语句没有被匹配上的时候就会执行default语句中的内容。大家还可以注意到每一个语句后都跟了个break;语句,这个break我们在循环中提到过一些,是跳出循环用的,不过在这里则是跳出switch用的,如果不加break语句,程序则会跟着匹配的case一直往下执行语句知道遇到break或者switch语句结束为止,因此break在这里不可或缺的,这也是switch一个很大的缺陷。

  switch虽然适用于多分支条件的情况下,但其本身有着极大的缺陷,并且实际上switch能实现的分支if语句也同样可以实现,有时候反倒会使我们的工作更加简单,因此我并不推荐在程序里经常使用switch,其中可读性低也是很重要的一部分原因。

循环语句

while循环

  while我们在初始C语言的章节已经涉猎,他是非常简单的一种循环语句,因为使用起来和if十分类似,不同点是if语句只判断一次条件,执行完则退出语句,但是while则是在每一轮循环结束后都要重新判断条件,如果条件依然成立则继续执行语句。

  打印0 - 9;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>//添加头文件
#include <stdlib.h>
int main()//主函数,函数入口
{
int i = 0;
while (i < 10)
{
printf("%d\t", i);
i += 1;
}
printf("\n");
system("pause");
}

  我相信大家对while的用法已经非常熟悉了,但是想要灵活使用我们还要在之后的学习中多加练习!

for循环

  for循环语句是一种相比while更为方便的循环语句,他更加便于书写,可读性更高。
  同样是输出0 - 9我们用for语句再写一遍。

1
2
3
4
5
6
7
8
9
10
11
12
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>//添加头文件
#include <stdlib.h>
int main()//主函数,函数入口
{
for (int i = 0; i < 10; i++)
{
printf("%d\t", i);
}
printf("\n");
system("pause");
}

  for语句语法更为精炼,将循环变量的更新条件的判断,循环变量的初始化融为一体。

1
2
3
4
for(语句1; 语句2; 语句3)
{
循环内容;
}

  for循环中语句1是循环变量的初始化,永远只执行一次,就是在循环刚开始的时候才执行;语句2则是循环条件的判断,只有在语句2满足的情况下才执行循环内容,语句2在每次循环开始前都要执行进行判断;语句3是循环变量的更新,在while语句中这一条往往是写在循环体里的,而for则将它提炼出来,这条语句在每一次循环结束后都会执行。因此for循环语句的执行顺序大概是:语句1->语句2(条件成立)->循环内容->语句3->语句2(条件成立)->循环内容->语句3->…->语句3->语句2(条件不成立)->循环结束。

  由此可见for循环语句的语法更为精炼快捷易于书写,且可读性更好,这里指的一提的是,for语句中括号里的三条语句都可省略不写,但是分号不可省略,而当语句2省略时则会变成死循环。

  for循环语句还有一些变种,我们之后学习中都会遇到,到时候大家需要小心留意。

do-while语句

  do-while语句是while语句的变种,他们十分相似,唯一不同点是前者执行完一次循环体后才会进行条件判断, 也就是说其至少执行一次。

1
2
3
4
5
6
7
8
9
10
11
12
13
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>//添加头文件
#include <stdlib.h>
int main()//主函数,函数入口
{
int i = 10;
do
{
printf("%d", i);
} while (i > 20);
printf("\n");
system("pause");
}

  从上面这个代码就可以看出明明while()中的条件不符合可依然执行了一次循环体,这就是while的独到之处。

  由于do-while语句使用条件有限,所以使用情况不多,这里不再深入讲解。

【C语言】第一章-初识C语言-3

发表于 2018-10-31 | 分类于 C语言初阶
字数统计: 3.3k

第一章 初识C语言

第3节

常见关键字

  C语言一共有32个关键字, 而关键字是我们写程序使用的关键,而最为重要的是,关键字是不被允许用作定义为变量名的。

1
2
3
4
auto break case char const continue default do double 
else enum extern float for goto if int long register
return short signed sizeof static struct switch typedef
union unsigned void volatile while

  接下来我们简单介绍几个常用的关键字。

  1、typedef关键字是类型定义关键字,这里应理解为烈性重命名。例:typedef unsigned int uint_32;在写过这一条语句后,我们之后使用uint_32定义变量的效果就和使用unsigned int定义变量的效果是一样的了,可以说是为我们书写代码省了不少功夫。

  2、static关键字常用的有三个用途:

  1)修饰局部变量,使局部变量的生命期延长至整个程序的存在时间。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>//添加头文件
#include <stdlib.h>
void test()//test函数
{
static int i = 0;//定义局部静态变量
i++;
printf("%d ", i);
}
int main()//主函数,函数入口
{
for (int i = 0; i < 10; i++)//利用循环调用十次函数
{
test();
}
printf("\n");
system("pause");
}

  大家可以在这段程序中尝试将test()函数中定义i变量前的static去掉,看看运行结果有什么不同。

  2)修饰全局变量:经static修饰过得全局变量将不能再在其它源文件中进行使用。

  3)修饰函数:经static修饰的函数也将不能在其它源文件中进行使用,编译会报错。

define定义常量和宏

  我们之前在讲解常量的时候已经讲解过使用define来定义常量,但是define的作用却不止定义常量这么简单。define的本质是文本替换, 因此我们也可以利用这一点进行宏的定义。

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>//添加头文件
#include <stdlib.h>
#define ADD(x, y) ((x) + (y))//宏定义
#define MAX 1000
int main()//主函数,函数入口
{
int sum = ADD(2, 3);//调用宏
printf("%d\t", sum);
sum = 10 * ADD(2, 3);
printf("%d\n", sum);
system("pause");
}

  根据上面这段代码大家可以看出利用define可以实现类似于函数定义的功能,但是define虽然功能强大,但也有着缺陷,就是他只能进行简单的文本替换,大家可以试着降ADD中定义的外层括号去掉,只保留内层括号,看看结果有什么变化?

指针

  或许小伙伴们在学习C语言之前,都对C语言有着或多或少的了解,但是我相信大家肯定都听说过C语言中最难的就是指针了,指针太难了。。。但是在这里我要告诉大家,指针并不难学,真正难的是C语言的内存管理,这才是让人头大的地方,而内存管理就与指针有着密切的关联。那么究竟什么才是指针呢?

  在提指针之前大家请先联想出这样一个场景,我们在上大学的时候应该都住过宿舍,而每个宿舍为了方便管理上面都有着一个门牌号(这样我们在卫生检查的时候宿管可以轻松的说出哪个宿舍不合格扣分等等),再假设我们一个宿舍里面住4个人,建立好这个场景后我们就可以开始讲解我们的计算机内存了。在计算机内存中,也有着类似的管理模式,我们的整个计算机内存就是一个大大的宿舍楼,这个宿舍楼有多大呢我们一会再讨论。在这个宿舍楼内部有着一个一个小的房间(存储空间),这么一个房间就是一个字节,然后为了方便管理这些房间,我们给每个房间都按照顺序标上了对应的号码,这些号码我们称为内存地址,而我们住在房间里面的人呢,刚才说过假设一个房间住4个人,那么我们一个房间中住的四个人就相当于是一个字节中对应的四个二进制位这么大的数据信息,因为1byte = 4 bit,一个字节 = 四位二进制数。相信这样大家对计算机内存应该有了一个大概的了解了。

  那么指针又是什么呢?指针不过是一种数据类型,不过它比较特殊,它里面存放的就是内存地址,也就是门牌号,是为了方便根据门牌号找到住在房间中的人而使用的,利用内存地址来查找数据是最为准确和快捷的方式,但是之后我们也会了解到在指针使用的便捷之余也存在着很多很多的危险。

  1、如果取出变量的地址?

  在这个问题中我们需要讲解一个之前我们已经遇到了的操作符——‘&’。之前已经提过这个操作符除了按位与的功能外还有着取地址的功能,或许之前大家不了解,但是在C语言中不得不说它的用途主要就是用于取地址。

1
2
3
4
5
6
7
8
#include <stdio.h>//添加头文件
#include <stdlib.h>
int main()//主函数,函数入口
{
int num = 10;
printf("%p\n", &num);//打印num变量的地址
system("pause");
}

  上面这个程序主要功能就是定义一个变量并且打印出这个变量的内存地址。其中的%p是用来输出地址的占位符。通过运行结果大家可以发现,是一串十六进制数,其实内存的地址在内存中为了方便计数多是用十六进制进行表示的,因为四位二进制数的上限恰好等于一位十六进制数的上限。对变量进行取地址的操作也很简单,使用&变量名即可。

  2、指针的定义与初始化

1
2
3
4
5
6
7
8
9
#include <stdio.h>//添加头文件
#include <stdlib.h>
int main()//主函数,函数入口
{
int num = 10;
int* p;
p = &num;//int* p = &num;
system("pause");
}

  在这段代码中我首先定义了一个变量num使他初始化为10,之后定义了一个指针p,并随后将它的内容存储为num的内存地址,这样这个指针p也就被我们叫做指向了变量num。至于对指针的定义语法也很简单,我们只需要像定义普通变量一样定义即可,不同的是在定义时我们需要在数据类型后变量名前加一个*。在此我们一定要注意一点,在指针被定义后一定要尽快初始化,即使暂时不用它也应将它的值赋为NULL。 int* p = NULL;这一点十分重要,否则在之后我们的程序编写中将及其容易出现野指针来干扰我们的工作。(说多了都是泪)

  3、指针的使用

  指针的使用过于博大精深,这里先用最为简单的例子作为示范。

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>//添加头文件
#include <stdlib.h>
int main()//主函数,函数入口
{
int num = 10;
int* p = &num;
*p = 20;
printf("%d\n", num);
system("pause");
}

  以上这段代码主要是用指针p指向了事先定义好的一个一个变量,但是重点来了我们在*p = 20;中操控了指针对变量进行了重新赋值(*也是解引符,简单来说就是用来利用指针找到指针所指向的内存空间的操作符)。这是怎么做到的呢?其实就像我们之前介绍内存所说的那样,我们将宿舍的房间号存入指针中,利用指针找到指定的房间号,我们程序员就相当于是宿管,房间号都有了想让这个房间里面的人换几个还不是轻轻松松的事。因此利用指针找到指定的内存空间进行内存空间内数据的修改是指针的拿手好戏。也正因为高度的便捷性反倒给我们的程序带来了很多不安全的地方,如果指针管理不当出现野指针那么可能会出现意想不到的后果。因此使用请谨慎,管理请当心。
  同时,因为指针是一个数据类型,呢么他肯定也是在内存中会被分配空间进行数据储存的,那么指针占多少的内存空间呢?在32位系统下无论任何类型的指针都是只占用4个字节的内存空间。这点需要大家牢牢记住,在日后的指针深入学习中我们对指针也会有更深的了解和认识,最终也会明白,指针真的是C语言中的“屠龙刀”。

结构体

  说到结构体,就不得不提一提面向对象编程了,众所周知,C语言是一门古老的语言,因此古人设计C语言之处并没有考虑到要用它来制作很多大型的程序,他们也无法想象将来的程序会进化到什么程度。因此,C语言被设计的可以说是很难用于现在的大规模程序的编写,其中的较为主要的原因就是C语言是面向过程编程,在这种面向过程编程语言中编写大型程序十分不便于项目管理,因此在比较先进的编程语言的设计中,设计者普遍都是用了一种叫做面向对象编程的编程语言设计模式,这种面向对象的设计更易于大型项目的管理,更易于编写,像CPP,java,VB等等都是面向对象的编程语言。呢么在CPP中是怎么进行从面向过程到面向对象的跨越的呢?这要用到一个叫做类的板块,其实在C语言中我们就能找到类似的面向对象编程前身的东西,这个对象就是结构体。

  1、结构体的定义

  结构体,可以理解为是一种自定义类型。用户根据需要定义一些具有实际意义的变量类型。

1
2
3
4
5
6
7
struct Stu//自定义学生结构体
{
char name[1024];//名字
int age;//年龄
char sex[5];//性别
char id[15];//学号
};

  以上的这段代码就是利用struct关键字进行了一个结构体的定义,在结构体内部可以自定义成员变量,这些全部都是由程序员我们自己决定的,而这么一个自己定义的类型自然也可以由我们自己随意进行使用。

  2、结构体定义变量并进行初始化

  在结构体类型自定义完成后我们就要开始用这个类型定义变量并且使用这个变量了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>//添加头文件
#include <stdlib.h>
#include <string.h>
struct Stu//自定义学生结构体
{
char name[1024];//名字
int age;//年龄
char sex[5];//性别
char id[15];//学号
};
int main()//主函数,函数入口
{
//struct Stu s = { "Misaki", 20, "男", "20181031" };//可以用这种方法直接进行初始化
struct Stu s;
strcpy(s.name, "Misaki");
s.age = 20;
strcpy(s.sex, "男");
strcpy(s.id, "20181031");
printf("姓名:%s\n", s.name);
printf("年龄:%d\n", s.age);
printf("性别:%s\n", s.sex);
printf("学号:%s\n", s.id);
system("pause");
}

  以上这段代码我们就用自己所定义的结构体类型定义了一个变量,当然这里提供了两种初始化方式,用哪一种根据情况而定。在初始化之后我们又使用结构体进行了操作,输出了初始化好的变量内部的信息,相信可以看出来在这个地方我们使用结构体变量名.成员变量的方式就可以随意调用结构体里的变量了,十分方便快捷。

  关于结构体我们日后在大型程序开发中十分常用,这里只做初步介绍,之后深入学习中会有更详细的讲解。

【C语言】第一章-初识C语言-2

发表于 2018-10-29 | 分类于 C语言初阶
字数统计: 3.9k

第一章 初识C语言

第2节

字符串+转义字符+注释

  1、字符串:

  "hello Misaki.\n";

  诸如这样由双引号引起来的一串字符称为字符串字面值,或者简称字符串。

  值得一提的是,由于C语言过于古老,所以在C语言中是没有字符串类型的,不过好在CPP中有了字符串类型。在C语言中字符串是由一个字符数组构成的,但与字符数组不同的是,字符串会在数组的结尾添加上一个空字符‘\0’作为结尾的标识符,这是为了更加方便的确定字符串的结束,方便输出等操作。关于字符串的具体知识我们会在后期详细讲解。

  2、转义字符:

  如果我们要在屏幕上打印一个目录:

1
2
3
4
5
6
7
#include <stdio.h>//添加头文件
#include <stdlib.h>
int main()//主函数,函数入口
{
printf("C:\code\test.c\n");
ststem("pause");
}

  我们能顺利打印出这个目录么?大家可以主动尝试一下。
  经过尝试之后我们会发现这是不可能做到的,会发生一些很有意思的事情,其中的某些字符消失了反倒多出了很多的类似于空格的东西。我在这里我们就不得不提一下转义字符了。

  在C语言中为了显示一些特殊的文本效果,例如换行,制表符(Tab),’ \ ‘等等的包括某些特殊的会与代码产生歧义的字符,于是出现了一种较为特殊的字符,这种字符就是转义字符。因为这种字符并不是可以直接输出往往需要使用特殊的代码进行代替。以下举几个常用的转义字符以供参考。

  \' 表示字符常量'

  \" 表示字符常量"

  \\ 表示一个反斜杠

  \n 换行符

  \t 制表符tab

  在转义字符的帮助下我相信我们就可以很好的输出上面的呢个目录了。

1
2
3
4
5
6
7
#include <stdio.h>//添加头文件
#include <stdlib.h>
int main()//主函数,函数入口
{
printf("C:\\code\\test.c\n");
system("pause");
}

  3、注释:

  在用任何一门语言进行程序的编写时,注释都是必不可少的,因为我们的程序不光是需要给我们自己写完算结束,我们还需要让别人能一模了然,全部看懂,更需要让几个月后的我们自己也可以依然能够看懂,如果你写完一个程序几个月后你自己都不想再看第二遍或者是看不懂第二遍,那么这个程序的书写就是失败的,因此除了我们需要有整齐良好的代码书写风格还需要在适当的位置加上合适的注释。

  在C语言中有两种风格的注释,一种是单行注释(CPP风格注释):这种注释用双斜线‘//‘标注,本行双斜线后的内容编译器会默认按照注释进行处理。

  // 我要好好学习C语言!

  而另一种则是多行注释(C语言风格注释),这种注释用’/‘和’/‘进行标注,在编译器中默认从’/‘往后的所有内容全部按照注释处理,知道遇到下一个’/‘为止。

  /* 我要好好学习C语言 */

  再次强调,好的注释和代码风格是一个程序员必备的基础素养,只有做好这点才能在团队中更好的进行合作与沟通。

选择语句

  选择语句(分支语句)是C语言重要的语法之一,因为在程序中我们往往要面临多种选择,根据用户的行为选择程序的走向,此时就需要选择语句派上用场了。

  在C语言中有多种选择语句,而每种选择语句的使用灵活多变,在此我选用if选择语句作为例子,为大家简单介绍选择语句的用法与用途。剩下的我们之后会详细讲解。

  例:如果我们要表达以下这样一个逻辑:如果你会好好敲代码,那么你就会在大学毕业时拿到一个好offer,否则就只能回家种田。那么这么一个逻辑我们怎么使用代码表示呢?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>//添加头文件
#include <stdlib.h>
int main()//主函数,函数入口
{
int coding = 0;
printf("你会每天好好敲代码么?(1 or 0)");
scanf_s("%d", &coding);
if (coding == 1)//进行判断如果coding为1
{
printf("加油,你会成功!\n");
}
else//其他情况
{
printf("你完了,回家种田!\n");
}
system("pause");
}

  大家可以试着在自己的编译器上写这么一个小的程序,多运行几次,输出不同的选项,查看结果。不过值得一提的是,或许有的同学会有疑问,为什么if语句中的括号里用了一个’==’符号?而不是’=’?因为在C语言中对等于号进行了区分,分为了用于判断的双等号和用于赋值的单等号,在进行判断时我们只能使用双等号进行判断,如果改为单等号编译器虽然不会报错但有可能会使程序出现逻辑错误。

循环语句

   循环语句和选择语句一样,在C语言中有着举足轻重的地位,因为计算机最擅长做的事情就是不断的循环,因此在编写程序中,我们可以利用循环进行在日常生活中我们执行起来很麻烦或是繁琐的事情。

  C语言中循环语句依然有着很多的形式,很多的语法,在此我使用最简单的循环语句while循环语句作为示范。

  比如说我们要完成这样一件事,我们要不断不断的敲代码,直到代码行数从0加到2000为止,每循环一次我们就为我们的代码行数加上1,直到行数到达或者多于2000为止。(希望大家可以不要这样自己欺骗自己,这里只是举个例子- _ -)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>//添加头文件
#include <stdlib.h>
int main()//主函数,函数入口
{
int line = 0;
printf("今天要开始敲代码了!目前行数为%d\n", line);
while (line < 2000)//循环开始,满足条件循环继续
{
printf("目前代码行数%d,我要继续努力敲代码!\n", line);
line = line + 1;
}
printf("代码行数总算到%d啦!我成功啦!\n", line);
system("pause");
}

  瞬间计算机就将循环执行了2000次,运行后大家就可以看到自己的代码行数一下从0飙到了2000,但是在现实中敲代码还是一行一行脚踏实地连起,就像唐僧取经每一步都要脚踏实地,是没有任何捷径可以走的。

函数

  说到函数,这就是C语言中相当重要的概念之一了,因为程序就是由一个个函数构成的,当我们开始写C语言代码时我们首先要写的就是一个入口函数——main() 函数,而除了main函数外,C语言允许我们可以自己定义很多很多自己的函数并且可以适当的时候进行调用,可以说是函数给我们的代码编写带来了很多的便利。

  比如说我要将连个数进行相加,这个程序很简单,但是如果我们在程序中需要经常将两个数进行相加的话,每次相加我们都再单独写一遍代码或许显得程序略显复杂,而且缺失可读性,因此使用自定义函数取而代之就显得格外重要。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>//添加头文件
#include <stdlib.h>
int add(int a, int b)//自定义相加函数,两个int型参数,返回值也为int型
{
return a + b;
}
int main()//主函数,函数入口
{
int num1 = 0;
int num2 = 0;
printf("请输入两个操作数:");
scanf_s("%d%d", &num1, &num2);
printf("相加结果为:%d\n", add(num1, num2));//调用写好的add函数
system("pause");
}

  从这个例子大家就可以看出来函数的好处最明显的就是可以简化代码,简化书写,使代码看上去一目了然,尤其在之后我们写更为复杂的程序时程序的函数化就显得格外重要了。

数组

  在介绍数组之前首先引入一个问题,如果我们要定义连续的成批的同种变量,我们应该怎么定义?用普通定义变量的方式一个一个定义么?如果数目少一些我们或许还可以使用这种方式,但如果数目很多要定义1000个甚至10000个呢?那这种普通的定义方式或许究竟行不通了。因此我们需要引入一种特殊的数据类型——数组。

  所谓数组在内存上的表示不过是一段连续的内存空间,我们用这段连续的内存空间存储类型相同的不同元素,而借用数组的下标的方式来进行数组内每一元素的调用。而在后面的深入学习中大家会了解到,所谓数组不过是一个指针,被分配了一串连续的内存空间,而我们在调用每一个变量时也不过是在用指针解引的方式在使用指针所指向内存空间的值。

  1、数组定义:

  int arr[10] = {0,1,2,3,4,5,6,7,8,9};

  我们可以使用诸如以上这一行代码的方式定义一个任何类型的数组,我们也可以在定义后不直接对数组进行初始化,不过数组内部元素的值会和普通变量被定义后不进行初始化一样,是随机的,因此在定义数组后也同样建议立刻初始化,即使不立刻使用,我们也应将他们的值初始化为0;

  2、数组的使用:

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>//添加头文件
#include <stdlib.h>
int main()//主函数,函数入口
{
int i = 0;
int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };//定义数组并初始化
for (i = 0; i < 10; i++)//打印数组
{
printf("%d\t", arr[i]);
}
printf("\n");
system("pause");
}

  以上这段代码的意思是定义一个有十个整数空间大小的数组并在定义的同时进行初始化,随后利用for循环将他们打印出来,抛开for循环的语法不管,大家利用看到数组的操作可以说是是和循环都密切相关的。关于数组每一个元素的使用的方式有很多种,在这里首先介绍最简单的一种:即通过数组名+下标的方式进行引用,arr[i],其中中括号中括号中的整形变量就是我们成为下标的东西。 值得一提的是,大家从循环也能看的出来, 数组的下标使用是从0开始的,即数组中的第一个元素我们要想表示的话得写成:arr[0]。 因此在C语言的学习中我们要学会从0开始进行标号,因为数组中每个元素的下标都是数组中当前元素个数-1,第一个元素的下标为0,诸如此类。

  关于数组的使用和技巧我们还大有可讲,我们先保持兴趣,之后的内容放到日后再详细讲述。

操作符

  C语言的操作符有很多种,也分为不同的种类,在日后的学习中我们都会逐一接触到,这里我先逐一列出,简单讲述其功能。

  1、算术操作符:  + - * / %  加、减、乘、除、模

  这里是最常用的基本操作符,其中需要讲解的是’%’这个操作符,这个操作符或许大家会比较陌生,但是它的功能十分简单,简单来说就是前一个操作数 / 后一个操作数,取他们的余数,例如:5 % 4 = 1,但是’%’操作符两边的操作数必须要求是整型,否则会编译失败。

  2、移位操作符:  << >>  左移、右移

  移位操作符的具体用途就是将操作数转换为二进制形式,然后将整体位数左移或右移,比如说左移就是在末尾加一个0,右移则是减少一位。因此在此有一个技巧,左移操作符对于原操作数每左移一位操作数变为原来的两倍,右移则变为原来的二分之一。 例如:2 << 1 = 4、2 >> 1 = 1。

  3、位操作符:  & ^ | ~  按位与、按位异或、按位或、按位取反

  这几个操作符都是针对操作数的二进制进行操作,具体运算较为复杂,我们之后进行详细讲解。其中’&’操作符大家或许会比较懵,因为大家也许都知道我们在输入一个值想要将一个值赋给一个变量时我们往往需要’&’操作符进行取地址,没错这个操作符也是取地址操作符,但是它也是位操作符,这里就牵扯到了运算符重载的知识,在CPP中会有详细讲述。

  4、赋值操作符:  = += -= *= /= &= ^= |= >>= <<=

  这些赋值操作符虽然看起来多但是大都大同小异,第一个是最为简单的复赋值操作符。之后的我们以+=为例进行简单说明。

  a += b 和 a = a + b是完全等价的,这么一说大家或许就都明白了,后面的操作符也都是类似的效果。

  5、关系操作符  == >= <= > < !=

  对于关系操作符,我们常常用于分支语句的判断中,其中>=就是大于等于,<=就是小于等于,而==我们之前已经讲过就是用于判断的恒等号。

  6、逻辑操作符:  && || !  与、或、非
  这都是最为简单的判断操作符,在逻辑的表达上十分常用,我们之后会详细讲解。

  除去以上这些操作符外,我们还有一些操作符,例如[]下标引用操作符,()函数调用操作符,->结构成员操作符,? :三目操作符,,操作符等等。我们之后都会详细讲解。

【C语言】第一章-初识C语言-1

发表于 2018-10-27 | 分类于 C语言初阶
字数统计: 2.6k

写在前面

  本专题博客主要内容为本人在C语言学习过程中遇到的主要问题和C语言相关知识点的讲解,是系统性的技术学习博客,使用的环境为VS2017。本教程本着先浅后深的学习理念由浅至深进行学习,并且每一章都会附有代码及案例讲解。在学习过程中如果读者有相关问题请移步我的私人博客,或发送问题到我的邮箱或者QQ一起探讨!

第一章 初识C语言

第1节

为什么学习C语言

  C语言是一门通用计算机编程语言,广泛用于底层开发。C语言虽然并不是最完美的语言,但是可以说目前很多的高级编程语言的前身都是C语言,所以C语言绝对是开发学习中的第一门语言,他可以帮助你很好的理解计算机原理,理解计算机内存管理。而且同时C语言有着简介的语法,十分简单易上手,但是想要精通使用C语言还需要长期的学习和锻炼才能掌握。目前2011年12月8日,国际标准化组织(ISO)和国际电工委员会(IEC) 发布的 C11标准是C语言的第三个官方标准,也是C语言最新标准,在以前C语言版本基础上加上了很多新的语法,而本系列博客也会以C11标准进行C语言讲解。

第一个C语言项目

  1、接下来我会在VS2017的环境中展示第一个C语言项目。首先是进行项目创建。

  1)点击新建->项目

  2)在左侧边框栏选择VisualC++选择右侧边框栏的空项目

  3)右键点击源文件选择添加->点击新建项->添加

  这样既可创建好一个CPP源文件

  虽说我们写的是C语言但是创建CPP源文件照样是可以写C语言代码的,互不影响,如果你想创建一个C语言源文件在第三部点添加之前把文件名称后缀改为 .c文件既可!!

  2、在创建好源文件后我们就可以正式开始快乐的敲代码啦!

1
2
3
4
5
6
#include <stdio.h>//添加头文件
int main()//主函数,函数入口
{
printf("This is my world!!\n");//输出“This is my world!!”
return 0;//主函数返回值,可以忽略这一条语句
}

  上面这一段代码的主要作用就是实现在屏幕上打印一句话的功能。接下来我给大家注意讲解每一行代码的含义。

  第一行代码是引用了一个标准输入输出流的头文件<stdio.h>,这个可以说是写C语言代码必备的。可能有小伙伴会有疑问,这句话有什么用?其实写代码的过程中并不是所有代码都由我们自己写的,在编译器中会实现留有很多的代码都是由大佬们实现写好留下来的,而这些代码都会被封装为一个又一个的头文件,提供给开发者使用,这样会给开发者带来不小的便利,比如说我们下面printf()这个函数就是这个头文件所提供给我们的。

  第二行代码包括下面的一对大括号都被成为主函数。主函数是一个程序的入口函数,程序的启动和运行都会先从主函数开始,所以在一个程序中主函数是必不可少的。

  主函数里面的函数printf() 这个函数的主要功能是将括号里面的内容输出到屏幕上,在这个函数中大家可以看到目前有一个参数,是一个由双引号括起来的字符串(字符串的概念之后会学习),字符串里面的内容大家可以随意改动,输出自己想要的内容。

  还可以注意到还有一个语句return 0这句话是函数的返回值。主函数是可以有返回值的,但是这句话不写编译器也不会报错,之后学了函数的知识后大家会对返回值有更深的理解。

  在写完了以上这几行代码后就可以编译运行了,大家可以使用快捷键ctrl+f5进行编译和运行,或者点击调试里面的开始执行(不调试) 进行执行。

  在运行后大家可能会发现程序运行一闪而过,根本无法看到结果,这是因为程序运行太快了并且没有暂停所以程序结束了,所以之后我们将代码改成这个样子让他暂停下。

1
2
3
4
5
6
7
8
#include <stdio.h>//添加头文件
#include <stdlib.h>
int main()//主函数,函数入口
{
printf("This is my world!!\n");//输出“This is my world!!”
system("pause");//暂停语句
return 0;//主函数返回值,可以忽略这一条语句
}

  可以注意到我们在第6行加了个system语句,这个语句的作用就是让程序暂停运行。改完之后大家可以重新编译运行下,就可以看到运行的结果了。

数据类型

  1、为什么会有不同的数据类型?

  这个问题其实很简单,因为众所周知程序在运行时会将数据暂时存储在内存中以方便程序使用,但是在系统给程序分配内存空间是就会产生问题,为了解决这个问题我该分配多少内存给它呢?多了的话浪费资源,少了的话不够用,而且不同的数据不可能使用同一种方式存储(例如字符和整形以及浮点型的存储方式都有很大的区别),于是在编程语言设计之初,不同的数据类型就产生了。

  2、在C语言中常用的数据类型一共有7种,接下来统一给大家介绍,这在大家之后的编程中是必不可少的。

1
2
3
4
5
6
7
   char //字符型:1字节
short //短整型:2字节
int //整型:4字节
long //长整型:4字节
long long //更长整型:8字节
float //单精度浮点型:4字节
double //双精度浮点型:8字节

  每个不同的数据类型都有不同的所占空间大小,而数据在内存中都是以二进制形式进行存储的。举个例子,int型占4个字节,一个字节是8个bit,就是4 * 8 = 32 个二进制位,所能存储的数据大小(默认无符号)就是从0 ~ 2 ^ 32 - 1大概就是42亿,依次类推。要说明的是整形是存储整数的无法处理小数,而浮点型是专门处理小数的(自然也能处理整数),而字符型则是处理字符的。数据在内存中存储方式也随着数据类型的不同而不尽相同,其中整形的存储是根据补码进行存储,而字符型则是根据ASCII码进行换算然后进行存储。

  所谓ASCII码不过是将键盘上的每一个字符都根据序号进行排序,每一个字符都有着自己编号,而进行内存存储时与ASCII表进行比对,找到自己的编号,然后将字符型转换为整形数字然后再进行存储。

变量、常量

  1、所谓变量就是可以改变的量,而常量则是无法被改变的值。

  2、定义变量的方式也十分简单。

1
2
3
   int age = 10;
float weight = 45.5f;
char ch = 'w';

  大家可以看出来定义变量不过是数据类型(空格)变量名称即可定义。而定义一个变量后最立刻对它进行初始化赋值,否则变量会存储一个随机的值,这十分不便于变量管理。在定义浮点型变量时如果初始化内容后不加f则默认为双精度浮点型。

  3、变量的分类大致可以分为:局部变量和全局变量,每个变量都有着自己的作用域和生命周期。局部变量的作用域和生命周期都是大括号,全局变量的作用域和生命周期则是当前整个程序

  具体可以参考以下代码段:

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>//添加头文件
#include <stdlib.h>
int global = 2019;//全局变量
int main()//主函数,函数入口
{
int local = 2018;//局部变量
//下面定义的global不会有问题
int global = 2010;
printf("global = %d\n", global);
system("pause");
}

  值得一提的是全局变量在已经定义的前提下,定义相同变量名的局部变量不会报错,那么在局部变量的作用域内打印局部变量会出现什么结果呢?执行过大家肯定会看到,global = 2010。这是因为在局部变量作用域内局部变量会覆盖同名称的全局变量。

  4、常量则是不能被改变的量,在C语言中常量分为字面常量、const修饰的常变量、#dfine定义的标识符常量、枚举常量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>//添加头文件
#include <stdlib.h>
#define PIE 3.14
enum Sex//枚举常量
{
MALE,
FEMALE,
SECRET,
};
int main()//主函数,函数入口
{
3.14;//字面常量
1000;//字面常量
const float pai = 3.14f;//const修饰的常量
system("pause");
}

  关于常量如代码演示,其中较为特殊的是enum常量,枚举常量默认元素从0开始赋值,是快速定义连续常量的一种方式。#define所用到的宏定义只是单纯的文本替换,具体使用之后会详细讲解。

1…89
MisakiFx

MisakiFx

Hard working or giving up!!!

86 日志
10 分类
64 标签
GitHub E-Mail 网易云音乐 CSDN

© 2020 MisakiFx
我的网站的访客数:
|
主题 — NexT.Pisces v5.1.4
博客全站共273.4k字