If you do a `throw;` on its own, and there isn&#39;t a current exception for it to rethrow, then the program ends abruptly. (More specifically, `terminate()` is called.)

Note that throw; is the only safe way to re-throw the current exception - it&#39;s not equivalent to

`catch (exception const &amp; e) { throw e; }`

Yes, it specified behavior, it will call terminate;

&gt; 15.1, para 8: If no exception is presently being handled, executing a
&gt; throw expression with no operand calls
&gt; terminate() (15.5.1).

That&#39;s so-called exception handler. It rethrows the &quot;current exception&quot; if any. If there&#39;s no exception currently being handled [`terminate()` will be called][1].


  [1]: https://stackoverflow.com/q/981400/57428

This is my code.

    public class SubFunction {
    	private String drawTribleX(){
    		return trible(&quot;X&quot;);
    	}
    	private String trible(String t){
    		return t + t + t;
    	}
    	public static void main(String[] args){
    		SubFunction o = new SubFunction();
    		System.out.println(o.drawTribleX());
    	}
    }

Can I do something like this ?

    public class SubFunction {
    	private String drawTribleX(){
    		// *** move trible(t) inside drawTribleX() ***
    		private String trible(String t){
    			return t + t + t;
    		}
    		return trible(&quot;X&quot;);
    	}
    	public static void main(String[] args){
    		SubFunction o = new SubFunction();
    		System.out.println(o.drawTribleX());
    	}
    }

Thank you.

Does Java support inner / local / sub methods?

This is almost exactly a duplicate of [Examining a single changeset in Mercurial][1], and without doubt a duplicate of another question I can&#39;t find on SO through Google alone. 

I&#39;m looking back through a Mercurial repo, and I want to see what exactly changed between two revisions (let&#39;s say 2580 and 2581):

    hg log -v -r 2581 

gives me all the **files** that changed.

How can I also see the **diffs** of these files?

Thanks.


  [1]: https://stackoverflow.com/questions/2550721/examining-a-single-changeset-in-mercurial

Mercurial: diffs in a particular changeset?

These days, I have been reading a lot the [C++ F.A.Q][1] and especially [this page][2].

Reading through the section I discovered a &quot;technique&quot; that the author calls &quot;exception dispatcher&quot; that allows someone to group all his exception handling in one handy function:

    void handleException()
    {
      try {
        throw; // ?!
      }
      catch (MyException&amp; e) {
        //...code to handle MyException...
      }
      catch (YourException&amp; e) {
        //...code to handle YourException...
      }
    }
     
    void f()
    {
      try {
        //...something that might throw...
      }
      catch (...) {
        handleException();
      }
    }

What bothers me is the single `throw;` statement: if you consider the given example then sure, it is obvious what it does: it rethrows the exception first caught in `f()` and deals with it again.

But what if I call `handleException()` on its own, directly, without doing it from a `catch()` clause ? Is there any specified behavior ?

Additionally for bonus points, is there any other &quot;weird&quot; (probably not the good word) use of `throw` that you know of ?

Thank you.


  [1]: http://www.parashift.com/c++-faq-lite/
  [2]: http://www.parashift.com/c++-faq-lite/exceptions.html

What does a single &quot;throw;&quot; statement do?

These days, I have been reading a lot the <a href="http://www.parashift.com/c++-faq-lite/" target="_blank" rel="noopener noreferrer">C++ F.A.Q</a> and especially <a href="http://www.parashift.com/c++-faq-lite/exceptions.html" target="_blank" rel="noopener noreferrer">this page</a>.
Reading through the section I discovered a "technique" that the author calls "exception dispatcher" that allows someone to group all his exception handling in one handy function:
<pre><code class="hljs language-csharp">void handleException()
{
 try {
 throw; // ?!
 }
 catch (MyException&#x26; e) {
 //...code to handle MyException...
 }
 catch (YourException&#x26; e) {
 //...code to handle YourException...
 }
}
 
void f()
{
 try {
 //...something that might throw...
 }
 catch (...) {
 handleException();
 }
}
</code></pre>
What bothers me is the single <code>throw;</code> statement: if you consider the given example then sure, it is obvious what it does: it rethrows the exception first caught in <code>f()</code> and deals with it again.
But what if I call <code>handleException()</code> on its own, directly, without doing it from a <code>catch()</code> clause ? Is there any specified behavior ?
Additionally for bonus points, is there any other "weird" (probably not the good word) use of <code>throw</code> that you know of ?
Thank you.

Are there types bigger than long long int in C++?

My compiler is g++.

Are there types bigger than long long int in C++?

On the [Sentinel Node wikipedia page][1] it says that the benefits of a sentinel node over NULL are :

 - Increased speed of operations
 - Reduced algorithmic code size
 - Increased data structure robustness (arguably).

I don&#39;t really understand how the checks against a sentinel node would be faster (or how to properly implement them in a linked list or tree), so I suppose this is more of a two part question:

 1. What causes the sentinel node to be a better design than NULL?
 2. How would you implement a sentinel node in (for example) a list?


  [1]: http://en.wikipedia.org/wiki/Sentinel_node

How does a sentinel node offer benefits over NULL?

I ran into an interesting issue today.  Consider this simple example:

    template &lt;typename T&gt;
    void foo(const T &amp; a) { /* code */ }

    // This would also fail
    // void foo(const int &amp; a) { /* code */ }
    
    class Bar
    {
    public:
       static const int kConst = 1;
       void func()
       {
          foo(kConst);           // This is the important line
       }
    };
    
    int main()
    {
       Bar b;
       b.func();
    }

When compiling I get an error:

    Undefined reference to &#39;Bar::kConst&#39;

Now, I&#39;m pretty sure that this is because the `static const int` is not defined anywhere, which is intentional because according to my understanding the compiler should be able to make the replacement at compile-time and not need a definition.  However, since the function takes a `const int &amp;` parameter, it seems to be not making the substitution, and instead preferring a reference.  I can resolve this issue by making the following change:

    foo(static_cast&lt;int&gt;(kConst));

I believe this is now forcing the compiler to make a temporary int, and then pass a reference to that, which it can successfully do at compile time.

I was wondering if this was intentional, or am I expecting too much from gcc to be able to handle this case?  Or is this something I shouldn&#39;t be doing for some reason?

Undefined reference to static const int

I&#39;m using Boost Program Options Library to parse the command line arguments.

I have the following requirements:

 1. Once &quot;help&quot; is provided, all the other options are optional;
 2. Once &quot;help&quot; is not provided, all the other options are required.

How I can deal with this?  Here is the my code handling this, and I found it&#39;s very redundant, and I think there must be an easy to do, right?

    #include &lt;boost/program_options.hpp&gt;
    #include &lt;iostream&gt;
    #include &lt;sstream&gt;
    namespace po = boost::program_options;
    
    bool process_command_line(int argc, char** argv,
                              std::string&amp; host,
                              std::string&amp; port,
                              std::string&amp; configDir)
    {
        int iport;
    
        try
        {
            po::options_description desc(&quot;Program Usage&quot;, 1024, 512);
            desc.add_options()
              (&quot;help&quot;,     &quot;produce help message&quot;)
              (&quot;host,h&quot;,   po::value&lt;std::string&gt;(&amp;host),      &quot;set the host server&quot;)
              (&quot;port,p&quot;,   po::value&lt;int&gt;(&amp;iport),             &quot;set the server port&quot;)
              (&quot;config,c&quot;, po::value&lt;std::string&gt;(&amp;configDir), &quot;set the config path&quot;)
            ;
    
            po::variables_map vm;
            po::store(po::parse_command_line(argc, argv, desc), vm);
            po::notify(vm);
    
            if (vm.count(&quot;help&quot;))
            {
                std::cout &lt;&lt; desc &lt;&lt; &quot;\n&quot;;
                return false;
            }
    
            // There must be an easy way to handle the relationship between the
            // option &quot;help&quot; and &quot;host&quot;-&quot;port&quot;-&quot;config&quot;
            if (vm.count(&quot;host&quot;))
            {
                std::cout &lt;&lt; &quot;host:   &quot; &lt;&lt; vm[&quot;host&quot;].as&lt;std::string&gt;() &lt;&lt; &quot;\n&quot;;
            }
            else
            {
                std::cout &lt;&lt; &quot;\&quot;host\&quot; is required!&quot; &lt;&lt; &quot;\n&quot;;
                return false;
            }
    
            if (vm.count(&quot;port&quot;))
            {
                std::cout &lt;&lt; &quot;port:   &quot; &lt;&lt; vm[&quot;port&quot;].as&lt;int&gt;() &lt;&lt; &quot;\n&quot;;
            }
            else
            {
                std::cout &lt;&lt; &quot;\&quot;port\&quot; is required!&quot; &lt;&lt; &quot;\n&quot;;
                return false;
            }
    
            if (vm.count(&quot;config&quot;))
            {
                std::cout &lt;&lt; &quot;config: &quot; &lt;&lt; vm[&quot;config&quot;].as&lt;std::string&gt;() &lt;&lt; &quot;\n&quot;;
            }
            else
            {
                std::cout &lt;&lt; &quot;\&quot;config\&quot; is required!&quot; &lt;&lt; &quot;\n&quot;;
                return false;
            }
        }
        catch(std::exception&amp; e)
        {
            std::cerr &lt;&lt; &quot;Error: &quot; &lt;&lt; e.what() &lt;&lt; &quot;\n&quot;;
            return false;
        }
        catch(...)
        {
            std::cerr &lt;&lt; &quot;Unknown error!&quot; &lt;&lt; &quot;\n&quot;;
            return false;
        }
    
        std::stringstream ss;
        ss &lt;&lt; iport;
        port = ss.str();
    
        return true;
    }
    
    int main(int argc, char** argv)
    {
      std::string host;
      std::string port;
      std::string configDir;
    
      bool result = process_command_line(argc, argv, host, port, configDir);
      if (!result)
          return 1;
    
      // Do the main routine here
    }


Required and Optional Arguments Using Boost Library Program Options

If I have a `struct` in C++, is there no way to safely read/write it to a file that is cross-platform/compiler compatible?

Because if I understand correctly, every compiler &#39;pads&#39; differently based on the target platform.


Struct padding in C++

I wish to throw an exception and have the following:

    (throw &quot;Some text&quot;)

However it seems to be ignored.

How can I throw an exception in Clojure?

Should caught exceptions be re-thrown directly, or should they be wrapped around a new exception?

That is, should I do this:

    try {
      $connect = new CONNECT($db, $user, $password, $driver, $host);
    } catch (Exception $e) {
      throw $e;
    }

or this:

    try {
      $connect = new CONNECT($db, $user, $password, $driver, $host);
    } catch (Exception $e) {
      throw new Exception(&quot;Exception Message&quot;, 1, $e);
    }

If your answer is to &lt;strong&gt;throw directly&lt;/strong&gt; please suggest the use of &lt;strong&gt;exception chaining&lt;/strong&gt;, I am not able to understand a real world scenario where we use exception chaining.

What are the best practices for catching and re-throwing exceptions?

What does `ArrayIndexOutOfBoundsException` mean and how do I get rid of it? 

Here is a code sample that triggers the exception:

    String[] names = { &quot;tom&quot;, &quot;bob&quot;, &quot;harry&quot; };
    for (int i = 0; i &lt;= names.length; i++) {
        System.out.println(names[i]);
    }


What causes a java.lang.ArrayIndexOutOfBoundsException and how do I prevent it?

I have a method that can throw two different exceptions, `CommuncationException` and `SystemException`. In both cases I do the same three-line code block.

    try {
     ...
    }
    
    catch (CommunicationException ce) {
       ...
    }
    
    catch {SystemExcetion se) {
       ... 
    }

Is there any possibility to do it like that?

    try {
       ...
    }
    
    catch (CommunicationException ce, SystemException se) {
       ...
    }

Then I would not have to write this much code. I know I could extract the exception handling to a private method, but since the code is only 3 lines long, the method definition would take more code than the body itself.

Catch two exceptions in the same catch block?

I want to read a .csv file in python. 

 - I don&#39;t know if the file exists.
 - My current solution is below. It feels sloppy to me because the two separate exception tests are awkwardly juxtaposed. 

Is there a prettier way to do it?

    import csv    
    fName = &quot;aFile.csv&quot;

    try:
        with open(fName, &#39;r&#39;) as f:
            reader = csv.reader(f)
            for row in reader:
                pass #do stuff here
        
    except IOError:
        print &quot;Could not read file:&quot;, fName



What is a good way to handle exceptions when trying to read a file in python?

&gt; **Possible Duplicate:**  
&gt; [how to use Java-style throws keyword in C#?](https://stackoverflow.com/questions/3465465/how-to-use-java-style-throws-keyword-in-c)  

&lt;!-- End of automatically inserted text --&gt;

i have a function where an exception occurs
say for example

    private void functionName() throws Exception
    {
       // some code that might throw an exception
    }

thanks!

Is there a throws keyword in C# like in Java?

Conventional wisdom says you can only throw objects that extend `Throwable` in Java, but is it possible to disable the bytecode verifier and get Java to compile and run code that throws arbitrary objects - or even primitives?

I looked up the JVM&#39;s [`athrow`][1] and it will pop the first objref on the operand stack; but would it check if said reference points to a `Throwable` at run time?


  [1]: http://docs.oracle.com/javase/specs/jvms/se7/html/jvms-6.html#jvms-6.5.athrow

What can you throw in Java?

I want to write a common error handler which will catch custom errors thrown on purpose at any instance of the code.

When I did `throw new Error(&#39;sample&#39;)` like in the following code

    try {
        throw new Error({&#39;hehe&#39;:&#39;haha&#39;});
        // throw new Error(&#39;hehe&#39;);
    } catch(e) {
    	alert(e);
    	console.log(e);
    }

Log shows in Firefox as `Error: [object Object]` and I couldn’t parse the object.

For the second `throw` the log shows as: `Error: hehe`

Whereas when I did

    try {
        throw ({&#39;hehe&#39;:&#39;haha&#39;});
    } catch(e) {
    	alert(e);
    	console.log(e);
    }

the console showed as: `Object { hehe=&quot;haha&quot;}` in which I was able to access the error properties.

**What is the difference?**

Is the difference as seen in the code? Like string will be just passed as string and object as objects but the syntax will be different?

I haven’t explored throwing error object… I had done only throwing strings.

Is there any other way than the above two mentioned methods?

What is the difference between `throw new Error` and `throw someObject`?

[PEP 342 (Coroutines via Enhanced Generators)][1] added a `throw()` method to generator objects, which allows the caller to raise an exception *inside* the generator (as if it was thrown by the `yield` expression).

I am wondering what the use cases for this feature are.


  [1]: http://www.python.org/dev/peps/pep-0342/

What is generator.throw() good for?

Is there any difference between `throw()` and `noexcept` other than being checked at runtime and compile time, respectively?

[This Wikipedia C++11 article](http://en.wikipedia.org/wiki/C%2B%2B11#Features_removed_or_deprecated) suggests that the C++03 throw specifiers are deprecated.  
Why so, is `noexcept` capable enough to cover all that at compile time ?

[Note: I checked [this question](https://stackoverflow.com/questions/88573/should-i-use-an-exception-specifier-in-c) and [this article](http://www.gotw.ca/publications/mill22.htm), but couldn&#39;t determine the solid reason for deprecation.]

Content Type	Original Author	Original Content on Stackoverflow
Question	ereOn	View Question on Stackoverflow
Solution 1 - C++	Alan Stokes	View Answer on Stackoverflow
Solution 2 - C++	dalle	View Answer on Stackoverflow
Solution 3 - C++	sharptooth	View Answer on Stackoverflow

What does a single "throw;" statement do?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Solution 3 - C++

Mercurial: diffs in a particular changeset?

Does Java support inner / local / sub methods?

Attributions