CISC 3142
Programming Paradigms in C++
Part II: Basic Facilities
Chapter 6 — Types and Declarations

Overview

Topics

ISO Standard

Here are the various categories of behavior:

• well-defined behavior
  • specified and documented for all implementations
    • semantics of short-circuited logical operators
• implementation-defined behavior
  • behavior is well-defined and documented, but can vary from one implementation to another
    • size of various integer types
    • numeric limits
    • packing of adjacent bit fields/elements
• unspecified behavior
  • well-defined behavior, but not specified
    • pointer value returned by new
    • order of local variables placed on stack
    • order of evaluation of function arguments within an expression

    f(x++) + g(x++)
    				

• undefined behavior
  • no reasonable behavior required by implementation
    • accessing or modifying element outside bounds of an array
    • value of uninitialized local variable

Types

• Built-in types
  • Fundamental types
    • arithmetic
      • integral
        • bool
          • bool implicitly converted to integer
            • true to 1; false to 0
          • integer implicitly converted to bool
            • 0 to false; anything else to true
          • pointer implicitly converted to bool
            • non-null to true; null to false
        • character
          • default char is usually 8 bits; other char types for wider (wchar_t, char_16t, etc)
        • integer — short, int, long, long, long
      • floating point — float, double, long double
    • void
  • Derived/Compound types: allow the creation of types from existing types using declarator operators (*, [], &)
    • pointers, arrays, and references
• User-defined types
  • struct, class, enumeration

Declarations

• scope
  • local

    int f(int x) {
    	int y;
    	…
    }
    				

  • class

    class C {
    	…
    private:
    	int x;
    };
    				

  • namespace
  • global

    int x;
    
    int f() {…}
    				

  • statement

    for (int i = 0; i < n; i++)
    	…
    				

  • function

Initialization

• Four flavors
  • X a1 {v}

    int i {17};
    				

    int a[] {1, 2, 3, 4};
    				

    Person p {1001, "Gerald", "Weiss"};
    				

    • list initialization
      • in this context, the {…} is an actual type (actually a class template from the STL) … std::initializer_list
    • always permitted, and recommended
    • no narrowing allowed

      int i {2.0};	// compilation error on narrowing from double to int
      						

  • X a2 = {v};

    int arr[] = {1, 2, 3, 4};
    						

    Person p = {1001, "Gerald", "Weiss"};
    						

    • Array (and struct/class) initialization
    • appears in older code
  • X a3 = v;

    int x = 17;
    				

    Counter c = 12;
    				

    • used when single initialization value (or constructor argument)
    • appears in older code
  • X a4(v);

    Person p(1001, "Gerald", "Weiss");
    				

    • general constructor invocation
    • appears in older code

No initializer?

• global, namespace, local static, static member (static objects) are initialized to the 0 of the type
• local variables and objects created on the free store / heap (i.e., with new) remain uninitialized unless they are of a class type with a default constructor.

Objects and Values

• lvalues and rvalues
  • lvalue is an object in memory
    • left side of an assignment
  • rvalue — anything not an lvalue
    • right side of an assignment
• Lifetime
  • automatic (on stack created/destroyed in synch with function)
  • static (lifetime of program)
  • free store (heap / programmer-controlled / dynamic) created/destroyed using new/delete
  • temporary
  array elements and data members created/destroyed with their enclosing objects (the array or class object)

Type alias

• allows replacement for long or complicated types

  using intp = int *;
  
  using uchar = unsigned char;
  	

• allows semantically-meaningful name instead of generic name

  using Speed = int;
  	

Advice