C语言-第三天!

关键字(32个)

1.​​auto​​​代码块内部定义的变量是局部变量,局部变量是用​​auto​​修饰的,一般都会省略

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
  for (int i=0;i<10;i++){
    printf("i=%d\n",i);
    if(1){
      auto int j = 0;//只限于局部变量。所以用auto修饰不是必要的，可以省略。
      printf("before:j=%d\n",j);
      j += 1;
      printf("after : j=%d\n",j);
    }
  }
  system("pause");
  return 0;
}

//result
i=0
before:j=0
after : j=1
i=1
before:j=0
after : j=1
i=2
before:j=0
after : j=1
i=3
before:j=0
after : j=1
i=4
before:j=0
after : j=1
i=5
before:j=0
after : j=1
i=6
before:j=0
after : j=1
i=7
before:j=0
after : j=1
i=8
before:j=0
after : j=1
i=9
before:j=0
after : j=1

2.​​register​​

越往上,离CPU越近,效率越高,价格更贵.相反最下面∏层越远,越低,越便宜.

register数量有限,一个程序一般用一两个.

哪些变量可以用​​register​​修饰

• 局部(全局会导致CPU寄存器被长时间占用)
• 不会被写入(写入就需要写回内存,后续还要读取检测,register没有意义)
• 高频被读取(提高效率)
• 不能被大量使用,寄存器有限

​​register​​修饰的变量不能取地址,寄存器没有地址的概念,地址是在内存中相关.

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>
int main() {
  register int pig = 0;
  printf("pig=%d\n", &pig);
  return 0;
}
//取地址就会报错
error C2103 寄存器变量上的"&"

3.​​static​​

修饰全局变量

对于全局变量来说，定义了一个全局之后，就可以通过使用​​extern​​声明不在本文件内部的全局变量来进行使用。所以全局变量是可以跨文件被访问的。而​​static​​修饰的全局变量只能够在本文件内部被使用。

修饰局部变量

对于局部变量来说，其生命周期是在定义的代码块内部。但是如果用static修饰局部变量。其生命周期就会变成全局变量的生命周期。但是要注意，虽然其生命周期发生改变，但是其作用域却不发生改变。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

void function1() {
  int i = 0;
  i++;
  printf("no static :i=%d\n", i);
}

void function2() {
  static int i = 0;
  i++;
  printf("has static : i=%d\n", i);
}

int main() {
  for (int i = 0; i < 10; i++)
  {
    function1();
    function2();
  }
  system("pause");
  return 0;
}

//result
no static :i=1
has static : i=1
no static :i=1
has static : i=2
no static :i=1
has static : i=3
no static :i=1
has static : i=4
no static :i=1
has static : i=5
no static :i=1
has static : i=6
no static :i=1
has static : i=7
no static :i=1
has static : i=8
no static :i=1
has static : i=9
no static :i=1
has static : i=10

function1函数中的i是一个局部变量，函数结束就会被销毁。而下一次调用又重新初始化，所以每一次的结果都是一样的。

而function2函数中的i是一个由​​static​​修饰的局部变量，其生命周期变为全局变量的生命周期。所以函数结束也不会被销毁。才会是我们看到的递增的打印。

同时，被static修饰的全局变量和局部变量都会存放在内存中的静态区。

修饰函数

没有被​​static​​修饰的函数是可以在被别的文件调用的。但是一但加了static修饰，就只能够在本文件内部使用。这个功能常用来隐藏一些不想被其他人看到的函数细节。

4.​​sizeof​​​

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>
int main()
{
  printf("%d\n", sizeof(char));//字符类型1字节
  printf("%d\n", sizeof(long));//长整型4字节
  printf("%d\n", sizeof(int));//整型4字节
  printf("%d\n", sizeof(float));//单精度浮点型4字节
  printf("%d\n", sizeof(double));//双精度浮点型8字节
  printf("%d\n", sizeof(short));//短整型2字节
  printf("%d\n", sizeof(long long));// 长长整型8字节
  return 0;
}

​​sizeof​​可以求出对应类型在内存开辟空间的大小.注意:​​sizeof​​可不是函数,也不是宏,他是关键字丶操作符.

5.​​signed​​​丶​​unsigned​​

​​signed​​表示有符号数,最高位为符号位表示数据的正负.

​​unsigned​​表示无符号数,则没有符号位.

默认情况下整型变量都是有符号数，即​​signed​​丶​​int​​。

6.​​if​​​丶​​else​​

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

//多分支
if(表达式1)
  语句1;
else if(表达式2)
  语句2;
else
  语句3;

//嵌套
if(表达式1){
  语句1;
  if(表达式x){
    语句x;
  }else{
    语句y;
  }
}else if(表达式2){
  语句2;
}else {
  语句3;
}
//else总是与离它最近的未被匹配的if相匹配。

7.​​switch​​​丶​​case​​​丶​​break​​​丶​​default​​

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

int main() {
  int day = 8;
  switch (day)//switch括号内表达式应该是整形表达式或者一个整型值
  {
  //se则是对应的整型表达式的值或者对应的整型值，根据表达式的值转到对应的case语句。
  case 1 :
    printf("星期一\n");
    break;//break是用来跳出switch语句。记得在每个case语句后都加上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是为了处理case语句中没有的特殊情况。
  default:
    printf("木有!\n");
    break;
  }
  system("pause");
  return 0;
}

//result
//木有!

8.​​do​​​丶​​while​​​丶​​for​​​丶​​continue​​

while循环、do-while循环和for循环。continue和break的不同之处在于其是跳过本次循环进入下一次循环，而break则是直接跳出循环。

9.​​goto​​(可以实现跳转，跳转到标签所在位置，但是不能跨代码块实现)

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

int main() {
  int i = 0;
START :
  printf("[%d]go to running ...\n", i);
  Sleep(1000);
  ++i;
  if (i < 10) {
    goto START;
  }
  printf("goto end ...\n");
  system("pause");
  {

  }
  return 0;
}
//result
[0]go to running ...
[1]go to running ...
[2]go to running ...
[3]go to running ...
[4]go to running ...
[5]go to running ...
[6]go to running ...
[7]go to running ...
[8]go to running ...
[9]go to running ...
goto end ...
//goto语句实现的循环。goto语句的功能很强大，但是应该慎用或者不用，因为它可能引发一些意想不到的错误。

10.​​void​​修饰函数返回值和函数参数

1 不需要参数时候，应该声明参数为void2 不需要返回值，应该声明为​void​类型

3 ​void*​指针默认不能++，原因是指向的​void​类型不知大小

4 如果返回需要任意类型指针，声明类型为​void*​

5 ​void​不能定义一个变量，因为大小未知

11.​​return​​终止一个函数，并返回其后面跟随的值

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

char* show() {
  char str[] = "hello bit";
  return str;
}
int main() {
  char* s = show();
  printf("%s\n", s);
  system("pause");
  return 0;
}

//result
//烫烫烫烫烫烫烫烫伫:

12.​​const​​

const修饰的变量，不可直接被修改。但是却可以通过指针的解引用来进行修改。

直接修改const修饰的变量：

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>

int main() {
  const int a = 10;
  int* p = &a;

  a = 11;
  return 0;
}
//erorr
//表达式必须是可修改的左值
//左值指定const对象

看一下通过指针间接修改：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

int main() {
  const int a = 10;
  int* p = &a;
  *p = 11;
  printf("%d\n", a);
  return 0;
}
//result
//11

​​const​​修饰指针变量分为几种情况：

• ​const int *p;​ // p 可变，p 指向的对象不可变
• ​int const *p;​ // p 可变，p 指向的对象不可变
• ​int *const p;​ // p 不可变，p 指向的对象可变
• ​const int *const p;​ //指针 p 和 p 指向的对象都不可变

同时​const​也可以修饰函数参数，​const​ 修饰符也可以修饰函数的返回值，返回值不可被改变。例如： ​const int Fun (void);​

也可以在另一连接文件中引用 ​const​ 只读变量：

​extern const int i;​ //正确的声明

​extern const int j=10;​ //错误！只读变量的值不能改变​

13.​​volatile​​可以忽略编译器优化，保持内存可见性

14.​​extern​​声明变量或者函数

​在本文件中给外来的变量或函数带了顶帽子，告诉本文件中所有代码，这些家伙不是本地人。提示编译器遇到此变量和函数时在其他模块中寻找其定义。

15.​​struct​​结构体

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>

//创建一个结构体类型
struct MyStruct
{
  char name[20];
  short price;
};

int main() {
//  //利用结构体类型创建一个该类型的结构体变量
  struct MyStruct b1 = { "c语言程序设计",55 };
  printf("书名 : %s\n", b1.name);
  printf("价格 : %d\n", b1.price);
  return 0;
}

//result
//书名 : c语言程序设计
//价格 : 55
//struct 是个神奇的关键字，它将一些相关联的数据打包成一个整体，方便使用。
在网络协议、通信控制、嵌入式系统、驱动开发等地方，我们经常要传送的不是简单的字节流（char 型数组），
而是多种数据组合起来的一个整体，其表现形式是一个结构体。

16.​​union​​联合体类型丶​​enum​​枚举类型

​​union​关键字和struct结构较为类似。但是，​union​内部成员共享一个存储空间同一时间只能储存其中一个数据成员，所有的数据成员具有相同的起始地址。同时，联合体总空间大小要能整除其任意成员的空间大小。

枚举类型的成员都是常量。是具有相关性的一些常量

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>

enum MyClocr
{
  RED,
  YELLOW,
  BLUE,
  WHITE,
  BLACK,
  GREEN,
};

int main() {
  enum MyClocr c = BLUE;
  return 0;
}

枚举与​​#define​​ 宏的区别：

1），​#define​ 宏常量是在预编译阶段进行简单替换。枚举常量则是在编译的时候确定其值。

2），一般在编译器里，可以调试枚举常量，但是不能调试宏常量。

3），枚举可以一次定义大量相关的常量，而​#define​ 宏一次只能定义一个。

17.​​typedef​​对类型进行重命名

1. 对一般类型进行重命名
2. 对结构体类型进行重命名
3. 对指针进行重命名
4. 对复杂结构进行重命名

​​​​​summarize​​

数据类型关键字(12个)

char : 声明字符型变量或函数

short:声明短整数变量或函数

int:声明整型变量或函数

long:声明长整型变量或函数

signed:声明有符号类型变量或函数

unsigned:声明无符号类型变量或函数

float:声明浮点型变量或函数

double:声明双精度浮点型变量或函数

struct:声明结构体变量或函数

union:声明共用体数据类型

enum:声明枚举类型

void:声明函数无返回值或无参数,声明无类型指针

​控制语句关键字(12个)

1. 循环控制(5个)

• ​for​:循环语句
• ​do​:循环语句的循环体
• ​while​:循环语句的循环条件
• ​break​:跳出当前循环
• ​continue​:结束当前循环,开始下一轮循环

​

2. 条件语句(3个)

• ​if​:条件语句
• ​else​:条件语句否定分支
• ​goto​:无条件跳转语句

​

3. 开关语句(3个)

• ​switch​:用于开关语句
• ​case​:开关语句分支
• ​default​:开关语句中的"其他分支"

​

4. 返回语句(1个)

​​return​​:函数返回语句(可以带参数,也可以不带)

存储类型关键字(5个)

注意：在C语言中存储类型关键字在使用时只能存在一个，不能共存

​auto​:声明自动变量,一般不使用

​extern​:声明变量是在其他文件中声明

​register​:声明寄存器变量

​static​:声明静态变量

​typedef​:用以给数据类型取别名(但是该关键字被分到存储关键字分类中，虽然看起来没什么相关性)

其他关键字(3个)

​const​:声明只读变量

​sizeof​:计算数据类型长度

​volatile​:说明变量在程序执行中可被隐含地改变

​