基本数据类型

使用编程语言进行编程时，需要用到各种变量来存储各种信息。变量保留的是它所存储的值的内存位置。这意味着，当您创建一个变量时，就会在内存中保留使用一些空间。

您可能需要存储各种数据类型（比如字符型、整型、浮点型、双浮点型、布尔型等）的信息，操作系统会根据变量的数据类型，来分配内存和决定在保留内存中存储什么。

数值类型

占用字节计算

我们可以通过limits头文件提供的numeric_limits 和sizeof() 内置方法计算数据类型存储值的范围以及占用内存多少字节。下面就演示了计算long数据类型的情况。

// 计算该数据类型会占用多少内存空间
sizeof(Type)

// 计算数据类型存储值的范围
numeric_limits<T>::max  //最大
numeric_limits<T>::min  //最小

#include <iostream>
#include "limits"

int main() {
    std::cout << "Hello, World!\n" << std::endl;

    long min = std::numeric_limits<long>::max();
    long max = std::numeric_limits<long>::min();

    printf("%ld\n", min);
    printf("%ld\n", max);
    printf("%llu\n", sizeof(long));

    return 0;
}

类是我们定义的数据类型，那么类大小使用sizeof() 函数计算占用字节大小，会有什么不一样呢？

• 空类的大小为1字节

/**
 * @file blackclass.cpp
 * @brief 空类的大小为1字节
 * @author 光城
 * @version v1
 * @date 2019-07-21
 */
#include<iostream>
using namespace std;
class A{};
int main()
{
    cout<<sizeof(A)<<endl;
    return 0;
}

• 一个类中，虚函数本身、成员函数（包括静态与非静态）和静态数据成员都是不占用类对象的存储空间。

/**
 * @file static.cpp
 * @brief 静态数据成员
 * 静态数据成员被编译器放在程序的一个global data members中，它是类的一个数据成员，但不影响类的大小。不管这个类产生了多少个实例，还是派生了多少新的类，静态数据成员只有一个实例。静态数据成员，一旦被声明，就已经存在。 
 * @author 光城
 * @version v1
 * @date 2019-07-21
 */
#include<iostream>
using namespace std;
class A
{
    public:
        char b;
        virtual void fun() {};
        static int c;
        static int d;
        static int f;
};

int main()
{
    /**
     * @brief 16  字节对齐、静态变量不影响类的大小、vptr指针=8
     */
    cout<<sizeof(A)<<endl; 
    return 0;
}

• 对于包含虚函数的类，不管有多少个虚函数，只有一个虚指针,vptr的大小。

/**
 * @file morevir.cpp
 * @brief 对于包含虚函数的类，不管有多少个虚函数，只有一个虚指针,vptr的大小。
 * @author 光城
 * @version v1
 * @date 2019-07-21
 */
#include<iostream>
using namespace std;
class A{
    virtual void fun();
    virtual void fun1();
    virtual void fun2();
    virtual void fun3();
};
int main()
{
    cout<<sizeof(A)<<endl; // 8
    return 0;
}

• 普通继承，派生类继承了所有基类的函数与成员，要按照字节对齐来计算大小
• 虚函数继承，不管是单继承还是多继承，都是继承了基类的vptr。(32位操作系统4字节，64位操作系统 8字节)！

/**
 * @file geninhe.cpp
 * @brief 1.普通单继承,继承就是基类+派生类自身的大小(注意字节对齐)
 * 注意：类的数据成员按其声明顺序加入内存，无访问权限无关，只看声明顺序。
 * 2.虚单继承，派生类继承基类vptr
 * @author 光城
 * @version v1
 * @date 2019-07-21
 */

#include<iostream>

using namespace std;

class A
{
    public:
        char a;
        int b;
};

/**
 * @brief 此时B按照顺序：
 * char a
 * int b
 * short a
 * long b
 * 根据字节对齐4+4+8+8=24
 * 
 * 或编译器优化
 * char a
 * short a
 * int b
 * long b
 * 根据字节对齐2+2+4+8=16
 */
class B:A
{
    public:
        short a;
        long b;
};
/**
* 把A的成员拆开看，char为1，int为4，所以是1+（3）+4+1+（3）=12，（）为字节补齐
*/
class C
{
    A a;
    char c;
};

class A1
{
    virtual void fun(){}
};
class C1:public A1
{
};


int main()
{
    cout<<sizeof(A)<<endl; // 8
    cout<<sizeof(B)<<endl; // 16 或 24
    cout<<sizeof(C)<<endl; // 12

    /**
     * @brief 对于虚单函数继承，派生类也继承了基类的vptr，所以是8字节
     */
    cout<<sizeof(C1)<<endl; // 8 
    return 0;
}

• 虚继承,继承基类的vptr。

/**
 * @file virnhe.cpp
 * @brief 虚继承
 * @author 光城
 * @version v1
 * @date 2019-07-21
 */

#include<iostream>
using namespace std;
class A
{
    virtual void fun() {}
};
class B
{
    virtual void fun2() {}
};
class C : virtual public  A, virtual public B
{
    public:
        virtual void fun3() {}
};

int main()
{
    /**
     * @brief 8 8 16  派生类虚继承多个虚函数，会继承所有虚函数的vptr
     */
    cout<<sizeof(A)<<" "<<sizeof(B)<<" "<<sizeof(C);

    return 0;
}

总结：

• 空类的大小为1字节
• 一个类中，虚函数本身、成员函数（包括静态与非静态）和静态数据成员都是不占用类对象的存储空间。
• 对于包含虚函数的类，不管有多少个虚函数，只有一个虚指针,vptr的大小。
• 普通继承，派生类继承了所有基类的函数与成员，要按照字节对齐来计算大小
• 虚函数继承，不管是单继承还是多继承，都是继承了基类的vptr。(32位操作系统4字节，64位操作系统 8字节)！
• 虚继承,继承基类的vptr。

整数类型

在C++中，经过计算，整数类型包括了以下几个：

• short int（short） 短整型（占用2个字节）范围在 --32768~ +32767

• int （占用4个字节）是最常用的类型。范围在 -2147483648 ~ +2147483647

• long （占用4个字节）范围在-2147483648~ +2147483647

在VS中，long是4字节，32位。   -2147483648~2147483647

在Linux中，long是8字节，64位。  -9223372036854775808~922337203685477580

• long int （占用4个字节）范围在 -2147483648~ +2147483647

• long long （占用8个字节) 范围在 -9223372036854775808~9223372036854775807

C++11标准增了long long类型的整数，**至少64位，且至少与long一样长**。

在VS中，long long是8字节，64位。 -9223372036854775808~9223372036854775807

在Linux中，long和long long类型都是8字节，64位。

C++默认整数类型都是有符号的(这个数字可以是正数、也可以是一个负数) 业务适合我们需要创建无符号的整型（只能是正数的），就可以使用unsigned 关键字进行修饰

• unsigned short （占用2个字节）范围在0~65535

• unsigned int (占用4个字节) 范围在0~4294967295

• unsigned long (占用4个字节) 范围在0~4294967295

• unsigned long long（占用8个字节） 范围在0~18,446,744,073,709,551,615

进制

整数默认是十进制，一个表示十进制的数字不需要任何特殊的格式。

#include <iostream>

int main() {
    std::cout << "Hello, World!\n" << std::endl;

    int a = 10;
    std::printf("%d\n", a);
    return 0;
}

二进制

二进制由 0 和 1 两个数字组成，书写时必须以0b或0B（不区分大小写）开头。

  int a = 0b101;      // 换算成十进制为 5
  int b = -0b110010;  // 换算成十进制为 -50
  int c = 0B100001;   // 换算成十进制为 33

八进制

八进制由 0~7 八个数字组成，书写时必须以0开头（注意是数字 0，不是字母 o）。

   int a = 015;      // 换算成十进制为 13
  int b = -0101;    // 换算成十进制为 -65
  int c = 0177777;  // 换算成十进制为 65535

十六进制

十六进制由数字 0~9、字母 A~F 或 a~f（不区分大小写）组成，书写时必须以0x或0X（不区分大小写）开头。

  int a = 0X2A;   // 换算成十进制为 42
  int b = -0XA0;  // 换算成十进制为 -160
  int c = 0xffff;   // 换算成十进制为 65535

需要注意的坑

• 1、在C++中，不要在十进制数前面加0，会被编译器当成八进制
• 2、还有，不要随便删掉别人程序中整数前面的0，它不是多余的。

浮点类型

在C++中，也可以轻松的使用小数

C++浮点型分三种：float（单精度）、double（双精度）、long double（扩展精度）。

首先我们来看看C++中小数类型包含哪些：

• float(占用4个字节)，范围在0.000000~340282346638528859811704183484516925440.000000

• double (占用8个字节)，范围在0.000000~179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464
  234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559
  332123348274797826204144723168738177180919299881250404026184124858368.000000

• long double(占用16个字节)，范围在 0.000000~ 更大

数学运算

在 C++ 中，除了可以创建各种函数，还包含了各种有用的函数供您使用。这些函数写在标准 C 和 C++ 库中，叫做内置函数。您可以在程序中引用这些函数。

C++ 内置了丰富的数学函数，可对各种数字进行运算。下表列出了 C++ 中一些有用的内置的数学函数。

为了利用这些函数，您需要引用数学头文件 <cmath>。

随机数

在许多情况下，需要生成随机数。关于随机数生成器，有两个相关的函数。一个是 rand()，该函数只返回一个伪随机数。生成随机数之前必须先调用 srand() 函数。

#include <iostream>
#include <ctime>
#include <cstdlib>
 
using namespace std;
 
int main ()
{
   int i,j;
 
   // 设置种子
   srand( (unsigned)time( NULL ) );
 
   /* 生成 10 个随机数 */
   for( i = 0; i < 10; i++ )
   {
      // 生成实际的随机数
      j= rand();
      cout <<"随机数： " << j << endl;
   }
 
   return 0;
}

字符类型

除了保存数字之外，C++语言还支持字符类型，我们的每一个字符都可以使用字符类型来保存.

字符型（char）占用的内存空间是1个字节，书写用单引号包含。

在内存中，不存放字符本身，而是存放与它对应的编码，即ASCII码。

• char(占用1个字节 ) 范围在 -128 ~ 127 ，可以表示所有的ASCII码字符，每一个数字对应的是编码表中的一个字符。
• wchar_t (占用2个字节) 范围在 0~65535。
• char16_t（占用2个字节） 范围在0~65535
• char32_t（占用4个字节） 范围在

同样的C++默认char == singed char也是无符号的，如果我们想创建无符号的字符类型，可以使用关键字unsigned char

• unsigned char(占用1个字节) 范围在 0~255

老外在一开始的时候，没有考虑到字符数量如此庞大，仅仅认为只需要1个字节存放字符就可以了，并提出了ASIIC字符集，来解释字符和计算机编码的对应关系。后来，随着IT的快速发展，字符越来越多，1个字节根本不够表示了，由此提出了使用wchat_t宽字节替代之前的多字节char. Unicode字符集来替换之前的ASCII字符集编码。

char* ---- 多字节的字符串
wchar_t* ---- 宽字节的字符串

那么如何在char* w_char_t* string 三者进行转换呢？

#include<Windows.h>

//不要忘记使用完char*后delete[]释放内存
char* wide_Char_To_Multi_Byte(const wchar_t* pWCStrKey)
{
	//第一次调用确认转换后单字节字符串的长度，用于开辟空间
	int pSize = WideCharToMultiByte(CP_OEMCP, 0, pWCStrKey, wcslen(pWCStrKey), NULL, 0, NULL, NULL);
	char* pCStrKey = new char[pSize + 1];
	//第二次调用将双字节字符串转换成单字节字符串
	WideCharToMultiByte(CP_OEMCP, 0, pWCStrKey, wcslen(pWCStrKey), pCStrKey, pSize, NULL, NULL);
	pCStrKey[pSize] = '\0';
	return pCStrKey;

	//如果想要转换成string，直接赋值即可
	//string pKey = pCStrKey;
}


//不要忘记在使用完wchar_t*后delete[]释放内存
wchar_t* multi_Byte_To_Wide_Char(const string& pKey)
{
	//string 转 char*
	const char* pCStrKey = pKey.c_str();
	//第一次调用返回转换后的字符串长度，用于确认为wchar_t*开辟多大的内存空间
	int pSize = MultiByteToWideChar(CP_OEMCP, 0, pCStrKey, strlen(pCStrKey) + 1, NULL, 0);
	wchar_t* pWCStrKey = new wchar_t[pSize];
	//第二次调用将单字节字符串转换成双字节字符串
	MultiByteToWideChar(CP_OEMCP, 0, pCStrKey, strlen(pCStrKey) + 1, pWCStrKey, pSize);
	return pWCStrKey;
}

字符的本质

• 1、在C++中，书写的时候只能单引号包含，也可以用整数。

      	char c = 65;

• 2、如果书写的时候用单引号包含，程序执行的时候，将把符号解释为对应的整数。

       	char c = 'A';
      	bool b = c == 65;
       	cout << b<<endl;   

• 3、字符的本质是整数 显示的时候，可以把整数解释为对应的符号，也可以直接显示整数。

		char a = 65;
		printf("%c\n",a);
		printf("%d\n",a);

• 4、可以与整数进行任何运算，运算的时候，书写方式可以用字符，也可以用整数。

     	char c = 'A';
        int a = c + 1;
        cout<< a <<endl;      

ASCII字符集

ASCII（American Standard Code for Information Interchange，美国信息交换标准代码）是现今最通用的单字节编码方案.

他包含了33个控制字符（具有特殊含义无法显示的字符）和95个可显示字符。

ASCII 码大致由以下两部分组成：

• ASCII 非打印控制字符： ASCII 表上的数字 0-31 分配给了控制字符，用于控制像打印机等一些外围设备。
• ASCII 打印字符：数字 32-126 分配给了能在键盘上找到的字符，当查看或打印文档时就会出现。

转义字符

在C++程序中，使用转义字符的原因有两个：

• 1、控制字符没有符号，无法书写，只能用其它的符号代替。
• 2、某些符号已被C++征用，语义冲突，只能用其它的符号代替。

现阶段我们常用的转义字符有： \n \\ \t

转义字符	含义	ASCII码值（十进制）
\a	警报	007
\b	退格(BS) ，将当前位置移到前一列	008
\f	换页(FF)，将当前位置移到下页开头	012
\n	换行(LF) ，将当前位置移到下一行开头	010
\r	回车(CR) ，将当前位置移到本行开头	013
\t	水平制表(HT) （跳到下一个TAB位置）	009
\v	垂直制表(VT)	011
\\	表示斜线	092
\'	代表一个单引号（撇号）字符	039
\"	代表一个双引号字符	034
\?	代表一个问号	063
\0	空，给字符串变量赋值时可以直接写0	000
\ddd	8进制转义字符，d范围0~7	3位8进制
\xhh	16进制转义字符，h范围09，af，A~F	3位16进制

字符串

C++提供了两种字符串的表示方式

• 1、可以是C风格的字符串（兼容）
• 2、C++引入的string类 类型

C风格字符串

C风格字符串：char 变量名[]="字符串的内容" ;

#include <iostream>
#include "limits"

int main() {
    std::cout << "Hello, World!\n" << std::endl;
	//可以用数组方式创建
    char str[12] = {'W', 'A', 'N', 'G', '\0'};
    // 可以用字符串字面量创建
    char str[] = "WANG";
    //可以用字符指针创建
    char str* = "WANG";

    return 0;
}

我们在学习C的时候就已经知道了，数组名存放的是字符数组第一个元素的地址值。所以数组元素和指针一定存在如下对应关系。我们通过一个Demo来验证下。

每一个字符占用1个字节的内存空间  c = 1
字符数组中第i+1个元素的指针和第i个数据元素的存储位置满足下列关系（LOC表示获得存储位置的函数）
LOC(ai+1) = LOC(ai)+c
又可以推出对于第i个数据元素ai的存储位置可以由a1推算得出：
LOC(ai) =LOC(a1)+(i-1)*c

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pK8hHLLM-1688023815695)(01-基本数据类型和注释.assets/image-20230308145800176.png)]

#include <iostream>

void printStrItem(char* p,char value){
    printf("%p\n", p);
    printf("%c\n", value);
    printf("-----------\n");
}

int main() {
    std::cout << "Hello, World!\n" << std::endl;

    char str[12] = {'W', 'A', 'N', 'G', '\0'};
    char *p = str;
    printStrItem(p,*p);
    printStrItem(p+1,*(p + 1));
    printStrItem(p+2,*(p + 2));
    printStrItem(p+3,*(p + 3));
	printStrItem(p+4,*(p + 4));
    return 0;
}

可以看到最终的输出结果，地址值是连续的。第二个元素地址值，等于第一个元素+元素数据类型（1个字节）。

元素索引	元素地址值	元素值
0	00000056317ff91c	W
1	00000056317ff91d	A
2	00000056317ff91e	N
3	00000056317ff91f	G
4	00000056317ff920	0

同样我们使用字符串字面量形式创建，发现C编译器自动会给我们加上空字符作为终止符。

  char str[] = "WANG";

也可以通过字符指针，指向字面量的方式创建

  char *p = str;

因为C太底层了，设计C的人根本就没想到实际使用这个语言的人，基本都在用字符串，而不用字符的。就有了后来C++设计的类string,其底层也是封装了字符数组。

所以，在C语言中约定：如果字符型（char）数组的末尾包含了空字符\0（也就是0），那么该数组中的内容就是一个字符串。

正是因为字符串需要用0结尾，所以在声明字符数组的时候，要预留多一个字节用来存放0。

char name[21];  // 声明一个最多存放20个英文字符或十个中文的字符串。

初始化方法

char name[11];                 // 可以存放10个字符，没有初始化，里面是垃圾值。
char name[11] = "hello";         // 初始内容为hello，系统会自动添加0。
char name[]   = { "hello" };      // 初始内容为hello，系统会自动添加0，数组长度是6。
char name[11] = { "hello" };      // 初始内容为hello，系统会自动添加0。
char name[11]   { "hello" };      // 初始内容为hello，系统会自动添加0。C++11标准。
char name[11] = { 0 };          // 把全部的元素初始化为0。

获取字符串长度

实际上开发我们写的字符串，带中文的都是宽字节字符串，所以要计算字符串长度应当使用wcslen(),而不是早期的ASIIC字符集那一套的strlen()

// 计算多字节字符串长度 -ASCII
int strlen(char* str);

// 计算宽字节字符串长度 -Unicode 
int wcslen(str);

int main()
{
	// 将多字节字符集 通过L 转为宽字节字符集
	wchar_t* msg = const_cast<wchar_t*>(L"王乃醒");

	//求字符集长度
	cout << wcslen(msg);
		
	cout << endl;

}

字符串比较

实际开发中，我们通常是比较两个字符串是否是相等的，可以通过此strcmp() 来比较C风格字符串。

//相等返回0，str1大于str2返回1，str1小于str2返回-1；
int strcmp(const char *str1, const char *str2 );

//such as:
if(strcmp(str1,str2) == 0)
{
    // str str2 content equal!
}

注意事项

• 字符串的结尾标志是0，按照约定，在处理字符串的时候，会从起始位置开始搜索0，一直找下去，找到为止（不会判断数组是否越界）。

• 结尾标志0后面的都是垃圾内容。

• 字符串在每次使用前都要初始化，减少入坑的可能，是每次，不是第一次。

• 不要在子函数中对字符指针用sizeof运算，所以，不能在子函数中对传入的字符串进行初始化，除非字符串的长度也作为参数传入到了子函数中。

• 在VS中，如果要使用C标准的字符串操作函数，要在源代码文件的最上面加

  #define _CRT_SECURE_NO_WARNINGS

C++风格字符串 string

C++风格字符串：string 变量名="字符串的内容" ;

#include <iostream>

using namespace std;

int main() {
    std::cout << "Hello, World!\n" << std::endl;

	// 定义类型为string 的变量 str 并初始化赋值为 字符串常量WANG
    string str = "WANG";
    

    return 0;
}

C风格字符串的本质是字符数组，C++风格字符串的本质是类，它封装了C风格字符串。

C++风格字符串的常用操作：

• 1、 赋值：变量名=“字符串的内容” ;
• 2、拼接：变量名=变量名+“字符串的内容1”+“字符串的内容2”+…+“字符串的内容n” ;如果字符串的内容都是常量，不要写加号（+），如果内容很长，可以分成多行书写。
• 3、 比较：支持==、!=、>和<关系运算符，常用的是==和!=。

原始字面量

原始字面量（值）可以直接表示字符串的实际含义，不需要转义和连接。

语法：R"(字符串的内容)"
R"xxx(字符串的内容)xxx"

#include <iostream>
using namespace std;

int main()
{   
	string path = R"(C:Program Files\Microsoft OneDrive\tail\nation)";
	string path2 = R"xxx(C:Program Files\Microsoft OneDrive\tail\nation)xxx";
	cout << path << endl;
	cout << path2 << endl;
	//C:Program Files\Microsoft OneDrive\tail\nation
	//C:Program Files\Microsoft OneDrive\tail\nation
	return 0;
}

布尔类型

bool(占用1个字节) 范围：要么是0 要么是1

布尔型取值只能是true和false，或1和0。

注意，布尔型变量输出的时候，如果值是true，将显示1，false显示0。

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。

int main()
{
	bool b = 1;

	cout << "b+b=" << b+b << endl;       // 将显示2。
	
	// 如果对bool型变量赋非0的值，将转换成1。
	b = 30;
	cout << "b=" << b << endl;                 // 将显示1。

	// 找到布尔变量b的内存，把里面的数据强制为8。
	char* c = (char *) & b; 
	*c = 8;
	cout << "b=" << b << endl;                 // 将显示8。
}

C语言用0表示假，非0表示真。

只是为了提高代码的可读性，C++新增了 bool 类型，占用1字节的内存，用true表示真，false表示假。

• 1、bool类型本质上是1字节的整数（unsigned char），取值只有1和0。

• 2、在程序中，书写的时候可以用true和false，编译器把它们解释为1和0。

• 3、如果对bool型变量赋非0的值，将转换成1。

• 4、用cin输入和cout输出的时候，仍是1和0，不会被解释为true和false。

程序的注释

在程序中添加的说明文字，对代码的流程或功能加以解释，方便自己和其他的程序员阅读和理解代码。

编译器在编译源代码的时候，会忽略注释。

单行注释

用两根反斜线打头，一般放在代码的上方，或者一行语句的末尾。
注意：字符串内容中的两根反斜线是内容的一部分，不是注释。

多行注释

从/*开始，到*/结束，把一些内容夹住。

注意：

a）字符串内容中的/*和*/是内容的一部分，不是注释；

b）/*和*/可以出现在一行代码的中间。

注释的注释

单行注释可以注释多行注释，多行注释也可以注释单行注释，但是，不建议使用。

VS中的快捷键

添加注释：Ctrl+k+c
取消注释：Ctrl+k+u

// 将显示2。

// 如果对bool型变量赋非0的值，将转换成1。
b = 30;
cout << "b=" << b << endl;                 // 将显示1。

// 找到布尔变量b的内存，把里面的数据强制为8。
char* c = (char *) & b; 
*c = 8;
cout << "b=" << b << endl;                 // 将显示8。

}

C语言用0表示假，非0表示真。

只是为了提高代码的可读性，C++新增了 bool 类型，占用1字节的内存，用true表示真，false表示假。

- 1、bool类型本质上是1字节的整数（unsigned char），取值只有1和0。

- 2、在程序中，书写的时候可以用true和false，编译器把它们解释为1和0。

- 3、如果对bool型变量赋非0的值，将转换成1。

- 4、用cin输入和cout输出的时候，仍是1和0，不会被解释为true和false。



# 程序的注释

在程序中添加的说明文字，对代码的流程或功能加以解释，方便自己和其他的程序员阅读和理解代码。

编译器在编译源代码的时候，会忽略注释。

## 单行注释

用两根反斜线打头，一般放在代码的上方，或者一行语句的末尾。
注意：字符串内容中的两根反斜线是内容的一部分，不是注释。

## 多行注释

从`/*`开始，到`*/`结束，把一些内容夹住。

注意：

a）字符串内容中的`/*`和`*/`是内容的一部分，不是注释；

b）`/*`和`*/`可以出现在一行代码的中间。

## 注释的注释

单行注释可以注释多行注释，多行注释也可以注释单行注释，但是，不建议使用。

## VS中的快捷键

添加注释：Ctrl+k+c
取消注释：Ctrl+k+u