我们把焦点放到这个 int a; 上面。在 C++ 中，我们通常管这行代码叫做声明了一个变量，这个变量的名字叫做 a，而前面的 int，表示这个变量可以存放一个整型的数据类型，整型的意思就是整数。

声明常量和声明一个变量非常像，不一样的地方就是在前面加了一个 const。这个 const 代表的就是不可变的。

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

c++中的第一个程序

#include <iostream>

int main()

{

    std::cout<<"Hello World! This is C++ Style\n"<<std::endl;

    return 0;

}

我们知道，函数在工作的以后，C++ 会为函数分配相应的内存，而且还存在参数的拷贝。这些就导致函数在调用的时候会带来额外的内存消耗。

但是函数又是一个可以让程序变得模块清晰的东西。那么有没有什么办法又能让我们使用函数，而又不带来更多的性能消耗呢？

C++ 为我们提供了一种函数形式，叫做内联函数。在程序编译的时候，编译器会把内联函数的代码复制出来，粘贴到调用的地方。例如如下代码：

int add(int a, int b)
{
   return a + b;
}

int main(int argc,char **argv)
{
   int a = 5;
   int b = 10;
   int c = add(a + b);

   return 0;
}

如果我们把 int add(int a, int b) 函数编程内联函数，那么这段程序在编译的时候，将会被自动处理成这样：

int main(int argc,char **argv)
{
   int a = 5;
   int b = 10;
   int c = a + b;
   return 0;
}

可以看到，经过编译器处理，这里就不再有函数的调用了。

那么如何把一个函数变成内联函数呢？只需要在函数前面加 inline 关键字就可以了。

inline int add(int a, int b)
{
   return a + b;
}

联函数有好处，就是可以节省调用时候的额外开销。但是同时也会造成另外的问题，内联是以代码膨胀为代价而进行的优化，而如果一个函数过长，或者一个函数被调用了好多次，那么显然就不是适合使用内联函数优化。

其实现代的编译器，会对代码进行足够的优化，有些时候，你写了内联函数，但是编译器不一定会按照内联去优化，而有的函数，你没有写内联，他却会给你优化成内联。所以大家在初学 C++ 的时候其实没必要太纠结内联函数的实际优化效果。

以上是值传递的概念，单纯地将a的值进行调用，change函数里的a变成了4，但是main函数里面的还是5，因为change函数执行完毕就销毁了里面的变量，所以其实change和main里的a完全是两个东西。

这里进行了址传递，因为函数本质是将a的地址传递到了change函数里，所以改变的是a地址里的数据，这样主函数和调用函数的内容就一致了。

int main(int argc,char **argv)
{
   Week week = Week::Fri;

   return 0;
}

eunm 变量 类似于数组的变量=变量：：变量展开定义的相对值

enum Week
{
   Mon, // 星期一
   Tue, // 星期二
   Wed, // 星期三
   Thu, // 星期四
   Fri, // 星期五
   Sat, // 星期六
   Sun, // 星期日
};

跟struct一样

定义之后要加分号

在函数调用的时候，依照函数定义时参数列表的顺序依次传入想要传入的值。在使用的时候，参数的顺序不可以改变。

int func(int a, float b)

上面的函数在调用的时候，传入的第一个参数 a 是int型，第二个参数 b 是float型。不能颠倒两者的顺序，如果颠倒，则可能发生语法错误，或者进行数据类型的隐式转换。

在 C++ 中，函数要想使用，必须要先声明。所以我们可以在调用之后实现函数体，但是必须在调用之前声明。

#include <stdio.h>

//定义函数
int avg(int a, int b)
{
   return a + b / 2;
}

int main(int argc,char **argv)
{
   int a = 10;
   int b = 20;
   int c = avg(a, b); //函数调用

   return 0;
}

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

等价于：

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

b = a - b;

在这个语句中，while（false）永远不会运行这个循环，用于延时设计。

while（true）会让程序一直执行，死循环。

这就是 switch case 的特殊的地方，他在匹配到相应的 case 之后，会将后面所有的 case 从句都执行一次，直到碰到一个 break 语句。如果想让这段程序符合预期，我们就要这么写：

#include <stdio.h>

int main(int argc,char **argv)
{
   int s = 5;
   switch (s) {
       case 1:
           printf("1\n");
           break;
       case 2:
           printf("2\n");
           break;
       case 3:
           printf("3\n");
           break;
       case 4:
           printf("4\n");
           break;
       case 5:
           printf("5\n");
           break;
       case 6:
           printf("6\n");
           break;
       case 7:
           printf("7\n");
           break;
       case 8:
           printf("8\n");
           break;
       case 9:
           printf("9\n");
           break;
       case 10:
           printf("10\n");
           break;
       default:
           printf("unknow\n");
   }
   return 0;
}

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

假设我们想要访问第 2 个元素（从 0 开始）

array[1];

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

直接输出 array 和首元素的地址，是一模一样的，那么就可以得出一个结论：数组名是一个指向数组首元素的指针，但是这个指针和我们常见的指针有一些不一样的地方，这个指针是一个常量，所以我们是不可以对其进行修改的。

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

假如想要访问第 3 个数字，我们可以把指针向后移动两个元素的位置，写成 *(p + 2)

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

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

变量只在一定的范围内有效，上面的例子中，b只在大括号（代码块）里有效。

代码在大括号外面会自动销毁里面的变量，所以b也叫自动变量。（栈内存）

为p指针分配一片4字节的堆内存，这样p在内存外也可以使用。

堆内存用完之后，要用free(p)来释放这片内存。

int a=2

int *p=&a

等价于：

*p=2

野指针指的是没有指明地址的指针，直接操作会很危险

我们可以先赋值一个空指针，但不要直接定义int *p;

可以这样int*p=nullptr；

enum Week
{
   Mon, // 星期一
   Tue, // 星期二
   Wed, // 星期三
   Thu, // 星期四
   Fri, // 星期五
   Sat, // 星期六
   Sun, // 星期日
};

int main(int argc,char **argv)
{
   Week week = Week::Fri;

   return 0;
}

在这段程序里，week 这个枚举变量，只能是定义好的 7 个值，不能是其他的值，而且在赋值的时候，你可以直接看出来这个值是什么，而不用再去和数字进行对应。这样就可以最大限度得减少出错的可能性了。

%d占位符