20.x — Chapter 20 comprehensive quiz

By Alex on February 11th, 2017 | last modified by Alex on December 21st, 2020

Chapter review

Exception handling provides a mechanism to decouple handling of errors or other exceptional circumstances from the typical control flow of your code. This allows more freedom to handle errors when and how ever is most useful for a given situation, alleviating many (if not all) of the messiness that return codes cause.

A throw statement is used to raise an exception. Try blocks look for exceptions thrown by the code written or called within them. These exceptions get routed to catch blocks, which catch exceptions of particular types (if they match) and handle them. By default, an exception that is caught is considered handled.

Exceptions are handled immediately. If an exception is raised, control jumps to the nearest enclosing try block, looking for catch handlers that can handle the exception. If no try block is found or no catch blocks matches, the stack will be unwound until a handler is found. If no handler is found before the entire stack is unwound, the program will terminate with an unhandled exception error.

Exceptions of any data type can be thrown, including classes.

Catch blocks can be configured to catch exceptions of a particular data type, or a catch-all handler can be set up by using the ellipses (…). A catch block catching a base class reference will also catch exceptions of a derived class. All of the exceptions thrown by the standard library are derived from the std::exception class (which lives in the exception header), so catching a std::exception by reference will catch all standard library exceptions. The what() member function can be used to determine what kind of std::exception was thrown.

Inside a catch block, a new exception may be thrown. Because this new exception is thrown outside of the try block associated with that catch block, it won’t be caught by the catch block it’s thrown within. Exceptions may be rethrown from a catch block by using the keyword throw by itself. Do not rethrow an exception using the exception variable that was caught, otherwise object slicing may result.

Function try blocks give you a way to catch any exception that occurs within a function or an associated member initialization list. These are typically only used with derived class constructors.

You should never throw an exception from a destructor.

The noexcept exception specifier can be used to denote that a function is no-throw/no-fail.

Finally, exception handling does have a cost. In most cases, code using exceptions will run slightly slower, and the cost of handling an exception is very high. You should only use exceptions to handle exceptional circumstances, not for normal error handling cases (e.g. invalid input).

Chapter quiz

1) Write a Fraction class that has a constructor that takes a numerator and a denominator. If the user passes in a denominator of 0, throw an exception of type std::runtime_error (included in the stdexcept header). In your main program, ask the user to enter two integers. If the Fraction is valid, print the fraction. If the Fraction is invalid, catch a std::exception, and tell the user that they entered an invalid fraction.

Here’s what one run of the program should output:

Enter the numerator: 5
Enter the denominator: 0
Invalid denominator

Show Solution

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

#include <iostream> #include <stdexcept> // for std::runtime_error   class Fraction { private: int m_numerator = 0; int m_denominator = 1;   public: Fraction(int numerator = 0, int denominator = 1) : m_numerator(numerator), m_denominator(denominator) { if (m_denominator == 0) throw std::runtime_error("Invalid denominator"); }   friend std::ostream& operator<<(std::ostream &out, const Fraction &f1);   };   std::ostream& operator<<(std::ostream &out, const Fraction &f1) { out << f1.m_numerator << "/" << f1.m_denominator; return out; }   int main() { std::cout << "Enter the numerator: "; int numerator; std::cin >> numerator;   std::cout << "Enter the denominator: "; int denominator; std::cin >> denominator;   try { Fraction f(numerator, denominator); std::cout << "Your fraction is: " << f << '\n'; } catch (std::exception& e) { std::cout << e.what() << '\n'; }   return 0; }

M.1 -- Intro to smart pointers and move semantics

Index

20.9 -- Exception specifications and noexcept

C++ Tutorial |  Print This Post

47 comments to 20.x — Chapter 20 comprehensive quiz

• salah

  July 16, 2020 at 3:05 am · Reply

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

  #include <iostream> #include <exception>   class Fraction { private:     int m_numerator;     int m_denemenator;     Fraction(int numerator, int denemenator) //    Fraction constructor is private         :m_numerator{ numerator }, m_denemenator{ denemenator } {     }   public:     Fraction() :Fraction(0, 1) { // default values       }       void Init(int numerator, int denemenrator)try { // this initialize fraction and throw an exception         this->m_numerator = numerator;         if (denemenrator == 0) {             throw std::runtime_error("denemenator can't be zero, denemenrator is set to 1");         }           this->m_denemenator = denemenrator; // else     }       catch (std::runtime_error value) {         std::cout << "Error: ";         this->m_denemenator = 1;         throw;       }         void printFraction() {           std::cout << m_numerator << "/" << m_denemenator << "\n";     }     };   int main() {     Fraction f; // decleration     try     {         f.Init(10, 0); // Init Fraction     }         catch (const std::exception& exception)     {         std::cout << exception.what() << "\n";     }       f.printFraction();               return 0; }

  Hi nascardriver,

  As you said in the previous lessons that we can surrounde our function ,escpecially constructor, by try-block.

  In my code I splited the initialization from the declaration of the Fraction class  to access it (Fraction object) outside the try-block: if 'try' was used in constructor, then I have to define my object inside try-block in main function, thus I can't access it outside that block, so does the code good in this case  ?

  • nascardriver

    July 19, 2020 at 2:41 am · Reply

    This only works if you have control over the object you're creating (ie. you're the author of `Fraction`) and the object can be created without being initialized (eg. it doesn't have a reference member variable).
    A more versatile solution is to dynamically allocate `f`. That way you can declare it without initializing it, and then really initialize (Not assign) it in the try-block.

    1 2 3 4 5 6 7 8 9

    std::unique_ptr<Fraction> f{}; // No Fraction created yet   try {   f = std::make_unique<Fraction>(10, 0); // Creates a Fraction and calls the constructor } // ...   f->printFraction();

    If you don't yet know what `unique_ptr` and `make_unique` are, they're explained in the next lesson. This could be done with `new` and `delete` as well.

    • SALAH

      July 19, 2020 at 5:50 am · Reply

      That's great thank you so much

• Gabe

  June 19, 2020 at 7:16 am · Reply

  Quiz:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

  class Fraction { private:     int m_num{};     int m_den{};   public:     Fraction(const int &num, const int &den)         : m_num{num}, m_den{den}     {         if(den == 0)             throw std::runtime_error("Invalid denominator");     }         friend std::ostream& operator<<(std::ostream &out, const Fraction &f)     {         out << f.m_num << '/' << f.m_den;         return out;     }   };     int main() {     try     {           std::cout << "Enter the numerator: ";         int num{};         std::cin >> num;           std::cout << "Enter the denominator: ";         int den{};         std::cin >> den;           Fraction fract{num, den};           std::cout << fract << '\n';       }     catch(std::exception &e)     {         std::cerr << "Exception: " << e.what() << '\n';         return 1;     }     catch(...)     {         std::cerr << "Unknown exception caught!\n";         return 2;     } }

• Ged

  March 6, 2020 at 11:34 am · Reply

  1	#include <stdexcept> // for std::runtime_error

  There is another library <exception>, but we don't use it because it is already inside <stdexcept> ?

  • Alex

    March 8, 2020 at 10:27 am · Reply

    The exception header only includes std::exception. The stdexcept includes all of the derived classes, like std::runtime_error.

• Anthony

  May 17, 2019 at 5:05 pm · Reply

  Some of this confused me to start with.

  1	T& operator* () const { return *m_ptr; }

  This line is straightforward. The * operator dereferences a pointer, so let's just return the dereferenced pointer, and everybody's happy.

  1	T* operator-> () const { return m_ptr; }

  This is more subtle. My first thought was that we were looking to dereference again, since the -> operator dereferences a pointer, as above. But then I saw that it's closer to meaning that since -> usually operates upon a pointer, we must here return a pointer. But then this would be more like preparing it for the operation than carrying out the operation, which are slightly different things.

  Is that right? Because it still doesn't seem to be the correct reasoning to me. Could you unmuddle my thinking somehow?

  Thanks :)

  • nascardriver

    May 18, 2019 at 1:50 am · Reply

    @operator-> can return references, but then you won't be able to use the returned value in a convenient way

    1 2 3 4 5 6 7 8

    hello->world(); // Won't work if @operator-> returns a reference. // Unless the returned object has an @operator-> that returns a pointer. // (Or the object returned by that call returns a reference to an object // that returns a pointer from it's @operator->, and so on and so forth).   // You'd have to do this, which defeats the purpose of operators. hello.operator->().world();

    The member lookup is done automatically for you. So although you're returning a pointer, the caller doesn't have to use @operator-> or indirection on the returned object again.

• Louis Cloete

  May 13, 2019 at 8:23 am · Reply

  Hi Alex!

  A couple of comments about the code in the quiz:

  1) Your expected output and your exception's text doesn't match. You expect "Your fraction has an invalid denominator." but you will get "Invalid denominator" instead.

  2) The code getting input is nearly identical except for the prompt. Why not extract it into a function like this:

  1 2 3 4 5 6 7 8

  int getNumber(const char *prompt) {     std::cout << prompt;     int num {};     std::cin >> num;     // error handling should go here, but for such a short academic program it could be omitted     return num; }

  and then use it like this:

  1 2	int numerator {getNumber("Enter the numerator: ")}:     int denominator {getNumber("Enter the denominator: ")};

  • Alex

    May 16, 2019 at 5:06 pm · Reply

    1) Fixed, thanks!
    2) You certainly can. However, my take is that it isn't worth the additional complexity (a new function + 3 extra lines of code) just to remove 2 lines of otherwise redundant code.

    • Louis Cloete

      May 17, 2019 at 11:18 am · Reply

      Regarding 2): True. If, however, you want to actually handle the possible error, it does make sense to extract a function (because error handling with std::istream isn't trivial...).

      • Alex

        May 17, 2019 at 9:10 pm · Reply

        Agreed!

• matrix

  May 12, 2019 at 2:27 am · Reply

  I'm getting this error while overloading "<<" operator:
  Severity    Code    Description    Project    File    Line    Suppression State
  Error    C2679    binary '<<': no operator found which takes a right-hand operand of type 'Fraction' (or there is no acceptable conversion)

  • nascardriver

    May 12, 2019 at 2:31 am · Reply

    Please post your code.

    • matrix

      May 12, 2019 at 2:32 am · Reply

      1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

      class Fraction {     int m_numerator;     int m_denumerator; public:     Fraction(int numerator=0, int denumerator=1):         m_numerator{numerator},         m_denumerator{denumerator}     {         if (m_denumerator == 0)             throw std::exception("Invalid denumerator");     }     friend std::ostream& operator<<(const Fraction& f, std::ostream& out); };   std::ostream& operator<<(const Fraction& f, std::ostream& out) {     out << f.m_numerator << "/" << f.m_denumerator;     return out; }   int main() {         std::cout << "enter the numeratoe: ";         int num;         std::cin >> num;           std::cout << "enter the denumerator: ";         int den;         std::cin >> den;     try {         Fraction f{ num, den };         std::cout << "Your fraction is " << f << '\n';     }     catch (std::exception & e) {         std::cout << "Error: " << e.what();     } }

      • nascardriver

        May 12, 2019 at 2:33 am · Reply

        1 2	friend std::ostream& operator<<(const Fraction& f, std::ostream& out); // No friend std::ostream& operator<<(std::ostream& out, const Fraction& f); // Ok

• missingsemicolon

  April 21, 2019 at 12:58 pm · Reply

  So I wrote a programm that should find all primenumbers from 2 to a user-defined max.
  It works but it is confusing. Any suggestions how I could write it better/clearer? :)

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98

  #include <iostream> #include <vector> #include <stdexcept>   std::vector<int> primenumbers;   bool doesnumberexistsalready(std::vector<int> &n, const int &zahl) {     bool exists = false;     for (int i{ 0 }; i < n.size(); ++i)     {         if (n[i] == zahl)         {             exists = true;         }     }     return !exists; }   void insertPrimenumbers(std::vector<int> &all, std::vector<int> &notprime, int max) {     // every number that exists in vector all and doesnt exists in vector notprime     // should be in vector prime           for (int i{ 0 }; i <= max; ++i)         {             if (!doesnumberexistsalready(all, i) && doesnumberexistsalready(notprime, i))             {                 primenumbers.push_back(i);             }         } }   int main() {     std::cout << "Till which number do you want to have the prime numbers?\n";     int max;     std::cin >> max;       if (max < 2)     {         std::cout << "There are no primenumbers!\n";         return 0;     }       std::vector<int> n;       // create the vector that holds every number (that has the     // potential to be a primenumber)     for (int index{ 0 }; index <= max - 2; ++index)     {         n.push_back(index + 2);     }                 std::vector<int> notprimenumbers;     // * search every non prime number     // with the Sieve of Eratosthenes       // * this should be done till the smallest number multiplied by itself is     // smaller than max       // first loop to get smallest non-marked number     for (int index{ 0 }; n[index] * n[index] < max; ++index)     {         // second loop takes the number of first loop         // which should be multiplied till max is reached         for (int actualNum{ n[index] }, help {2}; actualNum * help <= max; ++help)         {             //check if we already added the number in vector primenumber             //if so dont add it again             if (doesnumberexistsalready(notprimenumbers, actualNum*help))             {                 notprimenumbers.push_back(actualNum * help);             }         }     }       /* prints every non-prime number        no need for that anymore     for (int i{ 0 }; i < notprimenumbers.size(); ++i)     {         std::cout << notprimenumbers[i] << '\n';     }     */       insertPrimenumbers(n, notprimenumbers, max);       // print primenumbers     std::cout << "These are the primenumbers\n";         for (unsigned int i{ 0 }; i < primenumbers.size(); ++i)     {         std::cout << primenumbers[i] << ' ';     }       return 0; }

  • nascardriver

    April 22, 2019 at 2:10 am · Reply

    * Line 37, 9, 46, 57: Initialize your variables with brace initializers.
    * Line 20, 22, 27, 69: Limit your lines to 80 characters in length for better readability on small displays.
    * Program in english.
    * Missing printed line feed at the end of your program.
    * Line 10, 92: Comparison of different types.
    * Line 7: @n should be const.
    * You're using the same name style for function and variable. Neither consistently.
    * @doesnumberexistsalready: Use @std::find.
    * Line 50+: Initialize @index to 2 to avoid the calculation in every loop cycle.
    * Storing all numbers is a waste of memory. You can generate them when you need them.
    * Line 69, 73, 75: Triple calculation of the same number.

    I didn't check your logic, it seems way too complicated for generating prime numbers. Have a look at some other approaches online.

• a

  April 6, 2019 at 5:34 pm · Reply

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

  #include "pch.h" #include <iostream> #include <math.h>   #include <vector> #include <stdexcept> #include <string> #include <memory> #include <exception>     class Fraction {   public:     double m_numerator;     double m_denominator;     Fraction(double numerator, double denominator)         :  m_denominator(denominator), m_numerator(numerator)     {           if (m_denominator == 0)         {             throw std::runtime_error("denominator cannot be 0");         }     } };   int main() {     double a, b;     std::cout << "enter the numerator: ";     std::cin >> a;     std::cout << "\n enter the denominator: ";     std::cin >> b;     try     {         Fraction f(a, b);         std::cout << "\n" << a << "/" << b << "\n";     }     catch (std::exception& Exception)     {         std::cerr << Exception.what();     } }

  My solution

• ChilaKiller

  January 14, 2019 at 5:03 pm · Reply

  whats the difference between

  1 2 3 4 5 6 7 8 9

  try     {         Fraction f(numerator, denominator);         std::cout << "Your fraction is: " << f << '\n';     }     catch (std::exception&)     {         std::cout << "Your fraction has an invalid denominator.\n";     }

  and

  1 2 3 4 5 6 7 8 9

  try     {         Fraction f(numerator, denominator);         std::cout << "Your fraction is: " << f << '\n';     }     catch (std::exception& exception)     {         std::cerr << exception.what();     }

  • Alex

    January 14, 2019 at 10:55 pm · Reply

    The latter is better because it's less redundant. Quiz solution updated!

• Nigel Booth

  December 2, 2018 at 3:22 am · Reply

  Hi,

  solved the quiz thus:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56

  // FractionException.cpp : This file contains the 'main' function. Program execution begins and ends there. //   #include "pch.h" #include <iostream> #include <cmath> #include <stdexcept> //for std::exception   class Fraction { private:     int m_n{ 0 };     int m_d{ 1 }; public:     Fraction(int numerator = 0, int denominator = 1) :         m_n(numerator), m_d(denominator)     {         if (m_d == 0)               throw std::runtime_error("Invalid denominator entered!");     }       friend std::ostream& operator<<(std::ostream& output, const Fraction &fraction);      };   std::ostream& operator<<(std::ostream& output, const Fraction &fraction) {     output << fraction.m_n << "/" << fraction.m_d;     return output; }   int main() {     try     {         std::cout << "please enter the numerator: ";         int numerator;         std::cin >> numerator;           std::cout << "please enter the denominator: ";         int denominator;         std::cin >> denominator;           Fraction fraction(numerator, denominator);         std::cout << "Your fraction is: " << fraction << "\n";     }       catch (std::exception)     {         std::cout << "Invalid denominator! \n";     }       return 0;   }

  so effectively had the whole of my main function within the try block.  This ensures that any errors are caught (I feel).

  • nascardriver

    December 2, 2018 at 6:20 am · Reply

    Your catch won't catch everything. You need

    1	catch (...)

    Other than that, you're still using direct initialization.

• Sam

  September 23, 2018 at 8:37 pm · Reply

  Typo:  "If no try block is found or not catch blocks matches" should be "If no try block is found or no catch block matches"

  • Alex

    September 24, 2018 at 8:50 am · Reply

    Typo fixed! Thanks again.

• Ben

  August 19, 2018 at 4:44 pm · Reply

  EXCEPTIONal circumstances indeed :)! Thanks for the great tutorial. I've been working as a software analyst for about 8 months now, and I owe this tutorial for allowing me to start my second career!

  Thanks!

• Shawn

  July 13, 2018 at 6:35 am · Reply

  Hey Alex,

  Thank you for the great content! I've tried to use templates for this exercise but I couldn't seem to make it work. I get weird errors on line 1 that I've never had before.

  Here is my code:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

  #include "stdafx.h" #include <iostream> #include <stdexcept>   using namespace std;   template<class T> class Fraction { private:     T m_numerator = 0;     T m_denominator = 1;   public:     Fraction (T numerator, T denominator) :m_numerator(numerator), m_denominator(denominator)     {         if (denominator == 0)             throw runtime_error("Dividing by 0");     }       friend std::ostream& operator<<(std::ostream& out, const Fraction &f1); };   template <typename T>   std::ostream& operator<<(std::ostream& out, const Fraction<T> &f) {     out << f.m_numerator << "/" << f.m_denominator;     return out; }     int main() {     int x;     cout << "Enter the numerator: ";     cin >> x;            int y;     cout << "Enter denominator: ";     cin >> y;       try     {         Fraction<int> f(x, y);         std::cout << "Your fraction is " << f << endl;     }       catch (std::exception& exception)     {         std::cout << "Your fraction has an invalid denominator.\n";     }       cin.clear();     cin.ignore(32767, '\n');     cin.get();       return 0; }

  Thanks!

  • nascardriver

    July 13, 2018 at 8:07 am · Reply

    Hi Shawn!

    Disable precompiled headers in your project settings and remove

    1	#include "stdafx.h"

    Suggestions so far:
    * Don't use "using namespace"
    * Line 11, 12 will only work when @T is an arithmetic type, have a look at <type_traits>
    * Initialize your variables with uniform initialization
    * Use std::numeric_limits<std::streamsize>::max() rather than 32767

    • Shawn

      July 13, 2018 at 8:53 am · Reply

      Thanks for the advice!

      However I still get these weird problems....

      Severity    Code    Description    Project    File    Line    Suppression State
      Error    LNK2019    unresolved external symbol "class std::basic_ostream<char,struct std::char_traits<char> > & __cdecl operator<<(class std::basic_ostream<char,struct std::char_traits<char> > &,class Fraction<int> const &)" (??6@YAAAV?$basic_ostream@DU?$char_traits@D@std@@@std@@AAV01@ABV?$Fraction@H@@@Z) referenced in function _main    ch14    C:\Users\Shawn\source\repos\ch14\ch14\ch14.obj    1    

      Severity    Code    Description    Project    File    Line    Suppression State
      Error    LNK1120    1 unresolved externals    ch14    C:\Users\Shawn\source\repos\ch14\Debug\ch14.exe    1

      • Shawn

        July 13, 2018 at 9:01 am · Reply

        Is it due to the fact that I'm not using <type_traits> (even though I'm only using arithmetic types in my program)?

      • nascardriver

        July 13, 2018 at 9:17 am · Reply

        Template functions need to be defined inside the class (unless you want to do specialization, which I don't like).

        • Shawn

          July 15, 2018 at 11:54 pm · Reply

          Thanks, it worked!

          (Sorry for the delay in my response, I go caught up in stuff)

• Help

  July 21, 2017 at 1:18 am · Reply

  hi Alex,
  I wounder why u put in private int m_numerator = 0; and int m_denominator = 1; while in constructor we already do this they assign any argument Fraction(int numerator = 0, int denominator = 1). Couldn't i do just say in private int m_numerator; and int m_denominator; or is it any purpose for having both in constructor and assign in private ( cause if we call Fraction f; it still will in constructor put numerator = 0 and denominator = 1) ?

  Thanks in advance!

  • Alex

    July 22, 2017 at 9:07 am · Reply

    The non-static member initializers will be ignored in favor of the ones in the constructor. I included them just as a defensive programming mechanism. In this program, it will never get used. But if we later extended the class, we'd be sure that our numerator and denominator would be initialized to some reasonable value no matter what instead of remaining uninitialized.

• Daniel

  March 2, 2017 at 10:02 am · Reply

  You are correct. I was copy/pasting on my phone and forgot to update the copy.

  I meant to suggest changing "not ever" to "never".

  • Alex

    March 2, 2017 at 12:28 pm · Reply

    Thanks for clarifying. I agree this is clearer. Lesson updated.

• Daniel

  March 1, 2017 at 11:01 pm · Reply

  Suggest grammar fix:

  Change: "You should not ever throw an exception from a destructor."

  to: "You should not ever throw an exception from a destructor."

  • Alex

    March 2, 2017 at 9:56 am · Reply

    Those look identical to me. Am I missing something obvious? :)

• Unknown

  February 17, 2017 at 1:48 am · Reply

  Alex,
  When you add topics to rvalue references and semantics

  • Alex

    February 19, 2017 at 12:20 pm · Reply

    I think rvalue references will be the next lesson I write, so should be soon.

• aca4life

  February 13, 2017 at 6:22 am · Reply

  After neither my nor your solution compiled I found out that std::exception doesn't have a string/char* constructor. But since the derived error classes own such a constructor I used std::domain_error from <stdexcept> instead and it worked.

  http://www.cplusplus.com/reference/exception/exception/exception/

  • Alex

    February 13, 2017 at 2:15 pm · Reply

    Interesting, I didn't realize that a std::exception constructor that took a string was non-standard. I'll update the code accordingly.

    Doing a little investigation, most developers who want to use a standard exception with a customized error message use std::runtime_error. I've updated lesson 14.5 to include a note about this, as well as to fix a few other related issues.

• Manik

  February 13, 2017 at 4:09 am · Reply

  Can you give tutorials on designing animation programs with c++. I want to make animations with c++. I didn't understand any line of opengl and directx...

  • Alex

    February 13, 2017 at 2:08 pm · Reply

    Maybe someday I'll get to graphical applications, but it's unlikely to happen anytime soon.

• aakash gupta

  February 11, 2017 at 11:09 pm · Reply

  Hello alex,
  can you give me the code by which the '[code']'[/code'] converts a program to your html-style c++ code.

  • Alex

    February 12, 2017 at 2:33 pm · Reply

    Right now, it's being done via a WordPress plugin called Crayon.

    • Aakash

      March 4, 2017 at 3:42 am · Reply

      How can i set the theme of your site in my wordpress site