c++ 防止隐式转换 explicit

最新推荐文章于 2024-03-22 10:54:26 发布
最新推荐文章于 2024-03-22 10:54:26 发布
阅读量1.5k 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/lyyslsw1230_163com/article/details/9197779
博客介绍了在C++中，可在类的构造函数前声明为explicit，以此防止隐式转换，这是C++编程里关于构造函数使用的一个重要技巧。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

在c++ 类的构造函数之前声明为explicit，防止隐式转换。
C++11 为何要禁用构造函数的隐式转换（explicit）
二进制君
12-01 1万+
按照默认规定，只有一个参数的构造函数也定义了一个隐式转换，将该构造函数对应数据类型的数据转换为该类对象，如下面所示： class String { String(const char* p ); // 用C风格的字符串p作为初始化值 } String s1 = “hello”; //OK 隐式转换，等价于String s1 = String（“hello”）; 但是有的时候可能会不需要这种隐式转换，如下： class String { String ( int n ); //本意是预先分配
C++(11)：禁止隐式类型转换
风静如云的博客
04-17 2698
C++类的类型转换符默认是开启隐式转换的： #include <iostream> using namespace std; class B{ public: B() { cout<<"Construct B, this addr:"<<this<<endl; } B(const B& b) { cout<<"Copy Construct B, origin b addr:"<<&b<&lt
c++关键字之explicit
bai_lu_sz的专栏
02-16 661
C++中的explicit  构造函数需要显示调用 C++提供了关键字explicit，可以阻止不应该允许的经过转换构造函数进行的隐式转换的发生。声明为explicit的构造函数不能在隐式转换中使用。 C++中， 一个参数的构造函数(或者除了第一个参数外其余参数都有默认值的多参构造函数)， 承担了两个角色。 1 是个构造器 2 是个默认且隐含的类型转换操作符。 所以， 有时候在我们写
More Effective C++ 阅读笔记(四)-- 避免使用隐式类型转换
08-06 679
 More Effective C++ 阅读笔记(四)-- 避免使用隐式类型转换黑月亮 发表于 2005-10-3 15:38:00  让编译器进行隐式类型转换所造成的弊端要大于它所带来的好处，所以除非你确实需要，不要定义类型转换函数。隐式类型转换的缺点：它们的存在将导致错误的发生。例如:class Rational {public:  ...  operator double() con
C/C++编程：通过重载避免隐式类型转换
OceanStar的博客
08-30 515
以下是一段代码，如果没有什么不寻常的原因，实在看不出什么东西： class UPInt { // unlimited precision public: // integers 类 UPInt(); UPInt(int value); ... }; const UPInt operator+(const UPInt& lhs, const .
C++禁止隐式转换之explicit用法(八)
Android系统攻城狮
03-07 1288
1.隐式类型转换 #include &lt;iostream&gt; using namespace std; class Test { public： Test（int num){ cout &lt;&lt; __FUNCTION__ &lt;&lt; "(), num = " &lt;&lt; num &lt;&lt; endl; } } int main()...
C++隐式转换问题分析及解决办法
08-24
* 使用 explicit 关键字来禁止隐式转换。 * 使用 static_cast 或 dynamic_cast 进行显式类型转换。 * 使用 sizeof 运算符来检查变量的类型和大小。 * 避免使用隐式转换，尽量使用显式类型转换。 结论 ---------- ...
【C++】详谈explicit关键字背后的隐式类型转换和编译器优化
DanteKing的博客
02-07 1035
开场白 本来想总结一下explicit关键字的用法，结果看了官方文档发现能给拷贝构造加explicit，我就去试了试 试了之后，又发现了两个大坑：隐式类型转换和编译器优化，本来我以为我很久以前就理解了这俩概念，但是一系列实验结果表明这并不是那么简单 这两个坑折磨得我欲仙欲死 首先贴一下我们一直说的编译器优化是什么，官网的定义 编译器优化学名叫：拷贝省略 Copy elision Omits copy and move (since C++11) constructors, resulting in zer
C++ 类的隐式转换
digitalkee的博客
03-25 620
所谓类的隐式转换，就是将实参类型转成形参类型--如果不一致的话。 这个转换与基本类型转换不太一样，具体则是在形参类型的构造函数中使用实参类型的数据，从而构造出一个临时对象。 下面的代码，类Person的成员函数isSamePerson(const Person &person) const，理论上需要一个Person 引用，但实际上被传递了一个string对象！ 编译...
c++避免隐式转换
LaineGates的专栏
01-28 6294
C++有一个很方便的功能—隐式转换，比如有一个函数 void func(double f); 调用它的时候 func(5); func(5.0); 都是有效的。 但有时候，这个功能就很麻烦了。比如： class A｛ public: A(const string&amp;v){ ///... } ｝ void ...
c++防止构造函数隐式转换示例
DriverMonkey的专栏
04-05 1097
<br />/*******************************************************<br /> *author：彭晓林<br /> *copyright: 版权所有，翻版不究<br /> *function: 防止s构造函数隐式转换示例<br /> ******************************************************/<br />#include <iostream><br />#include <string><br />u
2-1 C++类的转换函数与禁止隐士转换(explicit)
baidu_41922918的博客
11-15 1169
C++类的转换函数与explicit关键字禁止隐士转换
More Effective C++ 21：通过重载避免隐式类型转换
qq_44800780的博客
06-21 348
考虑以下类： class UPInt { public: UPInt(); UPInt(int value); ... }; const UPInt operator+(const UPInt& lhs, const UPInt& rhs); UPInt upi1, upi2; ... UPInt upi3 = upi1 + upi2; 现在考虑下面这些语句： upi3 = upi1 + 10; upi3 = 10 + upi2; 这些语句也能够成功运行。方法是通过建
c++设计中可以利用重载避免隐式类型转换
qq_37185716的博客
08-05 404
首先，先看一个例子： class UPInt { public: UPInt(); UPInt(int value); ... } const UPInt operator +(const UPInt& object1,const UPInt& object2); UPInt object1,object2; UPInt object3=object1+object2;//调用o
C++隐式类型转换
onlyou2030的博客
09-26 347
C++ primer 中有这么一句话：可以用单个实参来调用的构造函数定义了从形参类型到该类型的一个隐式转换。 这么解释： 比如有个类A的对象a的成员函数的参数应该是类A的对象，但是把一个别的类型B的对象b传进去了，而且这个对象b的类型恰好是A的单参数构造函数参数类型，这时系统就用这个b自作聪明的创建了一个类A的临时对象c，虽然c和a都是A类型，但是是不同的对象。 这种隐式转换有很大风险，可以
C++编程规范之40：要避免提供隐式转换
longshengguoji的专栏
01-13 1864
摘要：     并非所有的变化都是进步。隐式转换所带来的影响经常是弊大于利。在为自定义类型提供隐式转换之前，请三思而行，应该依赖的是显示转换。     隐式转换主要有两个主要的问题：     1.它们会在最意料不到的地方抛出异常。     2.他们并步总是能与语言的其他元素有效地配合。     隐式转换构造函数与重载机制配合得很糟糕，而且会使不可见的临时对象到处出现。在C++中，一个转换
C++编程规范之29：考虑重载，以避免隐式类型转换
longshengguoji的专栏
12-21 1690
摘要：     如无必要勿增对象：因素类型转换提供了语法上的便利。但是如果创建临时对象的工作并不不要而且适于优化，那么可以提供签名与常见参数类型精确匹配的重载函数，而且不会导致转换。 隐式转换最常见的例子是字符串的比较，见如下程序： class string { //...... String(const char* text); }; boolopera
More Effective C++之 Item M21：通过重载避免隐式类型转换
janeqi1987的专栏
11-13 178
以下是一段代码，如果没有什么不寻常的原因，实在看不出什么东西： class UPInt { // unlimited precision public: // integers 类 UPInt(); UPInt(int value); ...
C++类定义中的隐式类型转换问题分析
qq_53324833的博客
03-22 426
最近看《C++ Primer》这本书时，遇到了一个比较抽象的问题，书上的内容描述的也比较抽象，感觉不好理解。因此我去搜索了一些资料再结合书籍原文大致弄清楚了C++在类定义中的隐式类型转换的问题，文末有书中原文内容截图，建议在看本文分析之前，先去看看这本书对应这一个问题的描述与解释，我就不再赘述，查看原书内容可以直接跳转到文末。
c++隐式转换
最新发布
03-17
### C++ 中隐式类型转换的工作原理及用法 #### 工作原理 C++ 支持多种类型的隐式转换，这些转换可以在编译期由编译器自动完成。隐式类型转换主要分为两类：内置类型的隐式转换和用户自定义类型的隐式转换。 对于 **内置类型** 的隐式转换，当不同数据类型之间存在兼容关系时，编译器会尝试将一种类型的数据转换为另一种类型[^2]。例如，在赋值语句 `int i = 'A';` 中，字符 `'A'` 被隐式地转换为整数值 65（ASCII 编码对应的值）。这种转换属于标准转换的一部分，称为 **标准转换 (Standard Conversion)**[^4]。 对于 **用户自定义类型** 的隐式转换，则通过构造函数或类型转换运算符实现。如果某个类提供了一个接受单一参数的构造函数，并且未声明为 `explicit`，那么这个构造函数就可以被用来执行隐式类型转换。例如： ```cpp class C { public: C(int x) : _x(x) {} // 单参构造函数 private: int _x; }; void func(C c) {} int main() { func(10); // 隐式调用了 C 的单参构造函数 } ``` 上述代码展示了如何利用单参构造函数进行隐式类型转换。这里，整数 `10` 被隐式地转换为类 `C` 的实例并传递给函数 `func`[^3]。 此外，还可以通过定义类型转换运算符来支持从类到其他类型的隐式转换。然而，默认情况下，这种方式可能会引发意外的行为，因此建议使用关键字 `explicit` 来禁用不必要的隐式转换。例如： ```cpp class MyClass { public: explicit operator int() const { return 42; } }; MyClass obj; // 错误：无法隐式转换为 int int i = obj; // 正确：需要显式转换 i = static_cast<int>(obj); ``` 在此例子中，由于 `operator int()` 前加了 `explicit` 关键字，所以不再允许从 `MyClass` 到 `int` 的隐式转换。 #### 示例代码 下面是一个完整的示例程序，演示了不同类型之间的隐式转换及其控制方法： ```cpp #include <iostream> class A { public: A(int val) : value(val) {} void display() const { std::cout << "Value: " << value << '\n'; } private: int value; }; class B { public: explicit operator double() const { return 3.14; } private: int data; }; int main() { // 内置类型间的隐式转换 char ch = 'a'; int num = ch; // 字符转整型 std::cout << "Char to Int: " << num << '\n'; // 用户定义类型的隐式转换 A a_obj = 10; // 使用单参构造函数创建对象 a_obj.display(); // 显式转换防止潜在错误 B b_obj; double d_val = static_cast<double>(b_obj); // 必须显式转换 std::cout << "B to Double: " << d_val << '\n'; return 0; } ``` 此代码片段涵盖了多个方面的内容，包括但不限于： - 内置类型的隐式转换； - 用户定义类型的隐式转换； - 使用 `explicit` 控制隐式转换行为。 --- ###
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值