C语言——基础语法

由于转义字符大多数是特殊的控制字符，部分无法直接在屏幕上显示出来，而是具有特殊效果，所以部分转义字符可能无法显示或显示乱码。

• 格式化规定字符

注意点：

• （1）可以在”%” 和字母之间插进”m”，m代表数字，表示输出格式占用m格。若m为正数则右对齐，若m为负数则左对齐。例如printf("%5d",a);表示输出场宽为5的十进制数，若a的数据位数不够5位则右对齐，多余5位以实际场宽为准。
• （2）可以在”%” 和字母之间插入”.n”，n代表数字n，表示输出数据强制保留n个小数点。例如printf("%.2f",a);表示保留2位小数。
• （3）可以在”%” 和字母之间插进”m.n”，m和n代表数字，表示输出格式占用m格，保留n位小数。若m为正数则右对齐，若m为负数则左对齐。例如: printf("%9.2f",a);表示输出场宽为9的浮点数，其中小数位为2，整数位为6，小数点占一位，若a的数据位数不够9位则右对齐，多余9位以实际占用场宽为准。
• （4）可以在字母前加小写字母l，表示输出的是长型数。例如: printf("%ld,a);表示输出long整数。printf("%f",a);表示输出float类型单精度浮点数（4字节）。printf("%lf",a);表示输出double类型双精度浮点数（8字节）。
• （5）可以在”%” 和字母之间插进”0m”，m代表数字，表示输出格式占用m格，a的数据位数不够m格，则空余部分用’0’字符填充。若m为正数则右对齐，若m为负数则左对齐。例如printf("%5d",a);表示输出场宽为5的十进制，若a的数据位数不够5位则右对齐，多余5位以实际场宽为准。

使用示例

#include int main(){char c;int a=1234;float f=3.141592653589;double x=0.12345678987654321;c='\x41'; //十进制65十六进制0x41ascii 'A'printf("a=%d\n", a); //结果输出十进制整数a=1234printf("a=%6d\n", a); //结果输出6位十进制数a= 1234printf("a=%06d\n", a);//结果输出6位十进制数a=001234printf("a=%2d\n", a); //a超过2位, 按实际值输出a=1234printf("x=%lf\n", x);//输出长浮点数x=0.123457printf("x=%18.16lf\n", x);//输出18位其中小数点后16位的长浮点数x=0.1234567898765432printf("c=%c\n", c);//输出字符c=Aprintf("c=%x\n", c);//输出字符的ASCII码值c=41return 0;}

scanf

scanf()函数是标准输入函数。它从标准输入设备（简谱）读取输入的信息。其调用格式为：scanf(格式化字符串, 地址表);格式化字符串包括以下三类不同的字符：

• 格式化说明符：格式化说明符与printf()函数中的格式说明符%d%f等基本相同。例如scanf("%d",&a);
• 空白字符：空白字符会使scanf()函数在读操作中略去输入中的一个或多个空白字符。例如scanf("%d %d",&a,&b);
• 非空白字符: 一个非空白字符会使scanf()函数在读入时剔除掉与这个非空白字符相同的字符。例如scanf("%d,%d",&a,&b);
• 地址表是需要读入的所有变量的地址,而不是变量本身，变量地址可以在变量名称前添加取址符’&‘取地址。这与printf()函数完全不同，要特别注意。各个变量的地址之间同’,’分开。
  例如scanf("%d,%d",&a,&b);

上例中的scanf()函数先读一个整型数, 然后把接着输入的逗号剔除掉, 最后读入另一个整型数。如果“,”这一特定字符没有找到, scanf()函数就终止。若参数之间的分隔符为空格, 则参数之间必须输入一个或多个空格。对于初学者来说，经常会将代码中%d,%d中的逗号写成英文逗号，然后键盘输入时候输入中文逗号，导致程序无法找到特定的英文逗号而出错。

注意：

• （1）对于字符串数组或字符串指针变量, 由于数组名和指针变量名本身就是地址, 因此使用scanf()函数时, 不需要在它们前面加上”&”操作符。例如

char c;scanf("%c",&c)//正确//scanf("%c",c)//错误，对于变量输入需要取地址char s[10];scanf("%s",s);//正确//scanf("%s",&s);//错误，数组名称本身就是地址，不需要再取地址

• （2）可以在格式化字符串中的“%”各格式化规定符之间加入一个整数, 表示任何读操作中的最大位数，可以类比printf中的场宽限制。例如

#include "stdio.h"int main(){int a,b;scanf("%3d %d",&a,&b);//变量a只接受前3位printf("a=%d b=%d",a,b);return 0;}

输入

123456789

请编程：简单加法计算器
参考例程

#include "stdio.h"int main(){double a,b;printf("请输入加法算式，例如 \"1+2=\"\n");scanf("%lf+%lf=",&a,&b);printf("%lf+%lf=%lf\n",a,b,a+b);return 0;}

输入

3.4+2.5=

注意输入两个数之间的分隔符必须与scanf中的格式保持一直，本程序中采用’+’分隔。

putchar()与getchar()

putchar()使用格式为

char c='A';putchar(c);

他的作用就是向标准输出设备输出一个字符，以回车键结束，其等价于printf("%c",c);

getchar()则是与putchar()相对应，putchar()为输出一个字符，getchar()为获得一个字符。getchar

char c='A';getchar(c);

使用例程

#include int main(){char c='A';//定义char类型变量c初始化为字符Aputchar(c);//屏幕显示（输出）字符putchar('\n');//输出换行c=getchar();//从键盘输入一个字符保存到cputchar(c);//输出字符putchar('\n');//输出换行return 0;}

键盘输入

B

运行结果可以看到，屏幕显示内容为 ‘A’、换行、‘B’、换行。

puts()与gets()

puts(s)与gets(s)可以类比标准输入输出：

char s[10]="hello";puts(s);//等价于printf("%s\n",s);gets(s);//等价于scanf("%s",s);//字符数组不用加&

注意`：

• puts(s);输出完字符串后会自动换行。
• gets(s);从缓冲区读取字符串直到遇到回车停止。但是scanf("%s",s);是从缓冲区读取字符串直到遇到回车或空格停止。

getch()

getch()与getchar()用法一样。区别在于getchar()读取字符时候，我们输入字符时，屏幕上会后相应的显示；而getch()读取字符则没有回显。当我们不需要屏幕回显时，比如贪吃蛇用awsd控制上下左右，每当我们按下一个键屏幕就显示相应字符显然不是我们想要的效果，这种时候就可以使用不带回显的输入。

getche()

同getchar()，只是该函数不论按下什么按键都直接获取相应字符，不以回车键结束。

C语言基本概念

从编译到运行

C语言程序从我们敲代码到运行有四个步骤：

• 1、预处理(Preprocessing)
• 2、编译(Compilation)
• 3、汇编(Assemble)
• 4、链接(Linking)

预处理

用于将所有的#include头文件以及宏定义替换成其真正的内容，预处理之后得到的仍然是文本文件，但文件体积会大很多。

编译

这里的编译不是指程序从源文件到二进制程序的全部过程，而是指将经过预处理之后的程序转换成特定汇编代码(assembly code)的过程。

汇编

汇编过程将上一步的汇编代码转换成机器码(machine code)，这一步产生的文件叫做目标文件，是二进制格式。

链接

链接过程将多个目标文以及所需的库文件(.so等)链接成最终的可执行文件(executable file)。

变量的本质

• 1、c中所有类型的数据存储在内存中，都是按照二进制格式存储的。所以内存中只知道有0和1，不知道是int的、还是float的还是其他类型。
• 2、int、char、short等属于整形，他们的存储方式（数转换成二进制往内存中放的方式）是相同的，只是内存格子大小不同（所以这几种整形就彼此叫二进制兼容格式）；而float和double的存储方式彼此不同，和整形更不同。
• 3、C语言中的数据类型的本质，就是决定了这个数在内存中怎么存储的问题，也就是决定了这个数如何转成二进制的问题。一定要记住的一点是内存只是存储1010的序列，而不管这些1010怎么解析。所以要求我们平时数据类型存取一致。

作用域与生命周期

作用域（scope）：限定一个变量的可用范围，以{}为界限，变量必须定义在作用域开始。

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

局部变量

定义在{}内部的变量称局部变量。局部变量的生命周期：进入作用域生命周期的开始，出作用域生命周期结束。例如以下程序，a的作用域在整个main内有效。

#include int main(){int a=0;//局部变量a，作用域为main函数printf("a=%d\n",a);return 0;}

而下例程中，a的作用域仅仅在{}内有效。

#include int main(){{int a=0;//局部变量a，作用域为{}内}printf("a=%d\n",a);//由于此时a不在作用域内，a的生命周期已经结束//所以报错表示a不存在。return 0;}

全局变量

定义在所有函数之外称为全局变量。全局变量的生命周期：整个程序的生命周期。例如

#include int a=1;//全局变量a=1int b;//全局变量b=0int main(){printf("a=%d,b=%d\n",a,b);}

全局变量与局域变量区别：

• 1、全局变量如果不对其初始化，则系统会自动执行默认初始化。int、short等整型变量默认0，char默认为0,指针默认为NULL。局部变量如果不对其初始化，那么它的值将处于未定义状态，或者默认初始化（编译器不同则不一样）。

#include int a;//全局变量a=0int main(){int b;//局部变量b=未定义printf("a=%d,b=%d\n",a,b);}

• 2、全局变量自从定义之后，其有效作用域为整个程序，并且其生命周期为整个程序运行期间。而局部变量定义之后，其作用域只在某一区域起作用，并且在程序运行出该作用域后销毁。
• 3、全局变量和局部变量名称可以相同，但实际上同名变量仅仅是名称相同的两个不同变量，他们有不同存储空间。当一个作用域中出现同名变量时，子作用域中的局部变量会屏蔽掉外层作用域中定义的变量。例如

#include int a;//全局变量a=0void fun(){printf("非主函数作用域a=%d\n",a);}int main(){int a=1;//局部变量a=1;{int a=2;//子作用域a=2;printf("子作用域a=%d\n",a);}printf("主函数内a=%d\n",a);fun();return 0;}

这里出现一个新的概念：自定义函数fun。函数具体内容后续章节介绍，在本程序中作用是输出全局变量a=0。

修饰符

修饰符指的是我们定义变量或函数时，在定义的语句添加的用于修饰变量或函数的关键字。常用修饰符有const、static、register、volatile、extern、auto。

const

表示该数据为常量。const修饰的是在它前面的类型，如果它前面没有类型，那它修饰的是紧跟着它的那个类型。使用const定义变量时，由于变量被const限制成不可改变的常量，所以该数据必须初始化，并且定义之后，任何试图修改该数据的操作都是非法的。例如

const int a=0;//修饰int，a是一个不可改变的数，值为0；int const b=1;//修饰int，b时应该不可改变的数，值为1；const int c=1,d=2;//修饰int，c和d都是常量const int f;//错误，常量必须初始化a=10;//错误，试图修改常量b=1;//错误，试图修改常量

有点编译器会自动对未初始化变量默认初始化，可能const int f;这种未定义的常量也可以通过编译，但是并没有什么意义，因为常量后期不能修改，而该常量目前的值是毫无意义的，那我们用它干什么呢。

并且通常对于不可改变的常量，我们用大写字母去命名数据，并不是说不可以使用其它名称，但如果拥有一个好的命名习惯，我们就可以通过变量名称看出他的类型及作用。
例程

#include int main(){const int W_SCREEN=128;//屏幕宽度为128像素const int H_SCREEN=64;//屏幕高度为64像素printf("屏幕宽度为%d\n",W_SCREEN);printf("屏幕高度为%d\n",H_SCREEN);printf("总像素点数%d\n",W_SCREEN*H_SCREEN);return 0;}

对于指针而言，const略有不同，区别在于顶层const与底层const

• 顶层const——修饰指针变量本身，指指针变量本身不可修改
  例如：int *const p1=&a;const与变量名称p1紧贴，修饰变量本身，这里表示p1指针从定义之后就不能修改了，从此p1就只能指向a。但是可以通过p1修改a的值，例如*p=5;
• 底层const——修饰目标地址，指目标地址的内容不可修改
  例如：int const *p1; //写法1 const int *p2; //写法2，这两种写法完全等价，其效果是无法通过该指针*p1去改变目标地址的内容（即a的内容）。但是可以修改p1的地址，例如p1=&b;。
• 双层const——无法修改指针变量本身，且无法通过指针修改目标地址内容。
  例如int const *const p1; //写法1 const int *const p2; //写法2
• 之前定义所有非指针变量都相当于顶层const。

const变量与指针的赋值问题——权限只能缩小，不能放大
假如有

int i=5;const int ci=10;

• 普通指针赋值问题

int *p1=&i;//正确，权限相同，可以修改i的值int *p2=&ci;//错误，权限扩大，通过p2修改ci的值，但是ci本身不可修改p1=&i;//正确，可以修改指针变量本身，并且权限相同p2=&ci;//错误，可以修改指针变量本身，但是权限扩大*p1=20;//正确，可以通过普通指针变量修改目标地址的内容*p2=20;//正确，可以通过普通指针变量修改目标地址的内容

• 顶层const赋值问题：

int *const pc1=&i;//正确，权限相同，不去修改i的值int *const pc2=&ci;//正确，权限相同，不能通过pc2修改ci的值，并且ci本身也不可修改pc1=&i;//正确，顶层const可以修改指针变量本身，并且权限缩小pc2=&ci;//正确，顶层const可以修改指针变量本身，并且权限相同*pc1=20;//错误，顶层const不可以通过指针修改目标地址的内容*pc2=20;//错误，顶层const不可以通过指针修改目标地址的内容

• 顶层const赋值问题

const int cp1=&i;//正确，权限相同，都可以修改i的值，但是cp1指针本身不可以修改const int cp2=&ci;//错误，权限扩大，ci本身不可修改，但是cp2指针可以通过地址修改ci内容，所有扩大权限的操作都是非法的cp1=&i;//错误，顶层const不能修改指针变量本身cp2=&ci;//错误，顶层const不能修改指针变量本身*pc1=20;//正确，顶层const可以修改目标地址的内容*pc2=20;//正确，顶层const可以修改目标地址的内容 

• 双重const赋值问题

const int *const cpc1=&i;//正确，权限缩小，并且修改i的值const int *const cpc2=&ci;//正确，权限相同，不能通过指针修改ci值，并且ci本身不可修改cpc1=&i;//错误，指针变量本身不可修改cpc2=&i;//错误，指针变量本身不可修改*cpc1=20;//错误，不能通过指针变量修改目标地址的内容*cpc2=20;//错误，不能通过指针变量修改目标地址的内容

static

static修饰符有3点作用：

• 1、修饰函数：被修饰的函数只在本文件中调用。
  关于函数概念与文件概念后续介绍。
• 2、修饰全局变量：被修饰的变量只在本文件中有效。
  文件概念后续介绍。
• 3、修饰局部变量：保持局部变量内容的持久。存储在静态数据区的变量会在程序刚开始运行时就完成初始化，也是唯一的一次初始化。共有两种变量存储在静态存储区：全局变量和 static 变量，只不过和全局变量比起来，static 可以控制变量的可见范围。例如：

#include //简单测试函数，目前看不懂没有关系，只需了解这个函数与主函数一样可以运行即可void fun(){int a=0;a=a+1;printf("a=%d\n",a);}int main(){fun();//第一次运行fun();//第二次运行fun();//第三次运行}

未使用静态变量时候，每次执行fun（）都会重新创建一个变量a=0；然后a=a+1；然后输出a=1；离开fun（）时候a会被销毁。

而使用static修饰符后。

#include //简单测试函数，目前看不懂没有关系，只需了解这个函数与主函数一样可以运行即可void fun(){static int a=0;a=a+1;printf("a=%d\n",a);}int main(){fun();//第一次运行fun();//第二次运行fun();//第三次运行}

添加static修饰符后，当初次执行fun（）会创建一个变量a=0；并执行a=a+1；然后输出a=1；离开fun（）后变量a不会被销毁，并且下次执行fun（）时不会重新创建变量a，而是继续使用之前的变量a；直接执行a=a+1；然后输出a=2；变量a一直持续到程序结束才会被销毁。

register

register表示寄存器变量，极少使用。简单讲解一下，可以略过不看。

• 电脑运行时，数据一般存储在存储区。存储区数据量极大，但是效率略低。当我们计算c=a+b时，cpu处理器先将a读到寄存器A中（register），再将读取b与寄存器相加，结果保存到之前的寄存器A中，然后再将a+b的结果放入存储器c中。这样虽然速度不慢，但是如果一开始a和b保存在寄存器中，就会更快。C语言中register修饰符就是将变量存储空间放在寄存器中，但是需要注意的是，cpu中寄存器十分稀有，所以除非是使用频率非常高的数据才会放在寄存器中。

volatile

volatile表示易变变量，较少使用。简单讲解一下，可以略过不看。
register介绍中描述了数据需要从存储器读取到寄存器。我们的电脑十分智能，当我们第一次使用a变量时，cpu会将它读取到寄存器中，假设是寄存器A。当我们第二次使用变量a是，cpu判断之前程序并没有对a的操作，所以cpu认为寄存器A中的值就是a，于是不会再次从存储器中读取a，而是直接使用寄存器中的A。但是电脑中可能有其他程序篡改了存储器中的a，如果我们想要cpu每次使用变量a时都重新从存储器中读取，那就可以使用volatile修饰变量。

extern

全局变量声明符号。在分文件编译中有详细介绍，通过该修饰符可以在不同文件中使用同一变量。

auto

1.c语言中，关键字auto用于声明一个变量为自动变量
 自动变量也称局部变量。将不在任何类、结构、枚举、联合和函数中定义的变量视为全局变量，而在函数中定义的变量视为局部变量。所有局部变量默认都是auto，一般省略不写。
auto声明全局变量时，编译出错：

#include auto int i;int main(void){}

auto声明局部变量时，编译正常：

int main(void){auto int i = 1;return 0;}

2.c语言中，只使用auto修饰变量，变量的类型默认为整型。

int main(void){double a = 1.2, b = 2.7;auto c = a + b;//等价于int c=a+b;先计算a+b值为3.9return 0;//然后将3.9赋值给int c，类型介绍中说过，c会向下取整=3}

类型转换

数据类型转换就是将数据（变量、数值、表达式的结果等）从一种类型转换为另一种类型。

C语言是强类型语言，如果一个运算符两边的运算数据类型不同，先要将其转换为相同的类型，强制类型转换可以消除程序中的警告，即确保写代码的程序员自己清楚类型转换，允许丢失一定精度做类型匹配。

强制类型转换

强制类型转换是显示的、按照我们意愿把变量从一种类型转换为另一种数据类型，通常用于 。表达式为：(新变量类型)原变量名称 例如：

#include int main(void){double a=9.2,b=9.2;printf("a=%lf,b=%d\n",a,(int)b);//a是double型，用%lf输出//b是double型，用%lf输出return 0;//(int)b是int类型，用%d输出}

再看一例：

#include int main(void){int a=5,b=2;//int类型无法保存小数double c,d;//双精度浮点型变量c=a/b;d=(double)a/b;printf("5/2结果为%lf\n",c);printf("5/2结果为%lf\n",d);return 0;}

本例中，c=a/b;由于a和b都是int类型，a/b结果也是int类型，即2，然后c=2；
d=(double)a/b;由于(double)a是double类型，b是int类型，两个不同类型数进行计算，系统会先将b也转为double，再进行运算，所以最后结果为2.5；

较为特殊的是，我们可以将空指针（void*）转为其他任意指针类型，例如：

void *pv=NULL;int *pi=(int*)pv;char *pc=(char*)pc;

另外有一种特殊且危险的使用方法是将底层const指针强制修改为可变指针并赋值给另一个指针。例如：

int a=5;//变量aint const *p1=&a;//底层const指针，无法通过p1修改a的值int *p2=(int*)p1//强制将int const*类型转为int *类型，可以通过p2修改a的值

还有一种更为危险且特殊的用法：我们可以通过强制类型转换将一个int数转为指针类型，但是极有可能导致错误，所以不推荐使用。例如：

int a=0xffffffff;int *p=(int*)a;

隐式类型转换

隐式类型转换又称自动类型转换，这种操作不需要程序员处理，系统会自动将运算符两边不同的数据类型进行匹配。
\

• 1、 将一种类型的数据赋值给另外一种类型的变量时就会发生自动类型转换，例如：float f = 320;这里320 是 int 类型的数据，需要先转换为 float 类型才能赋值给变量 f。再如：int n = f; 这里f 是 float 类型的数据，需要先转换为 int 类型才能赋值给变量 n。

  在赋值运算中，赋值号两边的数据类型不同时，需要把右边表达式的类型转换为左边变量的类型，这可能会导致数据失真，或者精度降低，例如int a=3.4; 这里的3.4会从double类型自动转换为int类型，丢失小数。所以说，自动类型转换并不一定是安全的。对于不安全的类型转换，编译器一般会给出警告。

• 2、在不同类型的混合运算中，编译器也会自动地转换数据类型，将参与运算的所有数据先转换为同一种类型，然后再进行计算。转换的规则如下：
  （1）转换按数据长度增加的方向进行，以保证数值不失真，或者精度不降低。例如，int 和 long 参与运算时，先把 int 类型的数据转成 long 类型后再进行运算。

  （2）所有的浮点运算都是以双精度进行的，即使运算中只有 float 类型，也要先转换为 double 类型，才能进行运算。

  （3）char 和 short 参与运算时，必须先转换成 int 类型。

通过下面例子更生动的表述一下：

#includeint main(){float PI = 3.14159;//float类型变量int s1, r = 1;//int类型变量double s2;//double类型变量s1 = r * r * PI;//int*int*float先计算int*int结果为int//之后计算int*float，先将int转为float，再计算float*float，结果为float//最后int=float，先将float转为int再赋值s2 = r * r * PI;//int*int*float计算过程如上，结果为float。//double=float，先将float转为double再赋值printf("s1=%d, s2=%f\n", s1, s2);return 0;}

上例中s1 = r * r * PI; int=intintfloat计算步骤：

• 先计算后赋值
• 计算int×int×float时，先计算int×int结果为int；之后先将int和float转为double，再计算double*double，得到结果为double。
• 最后int=double，先将double转为int再赋值。

上例中s2 = r * r * PI; double=intintfloat计算步骤：

• 先计算后赋值
• 计算int×int×float过程同上，结果为double。
• 最后double=double，直接赋值。

在计算表达式r×r×PI时，r 和 PI 都被转换成 double 类型，表达式的结果也是 double 类型。但由于 s1 为整型，所以赋值运算的结果仍为整型，舍去了小数部分，导致数据失真。

强制类型转换VS隐式类型转换

无论是隐式类型转换还是强制类型转换，都只是为了本次运算而进行的临时性转换，转换的结果也会保存到临时的内存空间，不会改变数据本来的类型或者值。

在C语言中，有些类型既可以隐式转换，也可以强制转换，例如 int 到 double，float 到 int 等；而有些类型只能强制转换，不能隐式转换，例如以后将要学到的 void * 到 int *，int 到 char * 等。

可以隐式转换的类型一定能够强制转换，但是，需要强制转换的类型不一定能够隐式转换。现在我们学到的数据类型，既可以隐式转换，又可以强制转换，以后我们还会学到一些只能强制转换而不能隐式转换的类型。

可以隐式进行的类型转换一般风险较低，不会对程序带来严重的后果，例如，int 到 double 没有什么缺点，float 到 int 顶多是数值精度丢失。只能强制进行的类型转换一般风险较高，或者行为匪夷所思，例如，char * 到 int * 就是很奇怪的一种转换，这会导致取得的值也很奇怪，再如，int 到 char * 就是风险极高的一种转换，一般会导致程序崩溃。

使用强制类型转换时，程序员自己要意识到潜在的风险。

第三部分

本章节为C语言核心部分，可以说掌握本章节对C语言学习至关重要。从本节开始，程序会渐渐变得复杂，这时在线编译器已经不能满足我们的需求了，所以我们后续程序都将使用Visual studio编译运行，Visual studio版本不同区别不大。

Visual Studio 2019软件介绍

下载地址

随着我们学习的深入，在线编译器已经无法满足需求了，我们需要自己再电脑上配置一个C语言程序开发环境。在C语言编译环境中曾给过大家VS、VC、在线编译器的下载地址，这里在展示一下。

vc++6.0，这个软件网络上有很多资源，这里给大家提供一个。
链接：https://pan.baidu.com/s/1PApsWKEDMzvqM9NmSuw6hA
提取码：zukk

或者也可以用菜鸟工具中的在线编译器
https://c.runoob.com/compile/11/

VS下载地址官网
https://visualstudio.

配置与应用安装

第一步： **
首先先找自己电脑上的浏览器，在搜索框中输入“Visual studio”，找到应用程序官方下载地址。

第二步：
根据自己的电脑选择版本，我自己电脑是Windows 所以以下内容将是Windows的安装教程。

第三步：
安装与配置


勾选C++桌面开发。选择合适的安装位置。

第四步：
确认安装，并等安装进度条走完。

此时桌面应该有一个VS图标，打开即可使用。

一个完整工程

1、创建工程项目：


输入该工程项目名称，支持中文；选择安装地址，创建工程。

2、添加工程文件
点击源文件-添加-新建项或按快捷键shift+ctrl+N

选择C++文件，输入文件任意文件名称（可以是中文、不能过长），文件后缀为 “.c” 表示c语言程序，如果为 “.cpp” 表示c++语言程序。点击添加


此时工程目录中也已经有程序文件main.c了

3、编写
其中快捷键有

• 全选——ctrl+A
• 剪切——ctrl+X
• 复制——ctrl+C
• 粘贴——ctrl+V
• 撤销——ctrl+Z
• 取消撤销——ctrl+Y

#include int main(){int a = 5;printf("原a=%d\n", a);printf("请输入新a的值：");scanf("%d", &a);printf("新a的值为%d\n", a);return 0;}

4、编译、链接与运行
开发环境可以直接集成编译、链接、运行。点击调试-开始运行（不调试）或按ctrl+F5

注意下面提示错误。

这句话翻译过来的大概意思是该函数在新标准里面已经不再使用。我们不用管它，有两种方法解决

• 文件开头添加#pragma warning(disable:4996)，4996警告全是因为函数版本低，可以直接使用这句话屏蔽。
• 也可以将scanf写成scanf_s，两者几乎没有区别，使用方法相同，但是scanf_s是新c语言标准，使用更加安全，降低了内存泄漏的风险。

添加忽略警告之后，重新编译，程序成功运行。

在我们编写的程序中输入10后效果图

运行成功，并且程序与预期相同。

调试介绍

当程序语句过多，且程序出现非语法错误时候，我们会采用调试功能。
调试指的就是编译全部代码，但是并不运行全部代码，而是按照我们的意愿执行到指定行，常用调试方式有：

• 断点调试
  断点调试指的是程序运行，直到下一个断点语句出现时，程序暂停运行，这时候我们可以将光标移动到变量上即可看到变量的值，并可以据此判断程序有没有问题。

  点击红框所指的区域，可以设置或取消断点
  
  点击调试-切换断点可以设置或取消断点，同时快捷键F9也是同样的作用
  
  当我们设置好断点时，可以点击调试-开始调试或按快捷键F5进行调试，调试时，程序会自动运行到第一个断点处，按F5可以继续运行直到下一个断点或暂停运行。
  
  提示框1是程序即将运行的语句，提示框2是终止或重启调试。

• 单步调试
  当程序需要一句话一句话的单步执行时，可以采用单步调试，常用于循环错误检测或错误内容锁定。

  点击调试-逐过程或按快捷键F10即可单步调试。
  
  此时不论是否有断点，程序都将暂停在main函数开头。每按一次F10或点击图标或点击调试-逐过程都将执行一句语句。
  

当我们运行到自定义函数时，可以使用F11或点击快捷菜单中图标，该快捷键作用是进入函数内部。

当我们跳转到自定义函数内部是，可以使用shift+F11或点击快捷菜单栏中图标，快速运行完该自定义函数并跳出该自定义函数。

单步调试和断点调试可以配合使用，能够极大提升开发者开发效率。

运算符介绍

运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C 语言内置了丰富的运算符，其种类有：算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符、其他运算符。

本章将逐一介绍算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符和其他运算符。
\

算术运算符

下表显示了 C 语言支持的所有算术运算符。假设int变量 A 的值为 10，变量 B 的值为 20，则：

请看下面的实例，了解 C 语言中所有可用的算术运算符：

#include int main(){int a = 5;int b = 2;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 = a / b;printf("a/b的值是 %d\n", c );c = a % b;printf("a%b的值是 %d\n", c );c = a++;// 赋值后再加 1 ，c 为 21，a 为 22printf("a++的值是 %d\n", c );c = a--;// 赋值后再减 1 ，c 为 22 ，a 为 21printf("a--的值是 %d\n", c );return 0;}

运行完成后结果为：

a+b的值是 7a-b的值是 3a*b的值是 10a/b的值是 2ab的值是 1a++的值是 5a--的值是 6

值得注意的是，++与–运算有左结合和右结合两种类型。区别如下：

#include int main(){int a=10;int b=10;printf("a++运算时值为：%d\n",a++);printf("a++运算后值为：%d\n\n",a);printf("++b运算时值为：%d\n",++b);printf("++b运算后值为：%d\n",b);return 0;}

运行结果为：

a++运算时值为：10a++运算后值为：11++b运算时值为：11++b运算后值为：11

左结合a++和右结合++a运算后结果一样，唯一区别时在a++和++a所处的语句中，表达式的值a++是原来的值，而++a是加1后的值。a–与–a同理。

其原理也很简单。假如a=10：

• a++运算时，先计算a++的值11并保存到另一个地方，此时a仍然是10，等运行完成a++所在的语句后再用11覆盖a的内存。
• 而++a是直接计算值11，然后覆盖a的内存，再计算后续语句。
• 这样看来++a的占用空间更少，运算更快。

下面我们看一个有意思的案例：

#include int main(){int a, b, c, d;a = 5;b = a++ * a++ * a++;printf("a=%d,b=%d\n", a, b);a = 5;c = ++a * ++a * ++a;printf("a=%d,c=%d\n", a, c);a = 5;d = ++a * a++ * ++a;printf("a=%d,d=%d\n", a, d);return 0;}

运行结果为：

a=8,b=125a=8,c=512a=8,d=343

对于第一个结果，a++*a++*a++时，所有更新的a的数据都在后台保存，但是本条语句中，a的值一直为5。

对于第二个结果，++a*++a*++a时，所有数据都在本条语句生效，即先统计完成所有++a后，a的值为8，然后再8*8*8=512。

对于第三个结果，++a*a++*++a时，两条语句即时生效，a=7，执行完成7*7*7后，程序会再处理a++的值，a的值为8，最后结果7*7*7=343。

关系运算符

下表显示了 C 语言支持的所有关系运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：

请看下面的实例，了解 C 语言中所有可用的关系运算符，其中输出0表示假、1表示真：

#include int main(){int a=5,b=2;printf("a==b的判断结果为%d\n",a==b);printf("a!=b的判断结果为%d\n",a!=b);printf("a>b的判断结果为%d\n",a>b);printf("a<b的判断结果为%d\n",a<b);printf("a>=b的判断结果为%d\n",a>=b);printf("a<=b的判断结果为%d\n",a<=b);return 0;}

运行结果为：

a==b的判断结果为0a!=b的判断结果为1a>b的判断结果为1a<b的判断结果为0a>=b的判断结果为1a<=b的判断结果为0

逻辑运算符

下表显示了 C 语言支持的所有关系逻辑运算符。假设变量 A 的值为 1，变量 B 的值为 0，则：

请看下面的实例，了解 C 语言中所有可用的逻辑运算符，其中输出0表示假，输出1表示真：

#include int main(){int a=5,b=2;printf("a&&b的判断结果为%d\n",a&&b);printf("a||b的判断结果为%d\n",a||b);printf("!(a&&b)的判断结果为%d\n",!(a&&b));return 0;}

运行结果为：

a&&b的判断结果为1a||b的判断结果为1!(a&&b)的判断结果为0

并且带有逻辑运算符的语句中，程序并不一定被执行，请看下面例子：

#include int main(){int a = 0;int b = 0;printf("a++&&b++结果为%d\n", a++ && b++);printf("此时a为%d，b为%d\n", a, b);return 0;}

运行结果为：

a++&&b++结果为0此时a为1，b为0

可能有同学发现，程序只执行了a++，并没有执行b++。这是因为系统会先判断&&运算符左边是否有效（是否为非0数），如果左侧有效，系统才会再去判断右边是否有效。在本程序中，系统先判断左侧a++的值在本条语句中为0，所以就不用执行并判断后续语句，直接就可以认定(a++&&b++)结果为假。

同理，对于||运算符而言，如果 (左表达式)||(右表达式) 语句中左表达式值为1，则程序不会执行右表达式，而是直接认定整个或逻辑运算结果为真。例如：

#include int main(){int a = 1;int b = 1;printf("a++||b++结果为%d\n", a++ || b++);printf("此时a为%d，b为%d\n", a, b);return 0;}

运行结果为：

a++||b++结果为1此时a为2，b为1

逻辑运算符与其他运算另一个不同点是，逻辑运算符（&&、||）左右两侧算两条语句。什么意思呢，就比如说++运算符，若a=5；则a++在本条语句中，a的值仍为5，但是在a++&&a++中，a在运算符左边时，其值为5，在运算符右边时，a的值为6，运行完本条语句后，a的值为7。例如：

#include int main(){int a = 1;printf("a--||a的值为%d\n", a-- && a);printf("之后a的值为%d\n", a);return 0;}

若是其他运算符，则由于a–&&a是同一条语句，语句中两个a的值都是1，最终1&&1=1。
但是不然，在逻辑运算中，a–先被执行完成，在左侧时，a–语句值为1，并且判断完成左侧后，a的值就被修改为0了，再到右侧时，a的值已经为0，所以最终a–&&a结果为0。

运行结果为：

a--||a的值为0之后a的值为0

位运算符

下表显示了 C 语言支持的所有关系运算符。为运算符直接将两个二进制数对应位相计算，假设变量 A 的值为 0B0101（5），变量 B 的值为 0B0011（3），则：

假设如果 A = 60，且 B = 13，现在以二进制格式表示，它们如下所示：
A = 0011 1100
B = 0000 1101

相关位运算计算：

• 按位与A&B =
  0B 0011 1100
  & 0B 0000 1101
  = 0B 0000 1100

• 按位或A|B =
  0B 0011 1100
  | 0B 0000 1101
  = 0B 0011 1101

• 按位异或A^B =
  0B 0011 1100
  ^ 0B 0000 1101
  = 0B 0011 0001

• 按位取反~A =
  ~0B 0011 1100
  =0B 1100 0011

• 左移A<<1 =
  0B 0011 1100
  《1
  = 0B 0111 1000

• 右移A>>1 =
  0B 0011 1100
  》1
  = 0B 0001 1110

请看下面的实例，了解 C 语言中所有可用的位运算符：

#include int main(){unsigned int a = 60;/* 60 = 0011 1100 */ unsigned 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", c );c = ~a;/*-61 = 1100 0011 */ printf("~a的值是 %d\n", c );c = a << 1; /* 120 = 0000 0111 1000 */ printf("a<<1 的值是 %d\n", c );c = a >> 1; /* 30 = 0001 1110 */ printf("a>>1 的值是 %d\n", c );return 0;}

运行结果为：

a&b 的值是 12a|b 的值是 61a^b 的值是 49~a的值是 -61a<<1 的值是 120a>>1 的值是 30

赋值运算符

下表列出了 C 语言支持的赋值运算符：

请看下面的实例，了解 C 语言中所有可用的赋值运算符：

#include 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 );return 0;}

运行结果为：

=运算符实例，c 的值 = 21+= 运算符实例，c 的值 = 42-= 运算符实例，c 的值 = 21*= 运算符实例，c 的值 = 441/= 运算符实例，c 的值 = 21%= 运算符实例，c 的值 = 11<<= 运算符实例，c 的值 = 44>>= 运算符实例，c 的值 = 11&= 运算符实例，c 的值 = 2^= 运算符实例，c 的值 = 0|= 运算符实例，c 的值 = 2

其他运算符

下表列出了 C 语言支持的其他一些重要的运算符，假设int a=4：

char变量c大小为1char指针pchar大小为4int变量i大小为4int指针pint大小为4pchar地址为00EFF82Cpchar内容为00EFF83Bc地址为00EFF83B通过*pchar访问c的值为Dc的值为Db 的值是 30b 的值是 20

#include main(){ int a = 20; int b = 10; int c = 15; int d = 5; int e;e = (a + b) * c / d;// ( ( 20 + 10 ) * 15 ) / 5 printf("(a + b) * c / d 的值是 %d\n",e );e = ((a + b) * c) / d;// ( ( 20 + 10 ) * 15 ) / 5 printf("((a + b) * c) / d 的值是 %d\n" ,e );e = (a + b) * (c / d); // ( 20 + 10 ) * ( 15 / 5 ) printf("(a + b) * (c / d) 的值是 %d\n",e );e = a + (b * c) / d; //20 + ( (10 *15 ) / 5 ) printf("a + (b * c) / d 的值是 %d\n" ,e ); return 0;}

(a + b) * c / d 的值是 90((a + b) * c) / d 的值是 90(a + b) * (c / d) 的值是 90a + (b * c) / d 的值是 50

#include int main(){int a[5]={0,1,2,3,4};int *p=a;*p++=10;printf("a[0]=%d,a[1]=%d,a[2]=%d,a[3]=%d,a[4]=%d\n",a[0],a[1],a[2],a[3],a[4]);return 0;}

a[0]=10,a[1]=1,a[2]=2,a[3]=3,a[4]=4

#include int main(){int a;a=10;printf("hello world%d\n",a);return 0;}

if(条件1){//满足条件1将执行}else if(条件2){//不满足前面条件，但满足条件2则执行}else if(条件3){//不满足前面条件，但满足条件3则执行}else{//所有条件都不满足则执行}

#include int main(){int score;printf("请输入学生成绩:");scanf("%d", &score);if (score > 90){printf("成绩为A\n");}else if (score > 80){printf("成绩为B\n");}else if (score > 60){printf("成绩为C\n");}else{printf("成绩为D\n");}return 0;}

请输入学生成绩:100成绩为A

#include int main(){int score;printf("请输入学生成绩:");scanf("%d", &score);if (score > 90)printf("成绩为A\n");else if (score > 80)printf("成绩为B\n");else if (score > 60)printf("成绩为C\n");elseprintf("成绩为D\n");return 0;}

#include int main(){int a = 3;if (a > 5){if (a < 10){printf("a在5到10之间\n");}}else{printf("a小于5\n");}printf("ok\n");return 0;}

a小于5ok

#include int main(){int a = 3;if (a > 5)if (a < 10)printf("a在5到10之间\n");elseprintf("a小于5\n");printf("ok\n");return 0;}

ok

#include int main(){int a = 3;if (a > 5){if (a < 10)printf("a在5到10之间\n");elseprintf("a小于5\n");}printf("ok\n");return 0;}

switch(总表达式){case 常量1:语句1;case 常量2:语句2;...case 常量3:语句n;default:总语句;}

#include int main(){int score;printf("请输入学生成绩:");scanf("%d", &score);switch (score / 10)//int数除以int数，结果仍然为int数，并且向下取整{case 0:case 1:case 2:case 3:case 4:case 5:printf("学生成绩为D\n"); break;;case 6:case 7:printf("学生成绩为C\n"); break;case 8:printf("学生成绩为B\n"); break;case 9:case 10:printf("学生成绩为A\n"); break;}return 0;}

请输入学生成绩:70学生成绩为C

#include int main(){int year;printf("请输入年份:");scanf("%d", &year);if ((year % 4 == 0) && (year % 100 != 0)){printf("%d年是闰年\n",year);}else{if (year % 400 == 0){printf("%d年是闰年\n", year);}else{printf("%d年不是闰年\n",year);}}return 0;}

请输入年份:20002000年是闰年

请输入年份:19211921年不是闰年

for(初始化语句;条件语句;条件修改语句){//如果条件语句为真，则执行以下循环体}

#include int main(){int a;int sum;for(a=0,sum=0;a<10;a++)\\程序从a=0开始，运行到a=9时仍然执行循环体，直到a=10时，不执行循环，直接跳出{sum+=a;}printf("从0加到9结果为：%d\n", sum);return 0;}

从0加到9结果为：45

#include int main(){int i, j;for (i = 0; i < 5; i++){for (j = 0; j <= i; j++){printf("*");}printf("\n");}return 0;}

***************

#include int main(){int i, sum;for (i = 0, sum = 0; i <= 100; i++){sum += i;}printf("0-100的和为:%d\n", sum);return 0;}

0-100的和为:5050

while(条件){//如果条件为真则执行循环体}

#include int main(){int i=0;while(i<5){printf("%d\n",i);i++;}return 0;}

01234

#include int main(){int i, j;i = 0;while (i < 5){j = 0;while (j <= i){printf("*");j++;}printf("\n");i++;}return 0;}

***************

#include int main(){int sum = 0;int i = 0;while (i <= 100){sum += i;++i;}printf("0-100的和为%d\n", sum);return 0;}

0-100的和为5050

do{}while(条件);

#include int main(){int i;int sum;i = 5;sum = 0;do{sum += i;i++;} while (i < 10);printf("5-10的和为:%d\n", sum);return 0;}

5-10的和为:35

#include int main(){int i = 0, j = 0;do{j = 0;do{printf("*");j++;} while (j <= i);printf("\n");i++;} while (i < 5);return 0;}

***************

#include int main(){int i = 0, sum = 0;do{sum += i;i++;} while (i <= 100);printf("0-100的和为%d\n", sum);return 0;}

0-100的和为5050

#include int main(){int i = 0, sum = 0;while (1)//永远循环，又称死循环{sum += i;i++;if (i > 100)//如果i>100时，将强制跳出循环{break;}}printf("0-100的和为%d", sum);return 0;}

0-100的和为5050

#include int main(){int i, sum;for (i = 0, sum = 0; i <= 100; i++){if (i % 2 == 0)//如果i为偶数，则跳过本次循环{continue;}sum += i;}printf("0-100的奇数和为%d", sum);return 0;}

0-100的奇数和为2500

语句1语句2标签1:语句3语句4goto 标签1;

#include int main(){int i = 0, sum = 0;loop:if (i <= 100){sum += i;i++;goto loop;}printf("0-100的奇数和为%d", sum);return 0;}

0-100的奇数和为5050

#include int main(){int num, i;for (i = 0, num = 0; i <= 100; i++){if (i % 7 == 0){printf("%d是7的整数倍\n", i);num++;}}printf("0-100共有%d个7的整数倍数\n", num);return 0;}

0是7的整数倍7是7的整数倍14是7的整数倍21是7的整数倍28是7的整数倍35是7的整数倍42是7的整数倍49是7的整数倍56是7的整数倍63是7的整数倍70是7的整数倍77是7的整数倍84是7的整数倍91是7的整数倍98是7的整数倍0-100共有15个7的整数倍数

#include int main(){int i = 100;int g, s, b;while (i < 1000)//最多判断到999{b = i / 100;//百位s = (i % 100) / 10;//十位g = i % 10;//个位if (b * b * b + s * s * s + g * g * g == i){printf("找到该数字%d\n", i);break;//找到后就退出循环}else{i++;}}return 0;}

找到该数字153

函数返回类型 函数名称( 形参类型1 形参名称1,形参类型2 形参名称2 ){语句;return 变量（同函数返回类型）;}

#include void fun();int main(){fun();fun();return 0;}void fun(){printf("hello world\n");}

hello worldhello world

#include void fun(int a, int b){a = 10;b = 11;printf("子函数中a=%d,b=%d\n", a, b);}int main(){int a = 3, b = 5;fun(a, b);printf("主函数中a=%d,b=%d\n", a, b);return 0;}

子函数中a=10,b=11主函数中a=3,b=5

#include void fun(int *pa, int *pb){*pa = 10;*pb = 11;printf("子函数中a=%d,b=%d\n", *pa, *pb);}int main(){int a = 3, b = 5;fun(&a, &b);printf("主函数中a=%d,b=%d\n", a, b);return 0;}

子函数中a=10,b=11主函数中a=10,b=11

#include //输入://参数1:begin累加初值//参数2:end累加终值//输出:累加值//作用:返回从begin到end的数的累加值int fun(int begin, int end){int i, sum;for (i = begin, sum = 0; i <= end; i++){sum += i;}return sum;}int main(){int a;a = fun(1, 5);printf("1-5的和为%d\n", a);printf("0-100的和为%d\n", fun(0, 100));return 0;}

1-5的和为150-100的和为5050

函数返回值类型 函数名称(强制形参类型 强制形参名称,...){}//范例//输入:// 参数1:需要计算的数据个数// 参数2:double类型形参// 参数3:double类型形参// ...//输出:double类型的所有形参累加和//作用:计算除第一个数以外的其他参数累加和double add(int n, ...){double sum = 0.0;va_list argptr;va_start(argptr, n); // 初始化argptrfor (; n > 0; --n) // 对每个可选参数，读取类型为double的参数，sum += va_arg(argptr, double); // 然后累加到sum中va_end(argptr);return sum;}

#include #include //输入:// 参数1:需要计算的数据个数// 参数2:double类型形参// 参数3:double类型形参// ...//输出:double类型的所有形参累加和//作用:计算除第一个数以外的其他参数累加和double add(int n, ...){double sum = 0.0;va_list argptr;va_start(argptr, n); // 初始化argptrfor (; n > 0; --n) // 对每个可选参数，读取类型为double的参数，sum += va_arg(argptr, double); // 然后累加到sum中va_end(argptr);return sum;}int main(){printf("1+3+3=%lf\n", add(3, 1.0, 3.2, 3.2));printf("2+2=%lf\n", add(2, 2, 2));return 0;}