{"id":918,"date":"2024-08-09T20:18:36","date_gmt":"2024-08-09T20:18:36","guid":{"rendered":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/?page_id=918"},"modified":"2025-01-25T21:08:16","modified_gmt":"2025-01-25T21:08:16","slug":"small-enhancements-over-c","status":"publish","type":"page","link":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/topics\/c-details\/beginnings\/small-enhancements-over-c\/","title":{"rendered":"Small Enhancements over C"},"content":{"rendered":"\n

<\/span>Overview of Small Enhancements<\/span><\/h2>\n\n\n\n
    \n
  • New keywords and reserved words<\/li>\n\n\n\n
  • Line-style comments<\/li>\n\n\n\n
  • Stronger typing<\/li>\n\n\n\n
  • struct<\/strong>\/union<\/strong>\/enum<\/strong> tags become true type names<\/li>\n\n\n\n
  • Declaration placement<\/li>\n\n\n\n
  • Scope operator<\/li>\n\n\n\n
  • const<\/strong> specifier (stricter than ANSI C)<\/li>\n\n\n\n
  • Anonymous union<\/strong><\/li>\n\n\n\n
  • Explicit (function-like) type conversion<\/li>\n\n\n\n
  • Function prototypes (stricter than ANSI C)<\/li>\n\n\n\n
  • Overloading of function names<\/li>\n\n\n\n
  • Default values for function parameters<\/li>\n\n\n\n
  • Functions with unspecified number of parameters (stricter than ANSI C)<\/li>\n\n\n\n
  • Reference parameters in functions<\/li>\n\n\n\n
  • inline<\/strong> specifier<\/li>\n\n\n\n
  • new<\/strong> and delete<\/strong> operators <\/li>\n\n\n\n
  • Pointers to void<\/strong> and functions returning void<\/strong> (stricter than ANSI C)<\/li>\n<\/ul>\n\n\n\n

    <\/span>New Keywords and Reserved Words<\/span><\/h3>\n\n\n\n

    C keywords<\/p>\n\n\n\n

    auto break case char const continue default do double else enum extern float for goto if int long register return short signed sizeof static struct switch typedef union unsigned void volatile while <\/strong><\/code><\/pre>\n\n\n\n
    C++ keywords added:<\/p>\n\n\n\n
    and<\/strong> <\/em><\/strong>and_eq<\/strong> <\/em><\/strong>asm<\/strong> <\/strong>bitand<\/strong> <\/strong>bitor<\/strong> <\/strong>bool<\/strong> <\/strong>catch<\/strong> <\/strong>class<\/strong> <\/strong>compl<\/strong> <\/strong>const_cast<\/strong> <\/strong>delete<\/strong> <\/strong>dynamic_cast<\/strong> <\/strong>explicit<\/strong> <\/strong>export<\/strong> <\/strong>false<\/strong> <\/strong>friend<\/strong> <\/strong>if<\/strong> <\/strong>inline<\/strong> <\/strong>mutable<\/strong> <\/strong>namespace<\/strong> <\/strong>new<\/strong> <\/strong>not<\/strong> <\/strong>not_eq<\/strong> <\/strong>operator<\/strong> <\/strong>or<\/strong> <\/strong>or_eq<\/strong> <\/strong>private<\/strong> <\/strong>protected<\/strong> <\/strong>public<\/strong> <\/strong>reinterpret_cast<\/strong> <\/strong>static_cast<\/strong> <\/strong>template<\/strong> <\/strong>this<\/strong> <\/strong>throw<\/strong> <\/strong>true<\/strong> <\/strong>try<\/strong> <\/strong>typeid<\/strong> <\/strong>typename<\/strong> <\/strong>using<\/strong> <\/strong>virtual<\/strong> <\/strong>w_char_t<\/strong> <\/strong>xor<\/strong> <\/strong>xor_eq<\/strong><\/code><\/pre>\n\n\n\n
      \n
    • bool<\/strong>, true<\/strong>, false<\/strong> are used for the C++ Boolean type<\/li>\n\n\n\n
    • catch<\/strong>, throw<\/strong>, try<\/strong> are used for C++ exception handling<\/li>\n\n\n\n
    • w_char_t<\/strong> in C is a typedef<\/em>; in C++ it becomes a built-in type<\/li>\n\n\n\n
    • and<\/strong>, and_eq<\/strong>, bitand<\/strong>, bitor<\/strong>, compl<\/strong>, not<\/strong>, not_eq<\/strong>, or<\/strong>, or_eq<\/strong>, xor<\/strong>, and xor_eq<\/strong> are alternatives to the standard operator symbols. <\/li>\n<\/ul>\n\n\n\n
      <\/span>Line-Style Comments<\/span><\/h3>\n\n\n\n
      \n
      \n
      <\/path><\/path><\/svg><\/span>
      \/* <\/span><\/span>\n * The C++ version of a famous program <\/span><\/span>\n *\/<\/span><\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>std<\/span>::cout << <\/span>"Hello World"<\/span> << <\/span>std<\/span>::endl;\t<\/span><\/span>\n\t                  \/\/ Output the famous message<\/span><\/span>\n\t<\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
      \n
        \n
      • \/*<\/strong> and *\/<\/strong> are the standard C comment delimiters<\/li>\n\n\n\n
      • \/\/<\/strong> starts a line comment; end of line ends the line comment<\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
        <\/span>Some Differences Due to Stronger Typing<\/span><\/h3>\n\n\n\n
        In C++, literal character constants (‘a’<\/strong>) are of type char<\/strong>; in C, they are of type int<\/strong>:<\/p>\n\n\n\n
          \n
        • In C, sizeof(‘a’)<\/strong> equals sizeof(int)<\/strong><\/li>\n\n\n\n
        • In C++, sizeof(‘a’)<\/strong> equals sizeof(char)<\/strong><\/li>\n<\/ul>\n\n\n\n
          In C++, the use of an undeclared function is an error; in C, an undeclared function is assumed to be of type int foo()<\/strong> (K&R-style):<\/p>\n\n\n\n
          int main()\n{\n\tprintf(\"Hello world\\n\"); \/\/ Error in C++; printf not declared\n\treturn 0;\n}<\/code><\/pre>\n\n\n\n
          In C++, assigning a void *<\/strong> pointer to any other type of pointer requires an explicit cast:<\/p>\n\n\n\n
          int main()\n{\n\tvoid  *vptr;\n\tfloat *fptr;\n     \/* ... *\/\n\tfptr = vptr;          \/\/ Error in C++!\n\tfptr = (float *)vptr; \/\/ OK\n\treturn 0;\n}<\/code><\/pre>\n\n\n\n
          In C++, the following:<\/p>\n\n\n\n
          int mumble()<\/strong><\/code><\/pre>\n\n\n\n
          declares mumble<\/strong> to be a function that has zero<\/em> arguments.  In C, it indicates that a function has an unspecified number of arguments of unspecified type<\/em>.<\/p>\n\n\n\n
            \n
          • In C++, the following initialization is illegal:<\/li>\n<\/ul>\n\n\n\n
            char ch[2] = \"Hi\";<\/strong><\/code><\/pre>\n\n\n\n
            because it does not provide space for the terminating NUL character.<\/p>\n\n\n\n
            The following is the recommended method:<\/p>\n\n\n\n
            char ch[] = \"Hi\";<\/strong><\/code><\/pre>\n\n\n\n
            There is a bool<\/strong> type in C++:<\/p>\n\n\n\n
            bool done = false;\t\/\/ bool to bool\nint  yesno = true;\t\/\/ bool to integer\nbool isalive = -100;\t\/\/ integer to bool\ndone = 1;\t\/\/ integer to bool\nisalive = ptr;\t\/\/ pointer to bool\n<\/code><\/pre>\n\n\n\n
            <\/span>struct\/union\/enum Tags Become True Type Names<\/span><\/h3>\n\n\n\n
            \n
            \n
            <\/path><\/path><\/svg><\/span>
            #include<\/span> <\/span><iostream><\/span><\/span>\n<\/span>\nenum<\/span> <\/span>account_type<\/span> {<\/span>SAVINGS<\/span>,<\/span>CHECKING<\/span>};<\/span><\/span>\nstruct<\/span> <\/span>bank_account<\/span><\/span>\n{<\/span><\/span>\n    <\/span>int<\/span>          id;<\/span><\/span>\n    <\/span>double<\/span>       balance;<\/span><\/span>\n    account_type type;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n    bank_account checking<\/span><\/span>\n   \t\t= {<\/span>1234<\/span>, <\/span>20000.00<\/span>, CHECKING};<\/span><\/span>\n<\/span>\n    <\/span>std<\/span>::cout << <\/span>"Balance for account # "<\/span><\/span>\n       << <\/span>checking<\/span>.<\/span>id<\/span> << <\/span>" type "<\/span><\/span>\n       << <\/span>checking<\/span>.<\/span>type<\/span> << <\/span>" is "<\/span><\/span>\n       << <\/span>checking<\/span>.<\/span>balance<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n    <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
            \n
              \n
            • You don’t have to precede the tag with a struct<\/strong>, etc.<\/li>\n\n\n\n
            • cout<\/strong> and the <<<\/strong> operator can be ‘chained together’ to replace the printf<\/strong> functionality.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
              <\/span>Enumerations are Treated More Strictly<\/span><\/h3>\n\n\n\n
              \n
              \n
              <\/path><\/path><\/svg><\/span>
              enum<\/span> <\/span>Color<\/span> {<\/span>Red<\/span>, <\/span>Green<\/span>, <\/span>Blue<\/span>};<\/span><\/span>\nenum<\/span> <\/span>Fish<\/span> {<\/span>Herring<\/span>, <\/span>Mackerel<\/span>, <\/span>Salmon<\/span>};<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n\tColor hue;<\/span><\/span>\n\tFish  swimmer;<\/span><\/span>\n\t<\/span>int<\/span> c;<\/span><\/span>\n<\/span>\n\thue = Red;<\/span>          \/\/ OK<\/span><\/span>\n\tswimmer = Mackerel;<\/span> \/\/ OK<\/span><\/span>\n\thue = Salmon;<\/span>       \/\/ Error!<\/span><\/span>\n\tswimmer = Blue;<\/span>     \/\/ Error!<\/span><\/span>\n\tc = Green;<\/span>          \/\/ OK!<\/span><\/span>\n\thue = <\/span>1<\/span>;<\/span>            \/\/ Error!<\/span><\/span>\n\thue = (Color) <\/span>1<\/span>;<\/span>    \/\/ OK<\/span><\/span>\n\t<\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
              \n
                \n
              • In C, enum<\/strong>s<\/strong> are all of type int<\/strong>, and any enum is assignment compatible with an int<\/strong>.<\/li>\n\n\n\n
              • In C++, each enum<\/strong> is a distinct<\/em> int type;  an enum<\/strong> type can be assigned to an int<\/strong> type, but not the other way around.<\/em>  <\/em><\/li>\n\n\n\n
              • An enum<\/strong> is a subtype of an int<\/strong> — an enum is a kind of <\/em>int<\/strong>, but not vice versa.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
                <\/span>Declaration Placement<\/span><\/h3>\n\n\n\n
                \n
                \n
                <\/path><\/path><\/svg><\/span>
                #include<\/span> <\/span><iostream><\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>for<\/span> (<\/span>int<\/span> i = <\/span>0<\/span>; i < <\/span>10<\/span>; i++)<\/span><\/span>\n\t\t<\/span>std<\/span>::cout << i << <\/span>'.'<\/span>;<\/span><\/span>\n<\/span>\n\t\/\/ ...<\/span><\/span>\n<\/span>\n\t<\/span>char<\/span> *ptr = <\/span>0<\/span>;<\/span><\/span>\n<\/span>\n\t\/\/ ...<\/span><\/span>\n<\/span>\n\t<\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                \n
                  \n
                • Allows the declaration of a variable to be placed near its first use — can make the program more readable<\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
                  <\/span>Scope Operator<\/span><\/h3>\n\n\n\n
                  \n
                  \n
                  <\/path><\/path><\/svg><\/span>
                  #include<\/span> <\/span><iostream><\/span><\/span>\n<\/span>\nint<\/span> value = <\/span>27<\/span>;<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>double<\/span> value = <\/span>16.298<\/span>;<\/span><\/span>\n<\/span>\n  <\/span>std<\/span>::cout << <\/span>"local value  = "<\/span> << value<\/span><\/span>\n     << <\/span>'<\/span>\\n<\/span>'<\/span><\/span>\n     << <\/span>"global value = "<\/span> << ::value<\/span><\/span>\n     << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                  \n
                    \n
                  • The scope operator<\/em>, (::<\/strong>), overrides the default scope (in this case, local scope<\/em>) to file scope<\/em><\/li>\n\n\n\n
                  • The scope cannot be overridden in the opposite direction<\/em><\/li>\n\n\n\n
                  • The scope operator becomes indispensable with classes.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
                    <\/span>const Specifiers<\/span><\/h3>\n\n\n\n
                    const<\/strong> means that a variable can’t be changed directly:<\/p>\n\n\n\n
                    const int stable = 1000;\nstable = 2000;\t\/\/ Error!\n<\/code><\/pre>\n\n\n\n
                    In C:<\/p>\n\n\n\n
                    const int arraysize = 100;\nint array[arraysize];   <\/code><\/pre>\n\n\n\n
                    is illegal. <\/p>\n\n\n\n
                    In C++, it is legal — in C++, a const<\/strong> value may be used in place of any literal constant of its type.<\/p>\n\n\n\n
                    In C, the default scope of a const<\/strong> is extern<\/strong>;
                    In C++, the default scope of a const<\/strong> is static<\/strong>; much better for including in header files!<\/p>\n\n\n\n
                    Can localize the scope of a const<\/strong>, whereas a #define<\/strong> is effective from the point of its definition through the rest of the file(s) in the compilation.<\/p>\n\n\n\n
                    Often used in specifying function parameter types:<\/p>\n\n\n\n
                    int blather(const char *readonly,\n\t\t    char *readwrite );<\/code><\/pre>\n\n\n\n
                    A const<\/strong> definition must be initialized:<\/p>\n\n\n\n
                    const char *fixed_ptr = somewhere;<\/code><\/pre>\n\n\n\n
                    <\/span>Anonymous unions<\/span><\/h3>\n\n\n\n
                    \n
                    \n
                    <\/path><\/path><\/svg><\/span>
                    struct<\/span> <\/span>token<\/span><\/span>\n{<\/span><\/span>\n    <\/span>int<\/span> id;<\/span><\/span>\n    <\/span>union<\/span><\/span>\n    {<\/span><\/span>\n        <\/span>int<\/span>   integer;<\/span><\/span>\n        <\/span>double<\/span> real;<\/span><\/span>\n    } value;<\/span><\/span>\n<\/span>\n   \t\/\/ ...<\/span><\/span>\n<\/span>\n} current_token;<\/span><\/span>\n\t<\/span><\/span>\n\t\/\/ ...<\/span><\/span>\n<\/span>\nf = <\/span>current_token<\/span>.<\/span>value<\/span>.<\/span>real<\/span>;<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                    \n
                      \n
                    • In C, a union often introduces an annoying extra level of names that must be referenced:<\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
                      \n
                      \n
                      <\/path><\/path><\/svg><\/span>
                      struct<\/span> <\/span>token<\/span><\/span>\n{<\/span><\/span>\n    <\/span>int<\/span> id;<\/span><\/span>\n    <\/span>union<\/span><\/span>\n    {<\/span><\/span>\n        <\/span>int<\/span>   integer;<\/span><\/span>\n        <\/span>double<\/span> real;<\/span><\/span>\n    };<\/span>\t\t\/\/ no name!<\/span><\/span>\n    <\/span><\/span>\n\t\t\/\/ ...<\/span><\/span>\n<\/span>\n} current_token;<\/span><\/span>\n<\/span>\n\t\/\/ ...<\/span><\/span>\n<\/span>\nf = <\/span>current_token<\/span>.<\/span>real<\/span>;<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                      \n
                        \n
                      • In C++, an anonymous union<\/em> avoids unnecessary names:<\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
                        <\/span>Explicit Type Conversion<\/span><\/h3>\n\n\n\n
                        C++ supports two kinds of syntax for a cast<\/em>:<\/p>\n\n\n\n
                          \n
                        • The traditional C cast: <\/li>\n<\/ul>\n\n\n\n
                          int i = 5;\ndouble x = (double)i;<\/code><\/pre>\n\n\n\n
                            \n
                          • The new-style ‘function-like’ cast:<\/li>\n<\/ul>\n\n\n\n
                            int i = 5;\ndouble x = double(i);<\/code><\/pre>\n\n\n\n
                            The new form tends to be more natural when used with classes<\/p>\n\n\n\n
                            <\/span>Function Prototypes<\/span><\/h3>\n\n\n\n
                            Both C++ and ANSI C have function prototypes:<\/p>\n\n\n\n
                            extern FILE *fopen(const char *filename, \n                   const char *mode);\n      ...\nFILE *fp;\n      ...\nfp = fopen(\"myfile.dat\", \"r\");<\/code><\/pre>\n\n\n\n
                            In ANSI C, they are optional<\/em>;  the old K&R style is still legal.<\/p>\n\n\n\n
                            In C++, function prototypes are required<\/em>.<\/p>\n\n\n\n
                            In C++:<\/p>\n\n\n\n
                            int foo();<\/code><\/pre>\n\n\n\n
                            is equivalent to:<\/p>\n\n\n\n
                            int foo(void)<\/code><\/pre>\n\n\n\n
                            not the ANSI C (K&R) interpretation !<\/em><\/p>\n\n\n\n
                            In C++:<\/p>\n\n\n\n
                            int doit(...);<\/code><\/pre>\n\n\n\n
                            means that the function accepts any number of arguments of undefined type.  <\/p>\n\n\n\n
                              \n
                            • ANSI C requires at least one argument before the ellipsis, …<\/li>\n\n\n\n
                            • ANSI C requires a comma between the last required argument and the ellipsis.<\/li>\n<\/ul>\n\n\n\n
                              <\/span>Overloading of Function Names<\/span><\/h3>\n\n\n\n
                              C (and most other languages) requires that every function have a unique name.
                              For example, if you wish to have a function that returns the absolute value of an int<\/strong>, long<\/strong>, float<\/strong> and double<\/strong>, you must give each function a different name, even though its purpose is exactly the same:<\/p>\n\n\n\n
                              int    iabs(int i);\nlong   labs(long l);\nfloat  fabs(float f);\ndouble dabs(double d);<\/code><\/pre>\n\n\n\n
                              which tends to cause ‘name pollution’<\/em>.<\/p>\n\n\n\n
                              \n
                              \n
                              <\/path><\/path><\/svg><\/span>
                              #include<\/span> <\/span><iostream.h><\/span><\/span>\n<\/span>\nlong<\/span>  <\/span>Abs<\/span>(<\/span>long<\/span> <\/span>i<\/span>)<\/span><\/span>\n{<\/span><\/span>\n\tcout << <\/span>"Abs of long<\/span>\\n<\/span>"<\/span>;<\/span><\/span>\n\t<\/span>return<\/span> (i > <\/span>0<\/span>) ? i : -i;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\ndouble<\/span> <\/span>Abs<\/span>(<\/span>double<\/span> <\/span>d<\/span>)<\/span><\/span>\n{<\/span><\/span>\n\tcout << <\/span>"Abs of double<\/span>\\n<\/span>"<\/span>;<\/span><\/span>\n\t<\/span>return<\/span> (d > <\/span>0.0<\/span>) ? d : -d;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>long<\/span>   lv = <\/span>5<\/span>;<\/span><\/span>\n\t<\/span>double<\/span> dv = -<\/span>27.3<\/span>;<\/span><\/span>\n<\/span>\n\tcout << <\/span>Abs<\/span>(lv) << <\/span>'<\/span>\\n<\/span>'<\/span>;<\/span><\/span>\n\tcout << <\/span>Abs<\/span>(dv) << <\/span>'<\/span>\\n<\/span>'<\/span>;<\/span><\/span>\n\t<\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                              \n
                                \n
                              • C++ allows many functions to have the same name, which allows the same operation to be applied to different types.<\/li>\n\n\n\n
                              • This is used heavily with classes.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
                                <\/span>Function Signature<\/span><\/h3>\n\n\n\n
                                Overloaded functions are distinguished from each other by their signature<\/em><\/p>\n\n\n\n
                                A function’s signature consists of:<\/p>\n\n\n\n
                                  \n
                                • its name<\/li>\n\n\n\n
                                • the number of its parameters<\/li>\n\n\n\n
                                • the type(s) of its parameters, in order<\/li>\n\n\n\n
                                • but not<\/em><\/strong> its return type!<\/li>\n<\/ul>\n\n\n\n
                                  a function’s return value can be discarded in C\/C++, so the compiler cannot distinguish between functions which are called with the same arguments but without the call making use of any return value.<\/p>\n\n\n\n
                                  The C++ compiler attempts to match a function call to its corresponding function, based on the function name and the number and type(s) of its actual arguments:<\/p>\n\n\n\n
                                    \n
                                  • If there is an exact match, then that is the function chosen<\/li>\n\n\n\n
                                  • If there is no exact match, then implicit conversions can be used, which can result in:\n
                                      \n
                                    • no match<\/li>\n\n\n\n
                                    • more than one match (ambiguity)<\/li>\n\n\n\n
                                    • a single unique match<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                    • Other than a single match produces a compilation error<\/em><\/li>\n<\/ul>\n\n\n\n
                                      The exact rules for matching a call to its overloaded function, when combined with implicit type conversions, are quite complex.<\/p>\n\n\n\n
                                      Templates (covered much later in the course) complicate things still further.<\/p>\n\n\n\n
                                      <\/span>Default Values in Function Prototypes<\/span><\/h3>\n\n\n\n
                                      \n
                                      \n
                                      <\/path><\/path><\/svg><\/span>
                                      #include<\/span> <\/span><iostream.h><\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>create_window<\/span>(<\/span>int<\/span> <\/span>height<\/span> = <\/span>24<\/span>,<\/span><\/span>\n      \t           <\/span>int<\/span> <\/span>width<\/span>  = <\/span>80<\/span>)<\/span><\/span>\n{     <\/span><\/span>\n\t\/\/ ...<\/span><\/span>\n\tcout << <\/span>"Creating Window "<\/span><\/span>\n\t     << height << <\/span>" by "<\/span> <\/span><\/span>\n\t     << width  << <\/span>'<\/span>\\n<\/span>'<\/span>;<\/span><\/span>\n      \/\/ ...<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>create_window<\/span>(<\/span>10<\/span>, <\/span>20<\/span>);<\/span><\/span>\n\t<\/span>create_window<\/span>(<\/span>12<\/span>);<\/span><\/span>\n\t<\/span>create_window<\/span>();<\/span><\/span>\n\t<\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                      \n
                                        \n
                                      • There are many situations where a function is called with an argument usually having the same value.  It would be convenient to simply omit the parameter and have it default<\/em> to a specified value.   C++ supports this.<\/li>\n\n\n\n
                                      • Default values are only allowed on trailing arguments<\/em>.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
                                        <\/span>Unspecified Function Parameters<\/span><\/h3>\n\n\n\n
                                        The checking for number and types of function parameters can be suppressed in C++:<\/p>\n\n\n\n
                                        int noway(...);<\/strong><\/code><\/pre>\n\n\n\n
                                        which is equivalent to the K&R-style C function declaration<\/em>:<\/p>\n\n\n\n
                                        int noway();<\/strong><\/code><\/pre>\n\n\n\n
                                        <\/em><\/strong>But this is strongly discouraged!<\/em><\/strong><\/p>\n\n\n\n
                                        It should only be used when there is no alternative!  <\/em><\/strong>
                                        <\/em><\/strong>(And there almost always is a better alternative!)<\/em><\/strong><\/p>\n\n\n\n
                                        <\/span>Type-Safe Linkage<\/span><\/h3>\n\n\n\n
                                        \n
                                        \n
                                        <\/path><\/path><\/svg><\/span>
                                        \/* fother.c *\/<\/span><\/span>\ndouble<\/span> <\/span>fother_the_grommet<\/span>(<\/span>int<\/span> <\/span>x<\/span>, <\/span>double<\/span> <\/span>d<\/span>)<\/span><\/span>\n{<\/span><\/span>\n\t\/* ... *\/<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/* main.c *\/<\/span><\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>int<\/span> i;\t<\/span><\/span>\n\ti = <\/span>fother_the_grommet<\/span>();<\/span> \/* Bad call! *\/<\/span><\/span>\n\t<\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                        \n
                                          \n
                                        • A major weakness of C compilers is that there is no cross-module type checking.<\/li>\n\n\n\n
                                        • The compiler and linker cannot detect the mismatch;  you only find the problem at run\/debug time, when all manner of strange things are likely to happen.\n
                                            \n
                                          • Type-Safe Linkage<\/em> is achieved, in most C++ compilers, by name mangling<\/em> of external names, so that they convey more information, such as parameter number and types.  Unfortunately, often, different compilers implement this incompatibly.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
                                            <\/span>Calling non-C++ Functions<\/span><\/h3>\n\n\n\n
                                            It is a goal for C++ to be able to call non-C++ routines (such as functions written in C).  We therefore need an escape mechanism from the normal C++ calling conventions:<\/p>\n\n\n\n
                                            extern \"C\" <\/strong>{\n       double sin(double x);\n       double cos(double x);\n       double tan(double x);\n       }     \nextern \"C\"<\/strong> {\n#include \"myfile.h\"\n}\n<\/code><\/pre>\n\n\n\n
                                            Note that function prototypes are still required<\/em>:<\/p>\n\n\n\n
                                            extern \"C\" {\n    int foo(); \/* Means int foo(void); !*\/\n}\n<\/code><\/pre>\n\n\n\n
                                            <\/span>Reference Parameters<\/span><\/h3>\n\n\n\n
                                            \n
                                            \n
                                            <\/path><\/path><\/svg><\/span>
                                            void<\/span> <\/span>swapint<\/span>(<\/span>int<\/span> <\/span>*<\/span>first<\/span>, <\/span>int<\/span> <\/span>*<\/span>second<\/span>)<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>int<\/span> temp = *first;<\/span>\t\/\/ Must dereference<\/span><\/span>\n\t*first = *second;<\/span> \t\/\/ Must dereference<\/span><\/span>\n\t*second = temp;<\/span>\t    \/\/ Must dereference<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>int<\/span> a = <\/span>1<\/span>, b = <\/span>2<\/span>;<\/span><\/span>\n\t<\/span>swapint<\/span>(&a, &b);<\/span>  \/\/ Must take address<\/span><\/span>\n\t<\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                            \n
                                              \n
                                            • Passing parameters in C can sometimes be clumsy, particularly when the parameters are out<\/em> or in\/out<\/em>.<\/li>\n\n\n\n
                                            • Both the function definitions, and<\/em> the calls to them become complex.<\/li>\n\n\n\n
                                            • Most programming languages take care of this for you!<\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
                                              \n
                                              \n
                                              <\/path><\/path><\/svg><\/span>
                                              void<\/span> <\/span>swapint<\/span>(<\/span>int<\/span> <\/span>&<\/span>first<\/span>, <\/span>int<\/span> <\/span>&<\/span>second<\/span>)<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>int<\/span> temp = first;<\/span><\/span>\n\tfirst = second;<\/span><\/span>\n\tsecond = temp;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>int<\/span> a = <\/span>1<\/span>, b = <\/span>2<\/span>;<\/span><\/span>\n\t<\/span>swapint<\/span>(a, b);<\/span><\/span>\n\t<\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                              \n
                                                \n
                                              • C++ has added the reference<\/em>.<\/li>\n\n\n\n
                                              • The C++ compiler takes care of doing the right thing to satisfy the parameter passing mechanism<\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
                                                <\/span>References<\/span><\/h4>\n\n\n\n
                                                \n
                                                \n
                                                <\/path><\/path><\/svg><\/span>
                                                int<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>int<\/span> i, val = <\/span>1<\/span>;<\/span><\/span>\n\t<\/span>int<\/span> *iptr;<\/span><\/span>\n\t<\/span>int<\/span> &refval = val;<\/span>\t\/\/ must be initialized!<\/span><\/span>\n\t<\/span>float<\/span> data[] = {<\/span>2.3<\/span>, <\/span>5.2<\/span>, <\/span>17.9<\/span>};<\/span><\/span>\n\t<\/span>float<\/span> &refdata = <\/span>data<\/span>[<\/span>2<\/span>];<\/span><\/span>\n<\/span>\n\trefval += <\/span>2<\/span>;<\/span>\t\/\/ adds 2 to val<\/span><\/span>\n\ti = refval;<\/span>     \t\/\/ assigns val to i<\/span><\/span>\n\tiptr = &refval;<\/span> \t\/\/ points iptr to val<\/span><\/span>\n\t<\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                                \n
                                                  \n
                                                • Reference parameters are simply a special case of a reference variable<\/em>:<\/li>\n\n\n\n
                                                • A reference<\/em> is an alias<\/em> for another variable.<\/li>\n\n\n\n
                                                • A reference<\/em> is very like a pointer, except:\n
                                                    \n
                                                  • a reference<\/em> must be initialized, and:<\/li>\n\n\n\n
                                                  • once initialized, a reference<\/em> cannot be made to alias another object.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                                  • A reference<\/em> is not<\/em> an object<\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
                                                    <\/span>References to Pointers<\/span><\/h4>\n\n\n\n
                                                    \n
                                                    \n
                                                    <\/path><\/path><\/svg><\/span>
                                                    void<\/span> <\/span>swap<\/span>(<\/span>void<\/span> <\/span>**<\/span>first<\/span>, <\/span>void<\/span> <\/span>**<\/span>second<\/span>)<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>void<\/span> *temp = *first;<\/span><\/span>\n<\/span>\n\t*first = *second;<\/span>\t\/\/ swap pointers<\/span><\/span>\n\t*second = temp;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>int<\/span>   a = <\/span>1<\/span>,      b = <\/span>2<\/span>;<\/span><\/span>\n\t<\/span>int<\/span>   *aptr = &a, *bptr = &b;<\/span><\/span>\n\t<\/span>float<\/span> f = <\/span>1.0<\/span>,    g = <\/span>2.0<\/span>;<\/span><\/span>\n\t<\/span>float<\/span> *fptr = &f, *gptr = &g;<\/span><\/span>\n<\/span>\n\t<\/span>swap<\/span>(&aptr, &bptr);<\/span><\/span>\n\t<\/span>swap<\/span>(&fptr, &gptr);<\/span><\/span>\n\t<\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                                    \n
                                                      \n
                                                    • In C, we can often generalize functions by using arguments of type pointer to pointer to <\/em>void:<\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
                                                      \n
                                                      \n
                                                      <\/path><\/path><\/svg><\/span>
                                                      void<\/span> <\/span>swap<\/span>(<\/span>void<\/span> <\/span>*&<\/span>first<\/span>, <\/span>void<\/span> <\/span>*&<\/span>second<\/span>)<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>void<\/span> *temp = first;<\/span><\/span>\n<\/span>\n\tfirst = second;<\/span>\t\/\/ swap pointers<\/span><\/span>\n\tsecond = temp;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>int<\/span>   a = <\/span>1<\/span>,      b = <\/span>2<\/span>;<\/span><\/span>\n\t<\/span>void<\/span>  *aptr = &a, *bptr = &b;<\/span><\/span>\n\t<\/span>float<\/span> f = <\/span>1.0<\/span>,    g = <\/span>2.0<\/span>;<\/span><\/span>\n\t<\/span>void<\/span> *fptr = &f,  *gptr = &g;<\/span><\/span>\n<\/span>\n\t<\/span>swap<\/span>(aptr, bptr);<\/span><\/span>\n\t<\/span>swap<\/span>(fptr, gptr);<\/span><\/span>\n\t<\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                                      \n
                                                        \n
                                                      • C++ also supports references to pointers<\/em>, which provides a better solution.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
                                                        \n
                                                        \n
                                                        <\/path><\/path><\/svg><\/span>
                                                        void<\/span> <\/span>swap<\/span>(<\/span>int<\/span> <\/span>&<\/span>first<\/span>, <\/span>int<\/span> <\/span>&<\/span>second<\/span>)<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>int<\/span> temp = first;<\/span><\/span>\n\tfirst = second;<\/span><\/span>\n\tsecond = temp;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>int<\/span> a = <\/span>10<\/span>;<\/span><\/span>\n\t<\/span>unsigned<\/span> <\/span>int<\/span> b = <\/span>20<\/span>;<\/span><\/span>\n\t<\/span>swap<\/span>(a, b);<\/span><\/span>\n\t<\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                                        \n
                                                          \n
                                                        • Note that you have to be very careful mixing types with references;  if the type does not match exactly:<\/li>\n\n\n\n
                                                        • Here, the compiler does the equivalent of:<\/li>\n<\/ul>\n\n\n\n
                                                          <\/path><\/path><\/svg><\/span>
                                                          int<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>int<\/span> a = <\/span>10<\/span>;<\/span><\/span>\n\t<\/span>unsigned<\/span> <\/span>int<\/span> b = <\/span>20<\/span>;<\/span><\/span>\n\t<\/span>int<\/span> T = <\/span>int<\/span>(b);<\/span><\/span>\n\t<\/span>swap<\/span>(a, T);<\/span><\/span>\n\t<\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
                                                          Note the careful datatype matching in the previous example!<\/p>\n<\/div>\n<\/div>\n\n\n\n
                                                          <\/span>Functions Returning References<\/span><\/h4>\n\n\n\n
                                                          \n
                                                          \n
                                                          <\/path><\/path><\/svg><\/span>
                                                          struct<\/span> <\/span>Location<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>int<\/span> x, y;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nLocation<\/span> <\/span>&<\/span>Position<\/span>(<\/span>int<\/span> <\/span>newx<\/span>, <\/span>int<\/span> <\/span>newy<\/span>)<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>static<\/span> Location myloc;<\/span><\/span>\n<\/span>\n\t<\/span>myloc<\/span>.<\/span>x<\/span> = newx;<\/span><\/span>\n\t<\/span>myloc<\/span>.<\/span>y<\/span> = newy;<\/span><\/span>\n\t<\/span>return<\/span> myloc;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n\tLocation here = {<\/span>0<\/span>, <\/span>0<\/span>};<\/span><\/span>\n\there = <\/span>Position<\/span>(<\/span>10<\/span>, <\/span>20<\/span>);<\/span><\/span>\n\t<\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                                          \n
                                                            \n
                                                          • Functions may also be declared as returning references:<\/li>\n<\/ul>\n\n\n\n
                                                              \n
                                                            • Note that the static<\/strong> storage specifier is extremely important here!  Why?<\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
                                                              <\/span>Advantages of References<\/span><\/h4>\n\n\n\n
                                                              Advantages of references<\/em> are:<\/p>\n\n\n\n
                                                                \n
                                                              • They clean up syntax <\/em>significantly.<\/li>\n\n\n\n
                                                              • They place the responsibility<\/em> for proper argument passing on the compiler<\/em>, and on the supplier<\/em> of a function, rather than the client<\/em>.<\/li>\n\n\n\n
                                                              • They typically are more efficient for function argument passing, especially for large objects.<\/li>\n<\/ul>\n\n\n\n
                                                                <\/span>The inline Specifier<\/span><\/h3>\n\n\n\n
                                                                We encourage procedural abstraction<\/em>, but this can cause programs to run more slowly if you use lots of functions.<\/p>\n\n\n\n
                                                                C’s solution to this was to define a macro ‘function’:<\/p>\n\n\n\n
                                                                #define min(x, y) ((x) < (y) ? (x) : (y))<\/code><\/pre>\n\n\n\n
                                                                But this is considered undesireable because:<\/p>\n\n\n\n
                                                                  \n
                                                                • Lack of Type Checking: Macros do not undergo type-checking during compilation. …<\/li>\n\n\n\n
                                                                • Difficulty in Debugging: Macros can make code harder to debug due to their inline nature. …<\/li>\n\n\n\n
                                                                • Potential for Code Bloat: Macros can result in code duplication when used extensively throughout the program.<\/li>\n<\/ul>\n\n\n\n
                                                                  C++ helps solve this problem by supporting inline<\/strong> functions:<\/p>\n\n\n\n
                                                                  inline int min(int i, int j)\n{\n\treturn (i < j) ? i : j;\n}<\/code><\/pre>\n\n\n\n
                                                                    \n
                                                                  • inline<\/strong> is only a hint<\/em> to the compiler<\/li>\n\n\n\n
                                                                  • inline<\/strong> causes the function to have default internal linkage<\/em><\/li>\n\n\n\n
                                                                  • inline<\/strong> becomes very important within classes<\/li>\n<\/ul>\n\n\n\n
                                                                    <\/span>The new and delete Operators<\/span><\/h3>\n\n\n\n
                                                                    \n
                                                                    \n
                                                                    <\/path><\/path><\/svg><\/span>
                                                                    #include<\/span> <\/span><stdio.h><\/span><\/span>\n#include<\/span> <\/span><stdlib.h><\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>int<\/span> *iptr;<\/span><\/span>\n<\/span>\n\tiptr = <\/span>malloc<\/span>(<\/span>sizeof<\/span>(<\/span>int<\/span>));<\/span>\t\/\/ check return value!<\/span><\/span>\n\t*iptr = <\/span>5<\/span>;<\/span><\/span>\n\t<\/span>printf<\/span>(<\/span>"<\/span>%d<\/span>\\n<\/span>"<\/span>, *iptr);<\/span><\/span>\n\t<\/span>free<\/span>(iptr);<\/span><\/span>\n\t<\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                                                    \n
                                                                      \n
                                                                    • C does not have support in the language for dynamically allocated objects;  you have to call the malloc()<\/strong> (or calloc()<\/strong>, etc.) function to allocate space, make sure the space is initialized, and eventually deallocate the space using the free()<\/strong> function:<\/li>\n\n\n\n
                                                                    • Modern languages like Ada support this in the language:<\/li>\n<\/ul>\n\n\n\n
                                                                      type INT_PTR is access INT;\nMY_INT : INT_PTR;\n       ...\nMY_INT := new INT_PTR;\n<\/code><\/pre>\n<\/div>\n<\/div>\n\n\n\n
                                                                      \n
                                                                      \n
                                                                      <\/path><\/path><\/svg><\/span>
                                                                      #include<\/span> <\/span><iostream><\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>int<\/span> *iptr = <\/span>new<\/span> <\/span>int<\/span>;<\/span><\/span>\n  <\/span>char<\/span> *string = <\/span>new<\/span> <\/span>char<\/span>[<\/span>40<\/span>];<\/span><\/span>\n  \/\/ Check for success<\/span><\/span>\n  \/\/ (Really need to catch exception)<\/span><\/span>\n  <\/span>if<\/span> ((iptr == <\/span>NULL<\/span>) || (string == <\/span>NULL<\/span>))<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>std<\/span>::cerr << <\/span>"No memory"<\/span> <\/span><\/span>\n              << <\/span>std<\/span>::endl;<\/span><\/span>\n    <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n  }<\/span><\/span>\n  *iptr = <\/span>5<\/span>;<\/span><\/span>\n  <\/span>std<\/span>::cout << *iptr;<\/span><\/span>\n  <\/span>delete<\/span> iptr;<\/span>\t\/\/ use this on scalars<\/span><\/span>\n  <\/span>delete<\/span> <\/span>[]<\/span> string;<\/span> \/\/ use this on arrays<\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                                                      \n
                                                                        \n
                                                                      • C++ provides similar operators<\/em>, new<\/strong> and delete<\/strong>:<\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
                                                                        new<\/strong> and delete<\/strong> are C++ operators<\/em>, and are typed<\/em>.  The typing is particularly valuable.<\/p>\n\n\n\n
                                                                        For a scalar, use the simple forms of new<\/strong> and delete<\/strong>:<\/p>\n\n\n\n
                                                                        int *iptr = new int;  \/* ... *\/ delete iptr;<\/strong><\/code><\/pre>\n\n\n\n
                                                                        For an array, specify size to the new operator:<\/p>\n\n\n\n
                                                                        int *iarrayptr = new int[5];<\/strong><\/code><\/pre>\n\n\n\n
                                                                        For an array, use the delete[]<\/strong> form of the delete operator, and do not<\/em> specify the size of the array:<\/p>\n\n\n\n
                                                                        delete[] iarrayptr;<\/strong><\/code><\/pre>\n\n\n\n
                                                                        Space is allocated from the free store<\/em>(heap)<\/em><\/p>\n\n\n\n
                                                                          \n
                                                                        • If the space requested is not available, new<\/strong> returns a NULL<\/strong> pointer, just like malloc<\/strong>, except that:<\/li>\n\n\n\n
                                                                        • The C++ ANSI\/ISO committee changed the behavior of new to raise an exception <\/em>if it fails to allocate space.<\/li>\n\n\n\n
                                                                        • Note that some compilers (including Microsoft Visual C++) have maintained the older behavior, for backwards compatibility.  You can explicitly choose the new behavior with the use of a compiler switch.<\/li>\n<\/ul>\n\n\n\n
                                                                          new<\/strong> and delete<\/strong> become particularly important with classes.<\/p>\n\n\n\n
                                                                          \n
                                                                          \n
                                                                          <\/path><\/path><\/svg><\/span>
                                                                          #include<\/span> <\/span><new.h><\/span><\/span>\n#include<\/span> <\/span><iostream.h><\/span><\/span>\n\t     <\/span><\/span>\nvoid<\/span> <\/span>heap_problem<\/span>()<\/span><\/span>\n{<\/span><\/span>\n\tcerr << <\/span>"operator new failed<\/span>\\n<\/span>"<\/span>;<\/span><\/span>\n    \/* ... *\/<\/span><\/span>\n}\t <\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{          <\/span><\/span>\n\t<\/span>void<\/span> (*<\/span>old_new_handler<\/span>)();<\/span><\/span>\n    \/* ... *\/<\/span><\/span>\n\told_new_handler = <\/span><\/span>\n\t\t\t<\/span>set_new_handler<\/span>(heap_problem);<\/span><\/span>\n    \/* ...  *\/<\/span><\/span>\n\t<\/span>set_new_handler<\/span>(old_new_handler);<\/span><\/span>\n\t<\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                                                          \n
                                                                            \n
                                                                          • Unlike malloc()<\/strong>, new<\/strong> can handle failures to allocate space:<\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
                                                                            <\/span>void* and Functions Returning void<\/span><\/h3>\n\n\n\n
                                                                            \n
                                                                            \n
                                                                            ANSI C includes two concepts which came from C++:<\/p>\n\n\n\n
                                                                              \n
                                                                            • Pointers to void<\/strong> (meaning unknown type<\/em>):<\/li>\n<\/ul>\n\n\n\n
                                                                              void *generic_ptr;<\/strong><\/code><\/pre>\n\n\n\n
                                                                                \n
                                                                              • Functions returning void<\/strong> (meaning no value<\/em>)<\/li>\n<\/ul>\n\n\n\n
                                                                                void my_procedure(int errogate, \n                  double cross);\n{\n    \/* ... *\/\n}\n<\/strong><\/code><\/pre>\n\n\n\n
                                                                                ANSI C allows the assignment of a pointer of type void*<\/strong> to a pointer of any other type.<\/p>\n<\/div>\n\n\n\n
                                                                                \n
                                                                                C++ is stricter; it requires an explicit cast:<\/p>\n\n\n\n
                                                                                <\/path><\/path><\/svg><\/span>
                                                                                int<\/span> <\/span>main<\/span>()\t       <\/span><\/span>\n{<\/span><\/span>\n\t<\/span>int<\/span> i;<\/span><\/span>\n\t<\/span>void<\/span> *vptr = &i;<\/span><\/span>\n\t<\/span>char<\/span> *cptr = vptr;<\/span> \t\/\/ allowed in ANSI C<\/span><\/span>\n\t<\/span>char<\/span> *cptr = (<\/span>char<\/span>*) vptr;<\/span>\t\/\/ required by C++<\/span><\/span>\n\t   \/* ... *\/<\/span><\/span>\n\t<\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
                                                                                Overview of Small Enhancements New Keywords and Reserved Words C keywords C++ keywords added: Line-Style Comments Some Differences Due to Stronger Typing In C++, literal character constants (‘a’) are of type char; in C, they are of type int: In C++, the use of an undeclared function is an error; in C, an undeclared function […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":1871,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-918","page","type-page","status-publish","hentry"],"blocksy_meta":[],"_links":{"self":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/918","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/comments?post=918"}],"version-history":[{"count":15,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/918\/revisions"}],"predecessor-version":[{"id":1681,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/918\/revisions\/1681"}],"up":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/1871"}],"wp:attachment":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/media?parent=918"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}