C++ 类型修饰符

風清掦

已于 2024-09-28 15:43:32 修改

阅读量1.7k

点赞数 1

分类专栏： C++ 文章标签： c++ 开发语言经验分享

于 2022-01-03 16:01:14 首次发布

本文链接：https://blog.csdn.net/weixin_60461563/article/details/122287952

版权

C++ 专栏收录该内容

34 篇文章 5 订阅

订阅专栏

数据类型修饰符

C++ 允许在 char、int 和 double 数据类型前放置修饰符。修饰符用于改变基本类型的含义，所以它更能满足各种情境的需求。下面列出了数据类型修饰符：

signed：表示变量可以存储负数。对于整型变量来说，signed 可以省略，因为整型变量默认为有符号类型。
unsigned：表示变量不能存储负数。对于整型变量来说，unsigned 可以将变量范围扩大一倍。
short：表示变量的范围比 int 更小。short int 可以缩写为 short。
long：表示变量的范围比 int 更大。long int 可以缩写为 long。
long long：表示变量的范围比 long 更大。C++11 中新增的数据类型修饰符。
float：表示单精度浮点数。
double：表示双精度浮点数。
bool：表示布尔类型，只有 true 和 false 两个值。
char：表示字符类型。
wchar_t：表示宽字符类型，可以存储 Unicode 字符。

修饰符 signed、unsigned、long 和 short 可应用于整型，signed 和 unsigned 可应用于字符型，long 可应用于双精度型。

修饰符 signed 和 unsigned 也可以作为 long 或 short 修饰符的前缀。例如：unsigned long int。 C++ 允许使用速记符号来声明无符号短整数short或无符号长整数long。可以不写 int，只写单词 unsigned short 或 unsigned long，int 是隐含的。例如，下面的两个语句都声明了无符号整型变量。

unsigned short x;
unsigned long y;   //相当于unsigned unsigned long int y;

以下实例演示了有符号整数和无符号整数之间的差别：

#include <iostream>
using namespace std;

int main()
{
     /*有符号短整数；位宽度：2 个字节；存储范围-32768 到 32767*/ 
	short int i;          
    /*无符号短整数；位宽度：2 个字节；存储范围   0   到 65535*/ 
	unsigned short int j;  
	 
	j = 50000;
	i = j;  //50000超出了short int的取值范围所能存储，产生上溢 

	cout << i << " " << j;

	return 0;
}

编译和执行上面的代码：

-15536 50000

分析一下-15536的由来：当计算数字过大，超过当前类型能表达的范围时，就会发生上溢。short int的取值范围为：-32768 到 32767，而unsigned short int的取值范围为0 到 65,535。50000在unsigned short int的取值范围内，将其赋值给short int会溢出，

计算一下-15536的得来，50000-32767=17,233‬，-32768+（17,233‬+1）=-15536

可以把无符号短整数j看作是汽车的里程表。当达到它能表示的最大值时，会重新从起始点开始。整数 i 也是类似的情况。

主要的区别是：在超过最大值时，unsigned short int（或unsigned short ）类型的变量 j 从 0开始；而short int类型的变量i则从 -32768开始。

注意，当i超出（溢出）其相应类型所能表示的最大值时，系统并未通知。因此，在编程时必须自己注意这类问题。溢出行为是未定义的行为，C\C++标准并未定义有符号类型的溢出规则。以上描述的溢出行为比较有代表性，但是也可能会出现其他情况。

类型限定符

类型限定符提供了变量的额外信息(修饰符用于改变基本类型的含义，注意区分)。

限定符	含义
const	const 定义常量，表示该变量的值不能被修改。
volatile	修饰符 volatile 告诉该变量的值可能会被程序以外的因素改变，如硬件或其他线程。。
restrict	由 restrict 修饰的指针是唯一一种访问它所指向的对象的方式。只有 C99 增加了新的类型限定符 restrict。
mutable	表示类中的成员变量可以在 const 成员函数中被修改。
static	用于定义静态变量，表示该变量的作用域仅限于当前文件或当前函数内，不会被其他文件或函数访问。
register	用于定义寄存器变量，表示该变量被频繁使用，可以存储在CPU的寄存器中，以提高程序的运行效率。
explicit	用于修饰类的构造函数，以防止构造函数在只有一个参数时被隐式地用于类型转换。

const 实例

const int NUM = 10;     // 定义常量 NUM，其值不可修改
const int* ptr = &NUM;  // 定义指向常量的指针，指针所指的值不可修改
int const* ptr2 = &NUM; // 和上面一行等价

volatile 实例

volatile int num = 20; // 定义变量 num，其值可能会在未知的时间被改变

mutable 实例

class Example 
{
public:
    int get_value() const 
    {
        return value_; // const 关键字表示该成员函数不会修改对象中的数据成员
    }
    void set_value(int value) const 
    {
        value_ = value; // mutable 关键字允许在 const 成员函数中修改成员变量
    }
private:
    mutable int value_;
};

static 实例

void example_function() 
{
    static int count = 0; // static 关键字使变量 count 存储在程序生命周期内都存在
    count++;
}

register 实例

void example_function(register int num) 
{
    // register 关键字建议编译器将变量 num 存储在寄存器中
    // 以提高程序执行速度
    // 但是实际上是否会存储在寄存器中由编译器决定
}

explicit 实例

当有一个类的构造函数，它接受一个参数，并且这个类没有定义其他接受单个参数的构造函数时，编译器可能会自动地使用这个构造函数来进行类型转换，即将该参数类型的对象隐式地转换为类类型的对象。然而，在某些情况下，这种隐式转换可能会导致代码难以理解和维护，特别是当构造函数执行了除了简单转换之外的额外操作时。

通过使用explicit关键字，可以明确地禁止这种隐式转换，要求程序员在需要时显式地进行类型转换。

没有使用explicit的情况：

class MyClass {  
public:  
    MyClass(int value) {  
        // 构造函数体  
    }  
};  
  
void function(MyClass obj) {  
    // 函数体  
}  
  
int main() {  
    int x = 10;  
    function(x); // 隐式转换：调用MyClass(int)来创建MyClass对象  
    return 0;  
}

在这个例子中，int类型的x被隐式地转换为MyClass类型的对象，因为MyClass有一个接受int的构造函数。

使用explicit的情况：

class MyClass {  
public:  
    explicit MyClass(int value) {  
        // 构造函数体  
    }  
};  
  
void function(MyClass obj) {  
    // 函数体  
}  
  
int main() {  
    int x = 10;  
    function(x); // 错误：需要显式转换  
    function(MyClass(x)); // 正确：显式转换  
    return 0;  
}

在这个修改后的例子中，尝试隐式地将int类型的x转换为MyClass类型的对象会导致编译错误。为了通过编译，你必须显式地创建一个MyClass对象，例如使用MyClass(x)。