基本数据类型
使用编程语言进行编程时，需要用到各种变量来存储各种信息。变量保留的是它所存储的值的内存位置。这意味着，当您创建一个变量时，就会在内存中保留使用一些空间。
您可能需要存储各种数据类型（比如字符型、整型、浮点型、双浮点型、布尔型等）的信息，操作系统会根据变量的数据类型，来分配内存和决定在保留内存中存储什么。
数值类型
占用字节计算
我们可以通过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
