突破编程_C++_面试（基本数据类型）

面试题1：在32位和64位系统上，`int`、`short`、`long`、`long long` 和 `char` 类型通常分别占用多少字节

在 32 位和 64 位系统上，int、short、long、long long 和 char 类型的大小可能会有所不同，这取决于编译器和操作系统。但按照常见的约定，一般的占用字节为：
32 位系统（通常是基于 x86 或 x86_64 的，尽管后者也是 64 位系统，但很多实现为了兼容性仍然保留 32 位模式）：
char ：通常占用 1 字节。
short ：通常占用 2 字节。
int ：通常占用 4 字节。
long ：通常占用 4 字节。
long long ：通常占用 8 字节。
64 位系统（基于 x86_64 或 ARM64 等架构）：
char ：通常占用1字节。
short ：通常占用2字节。
int ：根据编译器和操作系统的不同，可能是 4 字节或 8 字节。在 Windows 上， int 通常是 4 字节，而在 Linux 和 macOS 上，int 通常是 8 字节。
long ：根据编译器和操作系统的不同，可能是 4 字节或 8 字节。在 Windows 上， long 通常是 4 字节，而在 Linux 和 macOS 上，long 通常是 8 字节。
long long ：通常占用8字节。
注意：这些大小并不是由 C++ 标准直接规定的，而是由编译器和操作系统决定的。因此，不同的编译器或操作系统可能会有所不同。另外，现代编译器通常提供了类型大小的查询功能，例如通过 sizeof 运算符。
如下为样例代码：

#include <iostream>  

int main() 
{
	std::cout << "Size of char: " << sizeof(char) << " bytes" << std::endl;
	std::cout << "Size of short: " << sizeof(short) << " bytes" << std::endl;
	std::cout << "Size of int: " << sizeof(int) << " bytes" << std::endl;
	std::cout << "Size of long: " << sizeof(long) << " bytes" << std::endl;
	std::cout << "Size of long long: " << sizeof(long long) << " bytes" << std::endl;
	return 0;
}

上面代码在 Windows 上使用 64 位平台编译后运行的结果为：

Size of char: 1 bytes
Size of short: 2 bytes
Size of int: 4 bytes
Size of long: 4 bytes
Size of long long: 8 bytes

面试题2：`sizeof(void*)` 在32位和64位系统上的值是多少？为什么？

sizeof(void*) 在 C++ 中表示指针的大小。在 32 位系统上，sizeof(void*) 的值通常是 4 字节，而在 64 位系统上，其值通常是 8 字节。
这是因为指针本质上是一个存储内存地址的变量。在 32 位系统中，内存地址的大小是 32 位，即 4 字节，因为 2^32（约 4GB）是 32 位系统可以寻址的最大内存量。相应地，指针的大小需要足够大以存储这个 32 位的内存地址。
在 64 位系统中，内存地址的大小是 64 位，即 8 字节，因为 2^64（约 16EB）是 64 位系统可以寻址的最大内存量。因此，64 位系统中的指针也需要 8 字节来存储内存地址。
所以，sizeof(void*) 在 32 位系统上的值是 4，在 64 位系统上的值是 8。这是因为指针需要足够大以存储对应系统架构下的内存地址。这个大小是由系统的硬件架构决定的，而不是由 C++ 语言本身决定的。

面试题3：如何获取各种基本数据类型的取值范围

头文件 climits （在 C 语言中为 limits.h ）中包含了关于整型范围的宏定义。具体如下表所示：

符号常量	含义
CHAR_BIT	char 的位数
CHAR_MAX	char 的最大值
CHAR_MIN	char 的最小值
SCHAR_MAX	signed char 的最大值
SCHAR_MIN	signed char 的最小值
UCHAR_MAX	unsigned char 的最大值
SHRT_MAX	short 的最大值
SHRT_MIN	short 的最小值
USHRT_MAX	unsigned short 的最大值
INT_MAX	int 的最大值
INT_MIN	int 的最小值
UINT_MAX	unsigned int 的最大值
LONG_MAX	long 的最大值
LONG_MIN	long 的最小值
ULONG_MAX	unsigned long 的最大值
LLONG_MAX	long long 的最大值
LLONG_MIN	long long 的最小值
ULLONG_MAX	unsigned long long 的最大值

头文件 cfloat 中包含了关于浮点型范围的宏定义。具体如下表所示：

符号常量	含义
FLT_MAX	float 的最大值
FLT_MIN	float 的正最小值
DBL_MAX	double 的最大值
DBL_MIN	double 的正最小值
LDBL_MAX	long double 的最大值
LDBL_MIN	long double 的正最小值

面试题4：什么是隐式类型转换？什么是显式类型转换？

隐式类型转换和显式类型转换是 C++ 中两种不同类型的类型转换。
隐式类型转换
隐式类型转换是编译器自动进行的类型转换，不需要用户显式地指定转换操作。当需要将一种数据类型转换为另一种数据类型时，如果存在隐式转换规则，编译器会自动进行转换。这种转换通常发生在类型兼容的情况下，例如将一个较小范围的整数类型赋值给一个较大范围的整数类型，或者将一个派生类对象赋值给一个基类对象。例如，将一个整数赋值给一个浮点数变量，或者将一个派生类的对象赋值给一个基类对象。这种转换对用户来说通常是透明的，不需要用户干预。
显式类型转换
显式类型转换需要在代码中明确指定需要进行的类型转换操作。通过显式转换，可以将一种数据类型强制转换为另一种数据类型，即使这两种类型之间没有隐式转换规则。显式转换需要用户明确的指定要转换的类型，而且在转换的过程中可能会造成数据丢失或截断。例如，将一个浮点数转换为整数，或者将一个非基类的对象转换为基类对象。显式转换通常需要使用类型转换运算符（如 static_cast 、 dynamic_cast 、 reinterpret_cast 、 const_cast ）或者类型转换函数来实现。
总的来说，隐式类型转换是编译器自动进行的，而显式类型转换需要用户明确指定转换的类型。在编程时，应根据具体情况选择合适的类型转换方式，以确保程序的正确性和安全性。

面试题5：`static_cast`、`dynamic_cast`、`reinterpret_cast` 和 `const_cast` 之间的区别是什么？

static_cast 、 dynamic_cast 、 reinterpret_cast 和 const_cast 是 C++ 中的四种类型转换运算符，它们各有不同的用途和限制。
static_cast
这种类型是最常用的类型转换。它主要用于非多态类型之间的转换，如基本数据类型之间的转换、空指针和空指针之间的转换、非多态类类型之间的转换（如类和结构之间的转换）等。static_cast在编译时进行类型检查，但不会进行运行时检查，因此转换的安全性相对较低。如果转换类型不兼容，编译器会报错。
dynamic_cast
这种类型转换主要用于多态类型之间的转换。它通常用于类和子类之间的转换，特别是当子类对象被当作基类对象使用时。 dynamic_cast 在运行时进行类型检查，因此比 static_cast 更安全。如果转换失败（例如，试图将基类对象转换为派生类对象，而该对象实际上不是派生类对象）， dynamic_cast 会返回空指针。需要注意的是， dynamic_cast 要求转换类型必须是指针或引用，并且转换的类必须有虚函数。
reinterpret_cast
这种类型转换是最危险的，因为它允许在任意类型之间进行转换，而不需要任何类型兼容性检查。 reinterpret_cast 通常用于位字段和硬件地址等低级操作。由于它不进行任何类型检查，因此使用时要格外小心，以避免出现未定义行为。
const_cast
这种类型转换用于修改类型的 const 或 volatile 属性。 const_cast 允许程序员在 const 和非 const 对象之间进行转换，或者在 volatile 和非 volatile 对象之间进行转换。然而，尽管 const_cast 可以移除 const 属性，但它并不能改变对象的实际值，因此不能用于修改 const 对象的值。
总的来说，这四种类型转换运算符各有其特点和适用场景。在选择使用哪种转换时，应根据具体的需求和场景来决定。一般来说，应优先使用 static_cast 和 dynamic_cast ，因为它们提供了类型检查，可以提高代码的安全性。而 reinterpret_cast 和 const_cast 应谨慎使用，因为它们可能导致未定义行为或违反类型安全。

面试题6：枚举类型能否与整数类型进行比较和转换？

在C++中，枚举类型可以与整数类型进行比较和转换，尽管这种做法可能不是最佳实践，因为它可能会破坏枚举类型的类型安全性。
比较
枚举值可以直接与整数进行比较，因为枚举值在内部实际上是整数。例如：

enum Color { RED = 1, GREEN = 2, BLUE = 3 };

Color myColor = GREEN;

if (myColor == 2) 
{
    // 这个条件将为真，因为 GREEN 的值为 2
}

然而，直接比较枚举值和整数可能会使代码难以理解和维护。更好的做法是使用枚举值进行比较：

if (myColor == GREEN)
{
    // 更清晰的方式来表达条件
}

转换
枚举到整数
枚举值可以隐式地转换为整数，因为它们在内部就是整数表示。例如：

int colorValue = GREEN; // 隐式转换，colorValue 现在是 2

也可以进行显式转换，以更清楚地表达转换意图：

int colorValue = static_cast<int>(GREEN); // 显式转换

整数到枚举
同样地，整数也可以转换为枚举类型，但这种转换应该小心进行，以避免产生无效的枚举值。例如：

Color myColor = static_cast<Color>(2); // myColor 现在是 GREEN

但是，如果转换的整数不在枚举定义的有效范围内，结果将是一个有效的枚举类型，但可能不代表任何有意义的值：

Color myColor = static_cast<Color>(99); // myColor 现在是一个无效的枚举值

尽管 C++ 允许枚举和整数之间的比较和转换，但最佳实践是尽量避免这样做，以保持代码的清晰性和类型安全。如果确实需要进行比较或转换，最好使用显式转换，并在可能的情况下限制在有效范围内。此外，对于枚举值的比较，最好使用枚举常量而不是直接的整数值。

面试题7：`bool` 类型在C++中是如何实现的？

在 C++ 中， bool 类型是一个基本数据类型，用于表示逻辑值 true 或 false 。然而， bool 类型在底层是如何实现的，实际上取决于编译器和操作系统。 C++ 标准并没有规定 bool 的具体大小和内存布局，只规定了它的行为。
在大多数现代编译器和系统中， bool 类型通常被实现为一个足够小的整数类型，通常是 char 类型的大小（即 1 字节）。这是因为将 bool 实现为整数类型可以方便地将其转换为其他整数类型，并且可以利用整数的位操作来操作布尔值。

面试题8：如何在不用到临时变量的情况下交换两个变量的值？

可以使用位异或操作来交换两个变量的值，如下为样例代码：

#include <iostream>  

int main() 
{
	int a = 1;
	int b = 2;

	// 原始值  
	std::cout << "before swap: a = " << a << ", b = " << b << std::endl;

	// 使用位异或操作交换值  
	a = a ^ b;
	b = a ^ b;
	a = a ^ b;

	// 交换后的值  
	std::cout << "after swap: a = " << a << ", b = " << b << std::endl;

	return 0;
}

上面代码的输出为：

before swap: a = 1, b = 2
after swap: a = 2, b = 1

上面代码使用了三次异或操作来交换 a 和 b 的值。异或操作有一个特性：同一个数与它自身异或的结果是 0 ，与 0 异或的结果还是它自身。因此，通过三次异或运算，可以实现两个变量的值的交换。
以下是交换过程的解释：
第一次异或：a = a ^ b 。此时， a 存储了 a 和 b 的异或结果，而 b 的值保持不变。
第二次异或：b = a ^ b 。由于此时的 a 是 a 和 b 的异或结果， b 是原始的 b 值，所以 b 现在存储了 a 的原始值。
第三次异或：a = a ^ b 。由于此时的 a 是 a 和 b 的异或结果， b 是 a 的原始值，所以 a 现在存储了 b 的原始值。
通过这种方式，可以使用位操作交换了 a 和 b 的值。这种方法在不需要临时变量的情况下交换两个变量的值是非常有用的。