C语言的全局基础认识《大致了解全部》

打开我们的编译器，创立好工程，那么就开始我们进入C语言全局大致的认识，
本章目标：
基本了解C语言的基础知识，对C语言有一个大概的认识。
数据类型
变量、常量
字符串+转义字符+注释
选择语句
循环语句
函数
数组
操作符
常见关键字
define 定义常量和宏
指针
结构体

第一个C语言程序;你知道是什么？

#include <stdio.h>
int main()
{
printf("hello bit\n");
return 0;
}

当你输入这一段小代码的时候，预处理-》编译-》-》汇编-》链接之后，生成的程序，我相信，你的心里一定会很开心，程序在你的手里编译，开始通过了，那么我们就开始正式，认识一下C语言。

就像我们学习汉字的时候，我们先学拼音，在学单个的字，然后在学习词语，在学习句子，这样一步一步的走过的，所以，我们就先学习一下C语言的基础，先看一下它的
第一点：《数据类型》

char //字符数据类型
short //短整型
int //整形
long //长整型
long long //更长的整形
float //单精度浮点数
double //双精度浮点数

这些都是我们常用的C语言数据类型，那么他们的大小又是多少？又是怎么样测试的呢？请看下面的一段代码：

int main()
{
    printf("%d\n",sizeof(int));    
    printf("%d\n",sizeof(char));
    printf("%d\n",sizeof(double));
    printf("%d\n",sizeof(long));
    printf("%d\n",sizeof(long double));
    printf("%d\n",sizeof(float));
    printf("%d\n",sizeof(short));
	return 0;
}

输出的结果是下面的图片，一一对应，感兴趣的同学，也可以测试一下：

这样就可以计算它们的大小，注意单位是：字节 当然在不同的编译器情况下面，一个整形 int 的的大小不同，在vs上面是2个字节。

第二点：常量和变量

变量

生活中的有些值是不变的（比如：圆周率，性别（？），身份证号码，血型等等），有些值是可变的（比如：年龄，体重，薪资）。
不变的值，C语言中用常量的概念来表示，变得值C语言中用变量来表示。
下面是变量的分类：局部变量和全局变量

#include <stdio.h>
int global = 2019;//全局变量
int main()
{
int local = 2018;//局部变量
//下面定义的global会不会有问题？
int global = 2020;//局部变量
printf("global = %d\n", global);
return 0;
}

打印这一段代码，结果是 global = 2020，说明上面顶一顶全局变量并不会影响下面的局部变量。当局部变量与全局变量重名的时候，局部变量优先使用

变量的使用，下面一段代码

int main()
{
	int a = 0;    //也可以自己直接写比如 int a = 10；等都可以
	int b = 0;
	int sum =0;
	scanf("%d%d",&a,&b);
     sum = a + b;
    printf("sum= %d\n",sum);
   return 0;
}

首先：我们先说一下,scanf，printf，必须在头文件《stdio.h》，才能使用，scanf有输入的功能，就是把你想输入的值可以任意改变，或者也可以直接定义成常量，printf就是想让你写的函数打印出来，如果不写的话，就看不到就像上面的黑框框，最后，当我输入a = 2,b =2的时候 输出结果：sum = 4。

变量的作用域和生命周期

作用域
作用域（scope），程序设计概念，通常来说，一段程序代码中所用到的名字并不总是有效/可用的，而限定
这个名字的可用性的代码范围就是这个名字的作用域。

局部变量的作用域是变量所在的局部范围。
全局变量的作用域是整个工程。

生命周期
变量的生命周期指的是变量的创建到变量的销毁之间的一个时间段

局部变量的生命周期是：进入作用域生命周期开始，出作用域生命周期结束。
全局变量的生命周期是：整个程序的生命周期

常量

C语言中的常量和变量的定义的形式有所差异。
C语言中的常量分为以下以下几种：
字面常量
const 修饰的常变量
#define 定义的标识符常量
枚举常量

下面看一段代码，了解一下这几种常量，后面我们还会仔细讲述这些：

#include <stdio.h>
enum Sex
{
           MALE,//枚举常量
           FEMALE,
           SECRET
};
 #define MAX 100 //#define的标识符常量
int main()
{
             3.14;//字面常量
            1000;//字面常量
           const float pai = 3.14f; //const 修饰的常量
            pai = 5.14;//ok?
            return 0;
}

这就是这几种常量在定义的时候，我们需要注意到这几种常量该如何定义，该怎么样去用使用。

第三点：字符串+转义字符+注释

1.字符串

"hello word.\0" ;
这种由双引号（Double Quote）引起来的一串字符称为字符串字面值（String Literal），或者简称字符串。
注：字符串的结束标志是一个\0 的转义字符。在计算字符串长度的时候\0 是结束标志，不算作字符串内容。

2.转义字符

int main()
{
printf(“test:\code\test.c\n”);
return 0;
}

打印出的代码会不会是上面你写的呢？答案当然是：不是这个答案。看下面的答案.

为什么会出现这种情况呢？那当然是因为，在C语言中存在在转义字符的存在，把一些转会成别的意思。看下面的图片

这些就是在C语言中，常用的一些转义字，希望大家没事可以看一看，记一记。
学习了之后，给大家出一个这样的问题，
//问题1：在屏幕上打印一个单引号’，怎么做？
//问题2：在屏幕上打印一个字符串，字符串的内容是一个双引号“，怎么做？
感兴趣的同学可以在自己的编译器上面写一写，

3.注释

1. 代码中有不需要的代码可以直接删除，也可以注释掉
2. 代码中有些代码比较难懂，可以加一下注释文字

那么有什么好的办法呢？

/*int main()
{
	printf("test:\code\test.c\n");
	return 0;
}*/

//int main()
//{
//	printf("test:\code\test.c\n");
 // return 0;
//}

同样的两段代码，不一样的注释方法：

上面的是在学C语言时候，常用的方法，
第二种是在学c++之后常用的注释方法。

第四 选择语句（if—else）

比如：你只有两种选择，要么好好敲代码，要么回家种地，就可以用选择语句；

 #include <stdio.h>
int main()
{
           int coding = 0;
           printf("你会去敲代码吗？（选择1 or 0）:>");
           scanf("%d", &coding);
         if(coding == 1)
           {
              prinf("坚持，你会有好offer\n");
           }
         else
          {
             printf("放弃，回家种地\n");
           }
        return 0;
} 

第五种 循环语句（while&for）
//while语句的例子

 #include <stdio.h>
    int main()
    {
           printf("好好学习\n");
          int line = 0；
          while(line < 20000)
          {
                  line++;
                  printf("认真写代码\n");
          }
          if(line > 20000)
          {
          printf("买房子，娶媳妇\n");
         }
         return 0;
   }

这就是一个循环语句，当条件，不满足的时候，就可以一直在里面循环走，一直到判断条件结束。

第六点 函数

int main()
    {
    	int a = 0;   
    	int b = 0;
    	int sum =0;
    	scanf("%d%d",&a,&b);
         sum = a + b;
        printf("sum= %d\n",sum);
       return 0;
    }

把上面的代码，可以下成下面的函数。

int  Add(int a ,int b)
  {
       int sum2 = a + b;
       return sum2;
  }
   int main()
    {
    	int a = 0;   
    	int b = 0;
    	int sum =0;
    	scanf("%d%d",&a,&b);
         sum =Add(a,b);
        printf("sum= %d\n",sum);
       return 0;
    }

这样就可以写一个简单函数，函数的特点就是**：简化代码，代码复用。**

第七 数组

开始学习的时候，我们都想要知道，要想存1-10的数字怎么办？

那么就可以用我们的数组 array[10] = {1,2,3,4,5,6,7,8,9,10};
那怎么样打印出来呢？看下面一段代码;

#include <stdio.h>
int main()
{
        int i = 0;
       int arr[10] = {1,2,3,4,5,6,7,8,9,10};
      for(i=0; i<10; i++)
       {
            printf("%d ", arr[i]);
       }
     printf("\n");
     return 0;
}   

这样就可以了，在后面的博客中，我会详细说明，数组的使用。

第八 操作符

简单介绍：后面详细使用。以图片为主。




先大概了解一下这些运算符名称，使用方法，在以后会介绍；

第九 关键字

常用关键字

其中，我们主要学的有：

一。typedef 关键字

typedef 顾名思义是 类型定义，这里应该是类型的重命名。

typedef unsigned int uint_32;
int main()
{
         //观察num1和num2,这两个变量的类型是一样的
         unsigned int num1 = 0;
         uint_32 num2 = 0;
          return 0;
}

由此可见，在定义数据类型使，不仅仅是在函数内部定义，也可以在函数外部定义，用类型的重定义。

二。static 关键字

在C语言中：
static是用来修饰变量和函数的

1. 修饰局部变量
2. 修饰全局变量
3. 修饰函数

1.修饰局部变量

//代码1
#include <stdio.h>
void test()
{
           int i = 0;
           i++;
           printf("%d ", i);
}
int main()
{
           for(i=0; i<10; i++)
           {
                 test();
            }
return 0;
}
//代码2
#include <stdio.h>
void test()
{
          static int i = 0;
          i++;
         printf("%d ", i);
}
  int main()
{
           for(i=0; i<10; i++)
           {
                 test();
            }
          return 0;
}

对比代码1和代码2的效果理解static修饰局部变量的意义。
结论：
static修饰局部变量改变了变量的生命周期，让静态局部变量出了作用域依然存在，到程序结束，生命周期才结束。

2.修饰全局变量

  //代码1
//add.c
 int g_val = 2018;
//test.c
int main()
{
     printf("%d\n", g_val);
    return 0;
}
//代码2
//add.c
static int g_val = 2018;
//test.c
int main()
{
    printf("%d\n", g_val);
   return 0;
}

代码1正常，代码2在编译的时候会出现连接性错误。
结论：
一个全局变量被static修饰，使得这个全局变量只能在本源文件内使用，不能在其他源文件内使用。

3.修饰函数

//代码1
//add.c
int Add(int x, int y)
{
          return c+y;
}
//test.c
int main()
{
           printf("%d\n", Add(2, 3));
          return 0;
}
//代码2
//add.c
static int Add(int x, int y)
{
          return c+y;
}
//test.c
int main()
{
            printf("%d\n", Add(2, 3));
             return 0;
}

代码1正常，代码2在编译的时候会出现连接性错误.
结论：
一个函数被static修饰，使得这个函数只能在本源文件内使用，不能在其他源文件内使用。

三。#define 定义常量和宏

//define定义标识符常量
#define MAX 1000
//define定义宏

#define ADD(x, y) ((x)+(y)) //用宏定义的add函数;

#include <stdio.h>
int main()
{
          int sum = ADD(2, 3);
          printf("sum = %d\n", sum);
            sum = 10*ADD(2, 3);
         printf("sum = %d\n", sum);
            return 0;
}

第十一 指针

内存

内存是电脑上特别重要的存储器，计算机中所有程序的运行都是在内存中进行的 。
所以为了有效的使用内存，就把内存划分成一个个小的内存单元，每个内存单元的大小是1个字节。
为了能够有效的访问到内存的每个单元，就给内存单元进行了编号，这些编号被称为该内存单元的地址。

先看下面一段代码;

#include <stdio.h>
int main()
{
    int num = 10;
    int *p = &num;    //取num的地址给一个指针变量
    *p = 20;
    printf("%d",num);
    return 0;
}

答案是多少？是10还是20？ 答案是;20。为什么呢？
因为 我们取num的地址，那地址又要如何存储？这时候我们想要一个指针指向他存在的地址，如果我们找到他的地址，那么不是就找到他的里面的值了吗？

由此，我们可以照猫画虎，模仿写下面一段代码：

#include <stdio.h>
int main()
{
      char ch = 'w';
      char* pc = &ch;
      *pc = 'q';
      printf("%c\n", ch);
      return 0;
 } 

那指针又是多大呢？会不会和上面的类型大小有关你？

#include <stdio.h>
int main()
{
printf("%d\n", sizeof(char *));
printf("%d\n", sizeof(short *));
printf("%d\n", sizeof(int *));
printf("%d\n", sizeof(double *));
return 0;
}

经过我的测试;它们与类型的大小无关，只要是指针，它就是 4 个字节；

当然：指针大小在32位平台是4个字节，64位平台是8个字节。

第十二 结构体

结构体是C语言中特别重要的知识点，结构体使得C语言有能力描述复杂类型。

比如描述学生，学生包含： 名字+年龄+性别+学号这几项信息。

这里只能使用结构体来描述了。

struct stu
{
     char name[20];//名字
     int age; //年龄
     char id[15]; //学号
};

int main()
{
	struct stu s = {"张三", 20 , "20180101"};
	printf("name = %s age = %d id = %s\n", s.name, s.age, s.id);
    return 0;
}

这样就可以实现一个学生信息的获取。

下面就是我们要一个一个开始详细学习了，如果那里有什么问题，希望大神能够在下面说两句，嘿嘿。