Standardizing Your Code

• Standard Functionality
• Explicit Template Instantiation
• Keywords
• Overloading new[ ] and delete[ ] for Arrays
• Passing Standards Related Options to the Compiler
• Standard Exception Classes
• Standard Exceptions
• type_info Class
• HP aC++ Extensions to the Language
• Unsupported Functionality

Migration

• Migration Considerations Related to Standardization

HP aC++ Keywords

Usage

Example

void main(){
bool b=true; // Declare a variable of type bool and set it to true.
if (b)       // Test value of bool variable.
   b=false;  // Set it to false.
}

Usage

Example Code with Discussion

class Base {
   virtual void f();                 // Make Base a polymorphic type.
   // other class details omitted
};

class Derived : public Base {
   // class details omitted
};

void Base::f()
{
   // define Base function
}

void main()
{
   Base *p;
   Derived *q;

   Base b;
   Derived d;

   p = &b;
   q = dynamic_cast<Derived *>  (p);       // Yields zero.

   p = &d;
   q = dynamic_cast<Derived *>  (p);       // Yields p treated
                                           // as a derived pointer.
}

q = dynamic_cast <Derived> (p);

The result type of a dynamic cast must be a pointer or
reference to a complete class; the actual type was Derived.

class Base {
   // class details omitted
};

class Derived : public Base {
   // class details omitted
};

void main()
{
   Base *p;
   Derived *q;

   Base b;
   p = &b;
   q = dynamic_cast<Derived *> (p);
}

The above generates a compile-time error stating that:

Dynamic down-casts and cross-casts must start from a polymorphic class
(one that contains or inherits a virtual function); but class Base is
not polymorphic.

class Base {
   virtual void f();                 // Make Base a polymorphic type
   // other class details omitted
};

class Derived : public Base {
public:
   void derivedFunction();
   // other class details omitted
};

void Base::f()
{
   // Define Base function.
}

void Derived::derivedFunction()
{
}

void main()
{
   Base *p = new Derived;

   // details omitted

   if (Derived *q = dynamic_cast<Derived *>  (p))
      q->derivedFunction();          // use derived function
}

class Base1 {
   // Not a polymorphic type.
   // additional class details omitted
};

class Base2 {
   virtual void f();        // Make Base2 polymorphic.
   // additional class details omitted
};

void Base2::f()
{
   // Define Base2 function.
}

class Derived : public virtual Base1, public virtual Base2 {
   // additional class details omitted
};

void main()
{
   Base1 *bp1;
   Base2 *bp2;
   Derived *dp;

   bp1 = new Derived;
   bp2 = new Derived;

   // dp = (Derived *) bp1;              // Problem: compile time error
                                         // Can't cast from virtual base.

   // dp = (Derived *) bp2;              // Problem: compile time error
                                         // Can't cast from virtual base.

   // dp = dynamic_cast<Derived *> bp1;  // Problem: compile time error
                                         // Can't cast from
                                         // non-polymorphic type.

   dp = dynamic_cast<Derived *> bp2;     // OK
}

The explicit keyword is used for declaring constructor functions within class declarations. When these functions are declared explicit, they cannot be used for implicit conversions.

Usage

Example Code with Discussion

class C {
public:
  explicit C(int);
};

C::C(int)
{
  // empty definition
}

void main()
{
  C c(5);           // Legal
  c = C(10);        // Legal
  // c = 15;        // Produces a compile time error:
                    // Message: Cannot assign 'C' with 'int'.
  // c + 20;        // Produces a compile time error
}

class Vector {
public:
  Vector(int n);                    // create a vector of n items

  // other class details omitted

};

void main()
{
  Vector operator + (Vector, Vector);

  Vector v1(10), v2(10);            // create two 10 element vectors
  // details omitted
  v1 = v2 + 5;                      // Legal - converts int 5 to a 5
                                    // element vector and adds to v2.
                                    // Not something you want to be
                                    // legal
}

class Vector {
public:
  explicit Vector(int n);           // create a vector of n items

  // other class details omitted
};

void  main()
{
  Vector operator + (Vector, Vector);

  Vector v1(10), v2(10);            // create two 10 element vectors

  // details omitted

  // v1 = v2 + 5;                   // Not legal - generates compile-
  // time error
  // Message: Illegal types
  // associated with operator '+':
  // 'Vector' and 'int'.
}

Usage

An example of this is a use or reference count in an object that keeps track of the number of pointers referring to it.

Example Code with Discussion

class C {
public:
  C();
  int i;
  mutable int j;
};

C::C() : i(1), j(3)
{
  // Define constructor
}

void main()
{
  const C c1;
  C c2;

  // c1.i =0;               // Problem: compilation error
                            // Message: The left side of '=' must be
                            // a modifiable lvalue.
  c1.j = 1;                 // OK
  c2.i = 2;                 // OK
  c2.j = 3;                 // OK
}

class C {
  C() { }                   // define constructor

  mutable const int *p;     // OK
                            // mutable pointer to int const
                            // p in constant C object can be modified

  mutable int *const q;     // Compile time error
                            // mutable const pointer to int
                            // const data member can't be mutable
                            // Message: 'mutable' may be used only
                            // in non-static and non-constant data
                            // member declarations within class
                            // declarations.
};

• Basic Concepts
• Connections Across Translation Units
• using-declarations and using-directives
• Using the -Wc,-koenig_lookup,on Command Line Option

Basic Concepts

As can be seen, every namespace introduces a new scope. By default, names inside a namespace are hidden from enclosing scopes. Selection of a particular name can be achieved using the qualified-name syntax.

Namespaces can be nested very much like classes.

#include <stdio.h>

namespace N {
   struct Object {
      virtual char const* name() const { return "Object from N"; }
   };
}


namespace M {
   struct Object {
      virtual char const* name() const { return "Object from M"; }
   };

   namespace X {    // a nested namespace
      struct Object: M::Object {  // inherit from a class in the outer space
         char const* name() const { return "Object from M::X"; }
      };
   }
}


int main() {
   N::Object o1;
   M::Object o2;
   M::X::Object o3;
   printf("This object is: %s.\n", o1.name());
   printf("This object is: %s.\n", o2.name());
   printf("This object is: %s.\n", o3.name());
   return 0;
}

Connections Across Translation Units

One somewhat unique feature of namespaces is that they can be extended. The example below shows this as well as the connections between a namespace extending across different translation units.

The example also illustrates the concept of so-called unnamed namespaces. These namespaces can only be extended within a translation unit. Unnamed namespaces in different translation units are unrelated; hence their names effectively have internal linkage. In fact, the ANSI/ISO C++ International Standard specifies that using static to indicate internal linkage is deprecated in favor of using namespaces.

#include <stdio.h>

namespace N {
   char const* f() { return "f()"; }
}

namespace {      // An unnamed namespace
   char const* f(double);
} // Names in unnamed namespaces are visible in their surrounding scope.
  // They cannot be qualified since the space has no name.


namespace N {    // An extension of the first part of namespace N
   char const* f(int); // Leave the implementation to another
}                      // translation unit.

int main() {
   printf("Calling: %s.\n", N::f());  // OK, declared and defined above
   printf("Calling: %s.\n", N::f(7)); // OK, declared above (defined elsewhere)
   printf("Calling: %s.\n", f(3.0));  // OK, declared above (defined below)
   return 0;
}

namespace { // An extension of the unnamed namespace in this translation unit
   char const* f(double) { return "f(double) in main() translation unit"; }
}

An Auxiliary Translation Unit

namespace { // An unnamed namespace unrelated to the one in the other
            // translation units.
   char const* f(double) { return "f(double) in auxiliary translation unit"; }
}


namespace N { // This namespace is the same as the one in the main()
              // translation unit. We implement f(int) here.
   char const* f(int) { return "f(int) defined in auxiliary translation unit"; }
}

using-declarations and using-directives

using-declaration

using N::x;    // Where N is a namespace, x is a name in N

After this declaration, all uses of x in this scope are taken to
defer to N::x.  (The N:: prefix is no longer required.)

int x;

then a compiler error would occur.

using-derective

using namespace N; // If not found, lookup names in namespace N

If x is a name in namespace N, but another declaration of x is present
in the current scope, for example:

int x;

a compiler error is not necessarily emitted.  Only if that name is used
will an ambiguity occur.

Using namespace directives can be a powerful means to migrate code to libraries that use namespaces. Occasionally, however, they may silently make unwanted names visible. It is therefore often suggested not to use using-directives unless the alternatives are very inconvenient.

#include <stdio.h>

namespace N {
   char const* f() { return "N::f()"; }
   char const* f(double) { return "N::f(double)"; }
   char const* g() { return "N::g()"; }
}

char const* g(double) {
   using N::f;           // Declare all f's in namespace N
   return f(2.0);
}

namespace M {            // Illustrate how using-directives
   using namespace N;    // are transitive
}

int main() {
   using namespace N;
   printf("Calling: %s.\n", f());       // calls N::f()
   printf("Calling: %s.\n", g(1.0));    // calls ::g(double)
                                        // which calls
                                        // N::f(double)
   printf("Calling: %s.\n", N::g());    // calls N::g()
   printf("Calling: %s.\n", M::f());    // calls N::f()
   return 0;
}

Usage

For More Information

• typeid Example Code with Discussion
• type_info Class

typeid Example Code with Discussion

# include <iostream.h>
# include <typeinfo>

class Base {
   virtual void f();        // Must have a virtual function to
                            // be a polymorphic type.
   // additional class details omitted
};

class Derived : public Base {

   // class details omitted
};

void Base::f()
{
   // Define function from Base.
}

void main ()
{
   Base *p;

   // Code which does either
   //        p = new Base; or
   //        p = new Derived;

   // Note that this is NOT a good design for this functionality.
   // Virtual functions would be better.

   if (typeid(*p) == typeid(Base))
      cout << "Base Object\n";
   else if (typeid(*p) == typeid(Derived))
      cout << "Derived Object\n";
   else
   cout << "Another Kind of Object\n";
}

The style of programming used in the above example might be called a typeid switch statement. It is not generally a reasonable design. One alternative is to use a virtual function in a base class specialized in each of its derived classes. In some cases, this may not be possible, for example, when the base class is provided by a library for which source code is not available. In other cases it may not be desirable, for example, some base class interfaces might be too big if all derived class functionality is included.

You could rewrite the above example, using virtual functions, as:

class Base {
   virtual void outputType() { cout << "Base Object\n"; }

   // additional class details omitted
};

class Derived : public Base {
   virtual void outputType() { cout << "Derived Object\n"; }
// additional class details omitted
};

void main ()
{
   Base *p;

   // code which does either
   //        p = new Base; or
   //        p = new Derived;

   p->outputType();
}

You could rewrite the above example as follows using dynamic casts:

class Base {
    virtual void f();          // Must have a virtual function to
    // be a polymorphic type.
    // additional class details omitted
};

class Derived : public Base {

   // class details omitted
};

void Base::f()
{
    // Define function from Base.
}

void main ()
{
    Base *p;

    // code which does either
    //        p = new Base; or
    //        p = new Derived;

    if (dynamic_cast <Derived *> (p))
        cout << "Derived (or class derived from Derived) Object\n";
    else
        cout << "Base Object\n";
}

This keyword is part of the ANSI C standard with the same syntax and semantics.

Usage

Note, you can declare an identifier to be both const and volatile. This declares a value that the program cannot change but which can be changed by some means external to the program (such as by a piece of hardware like a clock).

Example Code with Discussion

class C {
public:                      // public to make example simpler
volatile int i;
// other class details omitted
};

C someData[10];

void main ()
{
   int j = someData[5].i;
   j = someData[5].i;        // Without the volatile specifier, the
                             // compiler could optimize these two
                             // statements into one. With it, it must
                             // execute both in case the i field of
                             // someData[5] has changed by some
                             // other means.
}

Usage

Example Code with Discussion

void main()
{
  wchar_t ch = L'a';
}

The standard library includes a string of wide characters known as wstring. The IOStream library supports I/O of wide characters.

In ANSI C, wchar_t is a synonym for another type, declared using a typedef in a standard header file.

typename Keyword

Use the typename keyword in template declarations to specify that a qualified name is a type, not a class member.

Usage

Example Code

template<class T>
class C1 {
  // class details omitted

  // T::C2 *p;              // Problem: flagged as compile-time
                            // error. T is a type, but T::C2 is not.
                            // Message: 'C2' is used as a type, but
                            // has not been defined as a type.


typename T::C2 *p;          // Solution: the keyword typename flags
                            // the qualified name T::C2 as a type.
};

class C {
  // details omitted
  class C2 {
    //details omitted
  };
};

void main ()
{
  C1<C> c;
}

Discussion

• Use it as the argument to the template (T below):

template<class T>
class C {
  // Additional details omitted
};

• Use it as the name of the template (C below):

template<class T>
class C {
  // Additional details omitted
};

• Declare a class as a member of the class template (C2 below):

template<class T>
class C1 {
  class C2;
  // Additional details omitted
};

• Declare a class in the context the template is declared within (C1 below):

class C1;
template<class T>
class C2 {
  // details omitted
};

Usage

For More Information

• Example Code with Discussion
• Migration -- Using operator new to Allocate Arrays

Example Code with Discussion

# include <iostream.h>
class C {
  public:
    void* operator new[ ] (size_t);        // new for arrays
    void operator delete[ ] (void*);       // delete for arrays

    // additional class details omitted
};

void* C::operator new[ ] (size_t  allocSize)
{
  cout << "Use operator new[ ] from class C\n";

    // here, real usage would include allocation

return ::operator new[ ] (allocSize);     // global operator
}                                         // for this simple example

void C::operator delete[ ] (void *p)
{
  cout << "Use operator delete[ ] from class C\n";

    // here, real usage would include deallocation

  ::operator delete[ ] (p);               // global operator
}                                         // for this simple example

void main()
{
  C *p;

  p = new C[10];
  delete[ ] p;
}

Multidimensional arrays can be allocated and deallocated with these operators. The operator is used with several array dimensions, and the compiler provides the size_t argument which is the space required for the entire array. For example:

// call C::operator new[ ] ( ) with
// an argument of 10 * 20 * sizeof(C)

p = new C [10] [20];

The global new and delete for both arrays and single objects are provided in the Standard C++ Library. This library also provides a version of new for arrays and single objects that takes a second void* argument and constructs the object at that address.

Standard Exception Classes

Classes are provided in the Standard C++ Library to report program errors. These classes are declared in the <stdexcept> header. All of these classes inherit from a common base class named exception. The two classes logic_error and runtime_error inherit from exception and serve as base classes for more specific errors.

Usage

Example

# include <stdexcept>
# include <iostream>
# include <string>
void f()
{
  // details omitted

  throw range_error(string("some info"));
}

void main()
{
  try {
    f();
  }
  catch (runtime_error& r) {
    // handle any kind of runtime error including range_error
    cout << r.what() << '\n';
  }
}

Discussion

• domain_error (the operation requested is inconsistent with the state of the object it is applied to)
• invalid_argument
• length_error (an attempt to create an object whose size equals or exceeds allowed size)
• out_of_range (an argument value not in the expected range).

• range_error
• overflow_error (arithmetic overflow)

Each of the subclasses includes a constructor taking an instance of the Standard C++ Library string class as an argument. They initialize an instance such that the function what(), when applied to the instance, returns a value equal to the argument to the constructor.

Exceptions Thrown by the Standard C++ Library

The following exceptions are thrown by the Standard C++ Library. CAUTION: If no catch clauses are available to catch these exceptions, the default action is program termination with a call to abort(). (Note that using the +noeh option does not disable the exceptions thrown by these library functions.)

• operator new () and operator new [ ] throw a bad_alloc exception when they cannot obtain a block of storage.
• A dynamic_cast expression throws a bad_cast exception when a cast to a reference type fails.
• Operator typeid throws a bad_type exception when a pointer to a typeid expression is zero.
• A bad_exception exception can be thrown when the unexpected handler function is invoked by unexpected().

Usage

Usage

Example

# include <iostream.h>
# include <typeinfo>

class Base {
   virtual void f();          // Must have a virtual function to
                              // be a polymorphic type
   // additional class details omitted
};

class Derived : public Base {
   // class details omitted
};

void Base::f()
{
// Define function from Base.
}

void main ()
{
   Base *p;

   // code which does either
   //       p = new Base; or
   //       p = new Derived;

   if (typeid(*p) == typeid(Base))       // Standard requires
                                         // comparison as part of
                                         // this class.
      cout << "Base Object\n";

   cout << typeid(*p).name() << '\n';    // Standard requires access to
                                         // the name of the type.
}

int operator == (const type_info&) const
int operator !=( const type_info&) const
const char * name() const
int before (const type_info&) const

Functionality defined in the ANSI/ISO C++ International Standard and not supported in this release of HP aC++ is listed below. Library functionality is listed separately.

NOTE: These are not all inclusive lists.

• Template Features
• separation model for template compilation (export keyword)
• template template parameters
• omission of template parameter names
• support for universal-character-sequences (\uxxxx)

** Available when compiled with -D_XOPEN_SOURCE=500. Also, the application must be linked with /usr/lib/hpux##/unix98.o, where ## is either 32 or 64.