[toc]

复习：

1 VS的工程组织方式

解决方案：
项目1
文件1.h
文件2.h
文件1.cpp
文件2.cpp
项目2
…….

如果项目编写完毕了，如果想要运行：

F5：调试运行 只有在调试模式下，才能够监视变量的值，查看程序的内存。
ctrl+F5：直接运行
F10：单步步过
F11：单步步入
F9： 设置断点
我们创建工程：
1 默认工程 pch.h—-2017 stdafx.h—-vs 2015之前
2 空工程

如果说我们想要调整vs的主题 颜色 字体大小 字号 行号

一：一个helloworld程序

预处理

以#号开头的一些命令#include

库函数

编译提供给你的一些代码，能够让你方便的实现一些功能
比如 printf 在屏幕上如何一个字符一个字符显示的，我们是不知道的，我们是这个函数的使用者。
如果我们想要使用一些库函数，那么就需要包含相应的头文件。（使用#include 命令）

关键字

C语言占用了的一些单词 我们就不能用来做别的事情
int int;(不可以)
int INT;可以
int _int;可以

注释

不参与程序的编译, 通常起到提示说明的作用
单行注释：
//
多行注释：
/
/

语句

是C语言中执行的基本单位 以;为结尾

二： 常量 变量

整型（整数）

int 
              short
              long
              long  long

浮点型（小数）

float
              double

字符型

char
            wchar_t

可以使用unsigned去修饰 int short long long long char wchar_t从而表示无符号整数。

unsigned short num1 = 100;

unsigned (int) num2 = 200;

变量名的定义规则：

1 字母 数字 下划线组成

2 数字不能开头

3 不能使用关键字

4 区分大小写

字符串类型

三 输出与输入

输出：

printf(“格式控制字符串”,参数列表);

功能：字符串原样输出 遇到控制 去匹配后面的参数列表

必背：

%d 整数

%c 字符

%s 字符串

%lf 双精度浮点

其他：

%x 十六进制整数

%o 八进制整数

%p 输出地址

转义字符：

换行： /n

输入：

scanf_s

用法和printf基本类似。

我们传递的参数列表，传递的都是地址。 得到变量地址的是&。

getchar() 获取一个字符

putchar() 输出一个字符

puts() 输出一个字符串

gets() 获取一个字符串

我们如何掌握一个函数：

1 函数的功能是什么？？？

2 函数的这个功能，需要什么参数？？

3 函数完成之后，你怎么得到结果？？

a. 屏幕上输出出来的

b. 输出到一个变量中了

int main()
{
    char  cCh = 0;
    scanf_s("%c", &cCh, 1);
    printf("%c", cCh);
    return 0;
}

c. 通过返回值

int main()
{
    char  cCh = 0;
    cCh = getchar();
    printf("%c", cCh);
    return 0;
}

运算符和表达式：

赋值运算符： =

算数运算符：+ - * / % ++ —

/ 整数相除只能得到整数部分

% 操作数只能是整数

++ 自增1

— 自减1

关于前置和后置的问题：

今天内容：

运算符

根据操作数的数量 可以分为

单目运算符 - & ++ —

双目运算符 + - * / %

三目运算符

关于赋值运算：

赋值复合运算：

*= /= += -= %=

逗号表达式的3个知识点：

1 逗号表达式只起到分割的作用
2 逗号表达式的值是表达式中最后一个数
3 逗号运算符的优先级是最低的。

sizeof ：

&符号：

int main()
{
    //定义变量的本质，申请内存空间，用一个名字代表这块空间
    //每一次程序运行，变量的地址都是随机的，基本不可预测。
    int nNum1 = 100;
    printf("%d\n", nNum1); //输出100
    printf("%d\n", &nNum1);//输出变量的地址值
    scanf_s("%d", &nNum1);//scanf函数因为要往内存中写入数据，所以要给它地址
    return 0;
}

我们在内存窗口中，查看我们刚刚输入进去的结果：

数组：

我们可以一次性的定义多个相同类型的变量，就是通过数组:
基本代码如下：

int main()
{
    int nPlayer[6];//相当于定义了6个变量
    //每一个变量的名字，如下所示
    nPlayer[0];
    nPlayer[1];
    nPlayer[2];
    nPlayer[3];
    nPlayer[4];
    nPlayer[5];
    return 0;
}

数组定义和使用的时候，需要注意的问题：

1 数组下标从0开始，如果数组长度是6个元素，那么下标最大到5
2 定义数组的时候，长度只能是常量。使用数组的时候，下标可以是常量，也可以是变量，或者含变量的表达式

int main()
{
    int  n = 6;
    //int nArray[n];错误的，数组定义的时候，不能是变量，只能是常量
    int nArray2[4 + 8];
    int nPlayer[6];//相当于定义了6个变量
    int m = 3;
    //我们在使用数组成员的时候，下标可以是变量
    nPlayer[0] = 10;
    nPlayer[1] = 11;
    nPlayer[2] = 8;
    nPlayer[m] = 100;
    nPlayer[m + 2] = 30;
    return 0;
}

关于数组的初始化问题：

int main()
{
    int a;//定义变量，不初始化，就是随机
    //定义变量初始化是一个好习惯，如果实在没有什么初始化的那就初始化为0
    int b = 0;
    //定义数组的时候，也可以初始化
    int nArr[5] = {2,5,3,8,0};
    int nArr2[5] = { 1,2,3,4,5 };
    int nArr3[5] = { 1,2 };//初始化的时候，元素个数不够，那就是补0
    int nArr4[5] = { 0 };
    printf("%d", nArr[0]);
    //给数组整体值的机会，就只在初始化的时候有
    //一旦错过，就只能一个一个元素的给值了
    //nArr = { 1,2,3,4,5 }; 数组是不能整体赋值的
    //nArr = nArr2;         数组是不能整体赋值的
    //如果想让它存储1，2，3，4，5
    //就只能一个一个赋值了
    nArr[0] = 1;
    nArr[1] = 2;
    nArr[2] = 3;
    nArr[3] = 4;
    nArr[4] = 5;
    return 0;
}

接下来，探讨数组越界的问题：

int main()
{
    int a = 10;
    int b = 20;
    int c = 30;
    int Arr[5] = { 0 };
    Arr[0] = 1;
    Arr[1] = 1;
    Arr[2] = 1;
    Arr[3] = 1;
    Arr[4] = 1;
    Arr[5] = 1;
    Arr[6] = 1;
    Arr[7] = 1;
    Arr[8] = 1;
    Arr[9] = 1;
    Arr[10] = 1;
    Arr[11] = 1;
    Arr[12] = 1;
    Arr[13] = 1;
    printf("%d  %d  %d", a, b, c);
    //。。。。。
    return 0;
}

数据越界 编译器不检测，出现问题 只能自己去排查。

字符数组的特殊语法：

关于字符串与字符数组

int main()
{
    //1 字符数组可以使用字符串进行初始化
    //2 字符串必须是以'\0'(asc码是0)为结尾。
    char Arr1[6] = { 'a','b','c','d','e','f'};
    char Arr2[6] = "abcde";//字符数组可以用字符串初始化
    //char Arr2[6] = "abcdef";//错误的
                            //字符串是以0为结尾的，所以这个字符串是
                            //7个元素。
    char Arr3[7] = "abcdef";//正确
    //printf("%s %s", "hello", "world");
    Arr2[2] = 0;
    printf("%s\n", Arr1);
    printf("%s\n", Arr2);
    return 0;
}

宽字符：

除了需要加一个L外，几乎没有区别
关于输入与输出：
输出没有太大的问题

输入的时候，涉及到一个安全版的问题：

我们先看一下非安全版函数：

安全版的函数，会怎么样呢？？？
使用安全版，就不会越界了。

所有的安全版函数，都是针对字符串处理的。
strlen 求得一个字符串的长度
strcmp 比较两个字符串是否相等
strcat_s 拼接两个字符串
strcpy_s 将一个字符串拷贝一块缓冲区中

int main()
{
    char  buf[10] = { "hello" };
    //求长度
    int nLenth = 0;
    nLenth = strlen(buf);
    printf("%d", nLenth);
    //比较两个字符串是否相等
    //相等的话，返回值就是0
    char  buf1[20] = { "hello" };
    char  buf2[10] = { "world" };
    int nResault = 0;
    nResault = strcmp(buf, buf1);
    nResault = strcmp(buf2, buf);
    printf("%d", nResault);
    //拼接  将buf2中的内容拼接到buf1的后面
    //      拼接完了之后，保存到buf1中
    strcat_s(buf1,20, buf2);
    //拷贝  将buf2中的内容，拷贝到buf1中
    strcpy_s(buf1, 20, buf2);
    return 0;
}