大的放到小的

左右两边标明类型

小的放到大的

左边表明，右边不表明

#include<stdio.h>

int main(int argc,char **argv)

{

    int a=;

    short b=(short)a;

    return 0;

}

我们来看看这个函数里其他的部分。

首先是 (int argc,char **argv) ，这是一个参数列表。我们可以看到，这里有两个参数，第一个参数argc表示参数个数，第二个参数argv是参数组，两个参数一起表达了这个程序的启动参数。

另外一个是return语句，我们可以看到 main 函数有一个返回值，这个返回表示程序的执行结果。我们这个 Hello Wolrd 程序里面，返回的是 0。0 表示程序执行成功，没有出现问题。如果这里返回的是非 0 ，那么表示程序执行出现问题。

一个程序里，有且只有一个 main 函数。程序从 main 函数开始执行，到 main 函数结束而终止。

#include <stdio.h>是什么意思？

在程序世界中，我们通常把外界将信息传递给我们的程序叫做输入，我们程序向外界传递信息叫做输出。

在程序中打印Hello World!，其实就是一个标准的输出行为，因为程序向外界传输了信息，这个信息就是Hello World!。

main()函数，没错，就是字面上看到的意思，主函数，这是一个特殊的函数，它是程序的入口函数。一个程序里，有且只有一个 main 函数。

向世界问好核心语句  printf("Hello World!\n");  这句代码的意思是向标准输入输出流中输出一行 Hello World!，\n表示换行符。printf 这个功能在 stdio.h 中包含，这也就是为什么我们要在程序一开头就 include 它的原因。

printf("int:%d\n",sizeof(int));查看字节数目

而在计算机中，存储数据的方式就很像电报。其实计算机中，只能存放 0 和 1 两种不同的信号，这也就是我们通常说的，计算机是二进制的。那么如何存放更复杂的数据呢？答案是排列组合。

那么如果我们将 8 个 bit 组合起来，通过排列组合，我们就可以得到 2 的 8 次方，也就是 256 个数字的数据容量。在计算机中，我们把 8 个 bit 的容量称之为 1 个 byte, 中文叫做字节。8bit = 1 byte

整型又可以分为有符号和无符号两个大类，这里的符号，指的其实就是正负号，有符号的数据类型，可以用来存放正数和负数，而无符号的数据类型，只能用来存放正数。

通过观察，我们可以发现，有符号和无符号的数据容量其实是相同的，拿 char 和 unsigned char 来说，他们的容量都是 2 的 8 次方，也就是 256 个数。只不过 char 类型的范围是 [-128, 127]，而 unsigned char 类型的范围是 [0, 255]。

每种数据类型最大的差别就是他们所占的空间大小不一样，更大的数据类型拥有更大的容量，这也意味着他能装得下更多的数字，或者更多的精度。
其实上面的表中的数据长度，只是一个常见的默认值，不同的机器会有不同的情况，C++ 标准中并没有定义某一个数据类型必须占用多少个字节的长度，C++只定义了每种数据类型长度的一个范围。

short 要大于等于 char

int 要大于等于 short

long 要大于等于 int

long long 要大于等于 long

我们可以通过 printf 向控制台输出内容，也同样可以使用控制台向程序输入内容。输入内容，就需要用到一个函数scanf。

函数要有返回值

#include<stdio.h>

#include<iostream>

int main(int argc,char **argv)

{

    int a=0

    int b=0

    std::cin>>a>>b;

    return 0;

}

scanf_s 跟printf差不多， stdcout是输出

stdcin是输入

const 数据类型 变量

include <iostream>

int main(int argc,char **argv)

{

    std::cout << "Hello World!\n" << std::endl;

    return 0;

最后那个是endl

std::cout << "Hello World!\n" << std::endl

先打一拳的循环：do while 循环

我们再来看看 do-while 循环，语法如下：

do { } while(表达式 A)

可以发现，do-while 和 while 是非常像的，不一样的是，这里多了一个 do，而且 while 放到了后面。

而 do-while 和 while 最不一样的地方，就是 do-while 无论条件是否成立，都会先执行一次循环体内的内容。

do-while 是一种 while 的重要补充，由 while 的先判断再循环，变成先循环再判断。

我们来看这样一段程序

do {     ... } while(false)

这段程序中，我们直接在 while 的判断条件中写了一个 false。那么我们这样做了，事实上是无法构成一个循环的。既然不是循环，那么我们为什么要这样做呢？

因为我们这里要利用一个循环的语法，来实现非循环的用途。

我们在写程序的时候，有时候会想要做一个跳过一段程序的功能。

if(a == 12){     // 执行跳过语句 } b = a + b; b = a - b;

例如，在上面的程序中，如果我们想要实现这样一个需求：当 a 等于 12 的时候，就跳过b = a + b;，直接执行b = a - b;。如果 a 不等于 12，就依次执行b = a + b; b = a - b;。

显然，实现这样一个功能，可以用 if 等的多分支结构：

if(a == 12){     b = a - b; } else{     b = a + b;     b = a - b; }

但是当要跳过的语句有好多行的时候，就会显得特别不方便。因此，我们可以尝试利用 do-while 语法来完成。

do {     if(a == 12){         break;     }     b = a + b; } while(false); b = a - b;

这样，我们将 do-while 和 break 进行配合，完成一个和循环无关的程序结构。

指针和数组的姻缘

数组篇

在前面及小结中，我们学习了指针和数组的概念，看起来这是两个完全不同的东西。但其实他们两者是紧密相关的，本小结我们就来探讨一下指针和数组的联系。

我们在定义数组的时候，常常这样定义，int arr[5];

在 C++ 中，数组表示的是一段连续的内存存储空间

如上图，每个元素之间是没有空隙的，这样每个元素的内存地址，其实也是有规律可循的。可以写这样一个程序，来验证我们的想法：

#include <stdio.h> int main(int argc,char **argv) {     int array[5];     printf("array[0]: %p\n", &array[0]); // %p 用来打印数组的地址     printf("array[1]: %p\n", &array[1]);     printf("array[2]: %p\n", &array[2]);     printf("array[3]: %p\n", &array[3]);     printf("array[4]: %p\n", &array[4]);     return 0; }

程序运行结果如下：

array[0]: 0x7ffee9d81490 array[1]: 0x7ffee9d81494 array[2]: 0x7ffee9d81498 array[3]: 0x7ffee9d8149c array[4]: 0x7ffee9d814a0

指针的地址以16进制的方式输出，可以看出，这几个地址中，每两个相邻的地址都相差 4 ，而每一个元素都是 int类型，int 占 4 个字节大小，说明他们确实是紧密相连的。

验证了数组的地址之后，再来看看数组是如何访问数组中的元素的。假设我们想要访问第 2 个元素（从 0 开始）

array[1];

那么 C++ 在碰到这行代码的时候，是先拿到第 2 个元素的地址，然后通过地址去访问元素，那么如何拿到第二个元素的地址呢？刚刚的实验证明，数组中元素的地址都是等差的，所以只要拿到第一个元素的地址，再加上相应元素的偏差，就可以拿到第二个元素的地址了。

那么，对于数组来说，第一个元素的地址是什么的？答案是数组名。

我们再尝试写一个测试程序

#include <stdio.h> int main(int argc,char **argv) {     int array[5];     printf("array: %p\n", array);     printf("array[0]: %p\n", &array[0]); // %p 用来打印数组的地址     printf("array[1]: %p\n", &array[1]);     printf("array[2]: %p\n", &array[2]);     printf("array[3]: %p\n", &array[3]);     printf("array[4]: %p\n", &array[4]);     return 0; }

程序运行结果如下：

array: 0x7ffeefa29490 

array[0]: 0x7ffeefa29490 

array[1]: 0x7ffeefa29494 

array[2]: 0x7ffeefa29498 

array[3]: 0x7ffeefa2949c 

array[4]: 0x7ffeefa294a0

我们发现，直接输出 array 和首元素的地址，是一模一样的，那么就可以得出一个结论：数组名是一个指向数组首元素的指针

但是这个指针和我们常见的指针有一些不一样的地方，这个指针是一个常量，所以我们是不可以对其进行修改的。也就是说，我们不能对其进行 array = p 或者 array++ 这样包含重新赋值的操作，但是我们仍然可以用指针的用法来操作他。

例如，使用指针的加减法来访问对应的元素

#include <stdio.h> int main(int argc,char **argv) {     int array[5];     *(array + 2) = 1;     return 0; }

代码中的 *(array + 2) = 1; 就等价于 array[2] = 1;

指针篇

我们在前面讲过 malloc 分配内存的用法。来看一个例子

#include <stdio.h> int main(int argc,char **argv) {     int * p = (int *)malloc(5 * sizeof(int));     free(p);     return 0; }

在上面的程序中，我们分配出来了一个 5 个 int 大小的储存空间：

在这块储存空间内，可以存放 5 个 int 类型的数字，假如想要访问第 2 个数字，我们可以写*(p + 2)

那么指针可不可以按照数组的访问方式去访问呢？p[2]

其实也是可以的，p[2]和*(p + 2)在这里是等价的。