这样的铸造安全吗？

发布于 2024-09-04 06:06:27 字数 540 浏览 2 评论 0原文

我需要编写一个 Util 函数（在我的 c++cli 应用程序中）将 String 转换为 Double 或 Float 或 Int。

template<typename T>
static T MyConvert(String^ str) {
     return static_cast<T>(System::Convert::ToDouble(str));
}

这样安全吗？
如果我调用 MyConvert("2") ，它能以某种方式将 2 转换为 1.999，然后再转换为 1 吗？
我想知道为什么 Convert 类一开始就没有模板化？（这会让我对所有类型调用 Convert 而不是 Convert.ToDouble()）
这是 C++/Cli，所以我可以使用 c++ 或 .net 中的任何转换方法，但我只知道 Convert.ToDouble()|ToString()|ToInt32())

原文

I need to write a Util function (in my c++cli app) that converts a String to a Double or Float or Int.

template<typename T>
static T MyConvert(String^ str) {
     return static_cast<T>(System::Convert::ToDouble(str));
}

Is this safe?
Can it somehow convert 2 to 1.999 and then to 1 if I call MyConvert<int>("2") ?
I was wondering why the Convert class isn't templated in the first place? (That would let me call Convert<T> instead of Convert.ToDouble() for all types)
This is C++/Cli so I can use any convert methods in c++ or .net, but I only know Convert.ToDouble()|ToString()|ToInt32())

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

愁杀 2024-09-11 06:06:27

在非 CLI 环境中编写的方式意味着类似“

   template <typename T> 
   T GetValue (const std::string& value) const
   {
      T t;


      try
      {
         t = boost::lexical_cast<T>(value);
      } 
      catch (const boost::bad_lexical_cast&) {
         // It's horrible!
         // (...)
      }

      return t;
   }

注意此转换是有效的”，因为只完成了适当的转换。 在您的情况下，转换为 int 意味着调用转换为 double （这可能，而且我怀疑比普通转换为 int 效率低）以及您的 static_cast< 的邪恶舍入/code>.

为什么倾向于这样做？

尝试与我在示例中使用的相同方法，但移植到 CLI。将您的模板专门用于 MyConvert、MyConvert 调用，甚至创建两个单独的方法（因为仅使用两个编写模板函数strong> 合适的模板参数不是设计应用程序的最佳方式）。

这些方法/模板特化中的每一个都意味着调用适当的 ToYyy 例程并返回相应类型的结果。

The way this is written in non-CLI environment would mean something like

   template <typename T> 
   T GetValue (const std::string& value) const
   {
      T t;


      try
      {
         t = boost::lexical_cast<T>(value);
      } 
      catch (const boost::bad_lexical_cast&) {
         // It's horrible!
         // (...)
      }

      return t;
   }

Note that this conversion is efficient, because only the appropriate conversion is done. In your case, converting to int would mean invoking conversion to double (which could, and I suspect is less-efficient than plain conversion to int) and evil rounding by your static_cast.

Why even tend to do that?

Try the same approach as I used in my sample, but ported to CLI. Specialize your templates for MyConvert<int>, MyConvert<double> calls or even make two separate methods (because writing template function with only two suitable template parameters isn't the best way to design your application).

Each of these methods / template specializations would mean calling the appropriate ToYyy routine and returning the result of the according type.

回复收藏 0 原文

~没有更多了~