布尔类型可以表示的数据范围只有 true 和 false。

在早期的 C++ 中是没有 bool 类型的，在没有 bool 类型的年代，人们常用普通的整型来表示二值化语义，即 0 表示 false，非 0 表示 true。

#include <stdio.h>

int main(int argc,char **argv)
{
   int a = 1;
   int b = 2;

   bool c1 = a > b;
   printf("Bool c1: %d\n", c1);

   bool c2 = a >= b;
   printf("Bool c2: %d\n", c2);

   bool c3 = a < b;
   printf("Bool c3: %d\n", c3);

   bool c4 = a <= b;
   printf("Bool c4: %d\n", c4);

   bool c5 = a == b;
   printf("Bool c5: %d\n", c5);

   bool c6 = a != b;
   printf("Bool c6: %d\n", c6);

   return 0;
}

几种运算符：

a = 10，就是将 10 赋给 a 这个变量;

a = b  将b的值赋给a

利用程序输出数据类型长度

#include <stdio.h>

int main(int argc,char **argv)
{
   printf("int: %d\n", sizeof(int));
   
   return 0;
}

bit中文名“位”

2 个 bit 组合起来，可以得到 2 的 2 次方，也就是 4 个数字的数据容量。

 8 个 bit 组合起来，可以得到 2 的 8 次方，也就是 256 个数字的数据容量。

在计算机中，我们把 8 个 bit 的容量称之为 1 个 byte, 中文叫做字节。8bit = 1 byte

cin

#include <stdio.h>
#include <iostream>

int main(int argc,char **argv)
{
   int a = 0;
   int b = 0;

   std::cin >> a >> b;

   return 0;
}

使用 cin 可以连续从键盘读取想要的数据，以空格、tab键或换行符作为分隔符。cin 相对于 scanf 来说，不需要指明类型，用起来更方便一些。

cout

#include <stdio.h>
#include <iostream>

int main(int argc,char **argv)
{
   int a = 99;
   int b = 98;

   std::cout << "a: " << a << ", b: " << b << std::endl;

   return 0;
}

输出结果 a: 98, b: 99
cout 相对 printf 来说，更易用一些，只需要将想要输出的内容用 << 连接起来就好了。

/*C

#include<stdio.h>

int main(int argc,char **argv)

{

    int a=1; int b=2; int c=a+b;  int d=a-b; int e=a*b; int f=a/b;  int g=a%b;

    printf("%d %d %d %d %d",c,d,e,f,g);

    return 0;

}

//语言输入Hello World!This is C Style

#include <stdio.h>

int main()

{

    printf("Hello World!This is C Style");

    return 0;

}

*/

//C++输出

#include <iostream>

using namespace std;

int main()

{

    cout << "Hello world！This is C++ Style" <<endl;

    return 0;

}

我们在上一小节的 Hello World 中，写了这样一段程序

#include <stdio.h>

int main(int argc,char **argv)
{
    printf("Hello World!\n");
    return 0;
}

在这段程序中，我们提到一个 main 函数。这个 main 函数是程序的入口，一个程序里，有且只有一个 main 函数。程序从 main 函数开始执行，到 main 函数结束而终止。

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

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

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

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

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

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

C++ Style

看到这里，有的学过 C 语言的同学会说，这段程序怎么和 C 语言的 Hello World 一摸一样啊。事实上，这段程序本身就是一段 C Style 的程序。C++ 是兼容 C 语言的大部分特性的，C 语言的 stdio 和 printf 在 C++ 程序中是一点问题都没有的。事实上，这也是很多成熟 C++ 项目的使用方式。那么 C++ 有什么专有的输出方式呢？其实是有的。我们再来看一个程序。

#include <iostream>

int main(int argc,char **argv)
{
    std::cout << "Hello World!\n" << std::endl;
    return 0;
}

在这个程序里面，我们没有包含 stdio，而是包含了 iostream，这是 C++ 里的 io 流的头文件。
main 函数中，输出语句变成了std::cout << "Hello World!\n" << std::endl;

这就是 C++ 风格的 Hello World 。在实际开发中，这两种输出语句都可以使用。

#include <stdio.h>

main()

{

    int a,b ,temp;

    a=1;

    b=2;

    temp=a;//temp=1

    a=b;//a=2

    b=temp;//b=1

    printf("%d,%d",a,b);//a=2,b=1

}

#include <stdio.h>

main()

{

printf("char:%d\n",sizeof(char));

printf("int:%d\n",sizeof(int));

printf("float:%d\n",sizeof(float));

printf("double:%d\n",sizeof(double));

printf("long:%d\n",sizeof(long));

printf("short:%d\n",sizeof(short));

}

iostream

std::cout<<"\n"<<std::endl

iostream

std::cout<<"\n"<<std::endl;

我们在定义数组的时候，常常这样定义，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 类型的数字，假如想要访问第 3 个数字，我们可以把指针向后移动两个元素的位置，写成 *(p + 2)

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

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