blocks|key|2904130|text|不，抛出一个char数组是有问题的。只是你应该收到的，|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2904131|catch(const+char*+const+errorMessage)+{...}|code-block|syntax|javascript|2904132|第一个const是添加接收任何char+char*+const+char*+char[]+const+char[]的功能|2904133|第二个const用于指定errorMessage不打算在catch数据块内更改|2904134|entityMap^0|6|4|0|0|3|5|F|4|K|5|Q|B|12|6|19|C|0|3|5|C|C|S|5|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|17|8|@$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]]|P|$]]

No there is problem with throwing a <code>char</code> array. Just that you should receive as,

<pre><code>catch(const char* const errorMessage) {...}
</code></pre>

1st <code>const</code> is to add ability to receive any <code>char</code> array <code>char*</code> <code>const char*</code> <code>char[]</code> <code>const char[]</code>

2nd <code>const</code> is to specify that <code>errorMessage</code> is not intended to change within <code>catch</code> block

blocks|key|1002565|text|一般的问题是，不能轻松地过滤异常并根据类型对其执行操作。但是，我不知道是否有特定于C%2B%2B的原因不这样做|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1002566|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

There is the general issue of not being able to easily filter your exceptions and act on them based on type. However, i don't know if there is a C++ specific reason not to do it

blocks|key|1002590|text|抛出一个标准的异常对象要好得多。通常，最佳实践是抛出从std::exception派生的东西，以便在某些情况下确实导致程序终止时，实现有更好的机会打印有用的诊断信息。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1002591|因为这样做并不难，所以我永远不会推荐抛出一个原始的字符串文字。|1002592|#include+<stdexcept>

void+someFunction()
{
++++try+{
++++++++//+code
++++++++if+(some+error)+{
++++++++++++throw+std::runtime_error(+"Description+of+error."+);
++++++++}
++++}
++++catch+(const+std::exception&+ex)+{
++++++++std::cerr+<<+ex.what()+<<+"\nFatal+error"+<<+std::endl;
++++}
}|code-block|syntax|javascript|1002593|entityMap^0|R|E|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|S|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

It is much better to throw a standard exception object. In general, the best practice is to throw something derived from <code>std::exception</code> so that if in some situation it does cause your program to terminate, the implementation has a better chance of printing a useful diagnostic.

Because it isn't hard to do this, I would never recommend throwing a raw string literal.

<pre><code>#include &lt;stdexcept&gt;

void someFunction()
{
 try {
 // code
 if (some error) {
 throw std::runtime_error( "Description of error." );
 }
 }
 catch (const std::exception&amp; ex) {
 std::cerr &lt;&lt; ex.what() &lt;&lt; "\nFatal error" &lt;&lt; std::endl;
 }
}
</code></pre>

blocks|key|4693105|text|exception(或者至少是std::runtime_error)包含一个字符串，可以通过what()方法访问该字符串。你能做的最好的事情就是使用它，因为它是标准的，而且其他代码可以期待它，而且因为它无论如何都可以服务于你的目的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4693106|在这种情况下，最好坚持标准。|4693107|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

std::exception (or at least, std::runtime_error) contains a string, that can be accessed through the what() method. Best thing you can do is to use that, since it's standard, and other code can expect it, and since it serves your purpose anyway.

Better stick to the standard in this case.

blocks|key|1002661|text|抛出字符串文字通常不是一个好主意，因为随着代码的发展，程序员可能需要用一些更多的信息来丰富错误消息，例如变量的值，或者抛出异常的行号。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1002662|给定捕获const+char*的未知客户端代码，鼓励程序员使用更动态的机制来连接所需的信息：|offset|length|style|CODE|1002663|1002664|是std::string和字符缓冲区，也可能是strcat和/或|unordered-list-item|1002665|1002666|1002667|1002668|使用这些方法的最明显的方法不起作用或者不起作用：|1002669|//+temporaries...
throw+(std::string("couldn't+parse+input:+")+%2B+input).c_str();
throw+(std::ostringstream()+<<+"error+line+"+<<+__LINE__).str().c_str();
char+buf[1024];+sprintf(buf,+"error+line+%25ld%25",+__LINE);+throw+buf;

//+not+thread-safe
static+char+buf...|code-block|syntax|javascript|1002670|即使程序员知道不要这样做，他们仍然有机会找到需要开始接受更丰富的值类型的所有客户端代码，特别是如果const+char*的其他throw/catch用法持续存在的话。|1002671|因此，使用一个通过值嵌入灵活的std::string描述的类对于编写可维护的代码非常重要。|1002672|entityMap^0|0|4|B|0|0|1|B|N|6|1|1|0|0|0|0|1D|B|1R|5|1X|5|0|F|B|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@$D|13|E|14|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|15|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|16|8|@$D|17|E|18|F|G]|$D|19|E|1A|F|G]]|9|@]|A|$]]|$1|L|3|-4|5|K|7|1B|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1E|8|@]|9|@]|A|$]]|$1|Q|3|R|5|S|7|1F|8|@]|9|@]|A|$T|U]]|$1|V|3|W|5|6|7|1G|8|@$D|1H|E|1I|F|G]|$D|1J|E|1K|F|G]|$D|1L|E|1M|F|G]]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1N|8|@$D|1O|E|1P|F|G]]|9|@]|A|$]]|$1|Z|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]]|10|$]]

Throwing a string literal is generally a bad idea because, as the code evolves, programmers may need to enrich the error message with some more information, e.g. the value of a variable, or the line number from which the exception is thrown.

Given unknown client code that's catching <code>const char*</code>, the programmer's encouraged to use a more dynamic mechanism to concatenate desired information:

<ul>
<li>a <code>std::string</code> and <code>+</code></li>
<li>a <code>std::ostringstream</code></li>
<li>a char buffer and perhaps <code>strcat</code> and/or <code>sprintf()</code></li>
</ul>

The most obvious ways of using these don't work or don't work well:

<pre><code>// temporaries...
throw (std::string("couldn't parse input: ") + input).c_str();
throw (std::ostringstream() &lt;&lt; "error line " &lt;&lt; __LINE__).str().c_str();
char buf[1024]; sprintf(buf, "error line %ld%", __LINE); throw buf;

// not thread-safe
static char buf...
</code></pre>

Even if the programmer knows not to do any of these, they'll still have a right time finding all the client code that needs to start accepting a richer value type, especially if other <code>throw</code>/<code>catch</code> usage of <code>const char*</code> persists.

So, using a class that embeds a flexible <code>std::string</code> description by value is very important for writing maintainable code.

blocks|key|4693166|text|如果您将字符串作为错误抛出是为了方便向用户显示错误，请考虑这将使本地化应用程序变得更加困难(尽管您可能担心也可能不担心)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4693167|此外，如果应用程序的另一部分需要了解错误是什么，以便能够对其做出反应(例如，如果是断开连接错误，请尝试自动重新连接，但如果是密码错误，则只向用户显示错误消息)，最好为异常捕获器提供某种类型的错误代码。|4693168|在我们的应用中，我们的异常是从std::exception派生的。它们包含错误类型(枚举)、调试错误消息(包括文件/行号)和本地化的错误字符串。|4693169|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

If your idea of throwing a string as an error was for convenience of showing the error to the user, consider that this would make localizing your application more difficult (may or may not be a concern to you though).

Also if another part of the application needs to understand what the error is so it can react to it (eg if it is a disconnect error, try to reconnect automatically, but if it's a password error, just show error message to the user), it is better to have some sort of error code available to the exception catcher.

In our app, our exceptions are derived from std::exception. They contain an error type (an enum), a debug error message (including file/line number), and a localized error string.

blocks|key|2904311|text|我认为这要简单得多。:)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2904312|#include+<iostream>
#include+<exception>

using+namespace+std;

int+main()+{
++++try+{
++++++++throw+runtime_error("This+is+an+Error");+
++++}catch+(exception&+e){
++++++++cout+<<+"Exception:+"+<<+e.what()+<<+endl;+
++++}
++++return+0;+
}|code-block|syntax|javascript|2904313|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I think this is much more simpler. :). 

<pre><code>#include &lt;iostream&gt;
#include &lt;exception&gt;

using namespace std;

int main() {
 try {
 throw runtime_error("This is an Error"); 
 }catch (exception&amp; e){
 cout &lt;&lt; "Exception: " &lt;&lt; e.what() &lt;&lt; endl; 
 }
 return 0; 
}
</code></pre>

I am working on a small c++ program and learning exceptions. Is the following code "bad", and if so, what can I do to improve it?

<pre><code>try {
 // code
 if (some error) {
 throw "Description of error.";
 }
}
catch (char* errorMessage) {
 cerr &lt;&lt; errorMessage &lt;&lt; endl &lt;&lt; "Fatal error";
}
</code></pre>

Is there anything wrong with throwing a <code>char</code> array as an exception?

EDIT:
Would this be a better way to go?

<pre><code>const char errorMessage[] = "Description of error";

try {
 // code
 if (some error) {
 throw errorMessage;
 }
}
catch (char* errorMessage) {
 cerr &lt;&lt; errorMessage &lt;&lt; endl &lt;&lt; "Fatal error";
}
</code></pre>

C++ Exceptions - Is throwing c-string as an exception bad?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我正在开发一个小的c++程序并学习异常。下面的代码是“坏的”吗?如果是的话，我能做些什么来改进它呢？try {    // code    if (some error) {        throw "Description of error.";    }}catch (char* errorMessage) { ...

问字符串异常-抛出c- C++作为异常是不好的吗？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问字符串异常-抛出c- C++作为异常是不好的吗？EN