ramneek handa's List: C++ Std Interpretations

• In addition to the facilities provided by C, C++  provides additional data types, classes, templates, exceptions, names-  paces, inline functions, operator overloading, function name overload-  ing, references, free store management operators, and additional  library facilities.
• --dynamic type: The dynamic type of an lvalue expression is the type  of the most derived object (_intro.object_) to which the lvalue  refers. [Example: if a pointer (_dcl.ptr_) p whose static type is  "pointer to class B" is pointing to an object of class D, derived  from B (_class.derived_), the dynamic type of the expression *p is  "D." References (_dcl.ref_) are treated similarly. ] The dynamic  type of an rvalue expression is its static type.
• --parameter: an object or reference declared as part of a function  declaration or definition, or in the catch clause of an exception  handler that acquires a value on entry to the function or handler;  an identifier from the comma-separated list bounded by the parenthe-  ses immediately following the macro name in a function-like macro  definition; or a template-parameter. Parameters are also known as  "formal arguments" or "formal parameters."

  • Notice the diff between arguments and parameters
• --static type: The static type of an expression is the type  (_basic.types_) resulting from analysis of the program without con-  sideration of execution semantics. It depends only on the form of  the program and does not change while the program is executing.
• 2) Function signatures do not include return type, because that does  not participate in overload resolution.
• Some objects are polymorphic  (_class.virtual_); the implementation generates information associated  with each such object that makes it possible to determine that  object's type during program execution. For other objects, the inter-  pretation of the values found therein is determined by the type of the  expressions (_expr_) used to access them.
• Objects can contain other objects, called sub-objects. A sub-object  can be a member sub-object (_class.mem_), a base class sub-object  (_class.derived_), or an array element. An object that is not a sub-  object of any other object is called a complete object.
• If a complete object, a data member (_class.mem_), or an array element  is of class type, its type is considered the most derived class, to  distinguish it from the class type of any base class subobject; an  object of a most derived class type is called a most derived object.

  • remember it can be considered and is a type of any base class. std is just trying to say that type of an object is most derived type that it was declared with unless it is a pointer..?
• Unless it is a bit-field (_class.bit_), a most derived object shall  have a non-zero size and shall occupy one or more bytes of storage.  Base class sub-objects may have zero size. An object of POD type  (_basic.types_) shall occupy contiguous bytes of storage.
• 1 The semantic descriptions in this International Standard define a  parameterized nondeterministic abstract machine. This International  Standard places no requirement on the structure of conforming imple-  mentations. In particular, they need not copy or emulate the struc-  ture of the abstract machine. Rather, conforming implementations are  required to emulate (only) the observable behavior of the abstract  machine as explained below.3)
• sequence points
• A full-expression is an expression that is not a subexpression of  another expression.
• 16[Note: operators can be regrouped according to the usual mathematical  rules only where the operators really are associative or  commutative.7) For example, in the following fragment  int a, b;  /*...*/  a = a + 32760 + b + 5;  the expression statement behaves exactly the same as  a = (((a + 32760) + b) + 5);  due to the associativity and precedence of these operators. Thus, the  result of the sum (a + 32760) is next added to b, and that result is  then added to 5 which results in the value assigned to a. On a  machine in which overflows produce an exception and in which the range  of values representable by an int is [-32768,+32767], the implementa-  tion cannot rewrite this expression as  a = ((a + b) + 32765);  since if the values for a and b were, respectively, -32754 and -15,  the sum a + b would produce an exception while the original expression  would not; nor can the expression be rewritten either as  a = ((a + 32765) + b);  or  a = (a + (b + 32765));  since the values for a and b might have been, respectively, 4 and -8  or -17 and 12. However on a machine in which overflows do not produce  an exception and in which the results of overflows are reversible, the  above expression statement can be rewritten by the implementation in  any of the above ways because the same result will occur. ]

  • very interesting. Order of operands matter and need to be preserved so that the exceptions can be detected? although not sure of the reason?
• Overloaded operators are never assumed to be associative or commu-  tative.
• 7) Overloaded operators are never assumed to be associative or commu-  tative.
• 8) As specified in _class.temporary_, after the "end-of-full-expres-  sion" sequence point, a sequence of zero or more invocations of de-  structor functions for temporary objects takes place, usually in re-  verse order of the construction of each temporary object.

  • suggests that temporary should be destructed as soon as evaluation is over.. may be compiler dependant
• In the evaluation of each of the expressions  a && b  a || b  a ? b : c  a , b  using the built-in meaning of the operators in these expressions  (_expr.log.and_, _expr.log.or_, _expr.cond_, _expr.comma_) there is a  sequence point after the evaluation of the first expression10).
• 10) The operators indicated in this paragraph are the built-in opera-  tors, as described in Clause _expr_. When one of these operators is  overloaded (_over_) in a valid context, thus designating a user-de-  fined operator function, the expression designates a function invoca-  tion, and the operands form an argument list, without an implied se-  quence point between them.

16 more annotations...

• lvalue
• C++'s notion of type, scope,  linkage, and storage duration.
• An entity is a value, object, subobject, base class subobject, array  element, variable, function, instance of a function, enumerator, type,  class member, template, or namespace.
• A name is a use of an identifier (_lex.name_) that denotes an entity  or label (_stmt.goto_, _stmt.label_). A variable is introduced by the  declaration of an object. The variable's name denotes the object.
• Every name that denotes an entity is introduced by a declaration.
• name lookup (_basic.lookup_).
• 8 An identifier used in more than one translation unit can potentially  refer to the same entity in these translation units depending on the  linkage (_basic.link_) of the identifier specified in each translation  unit.
• A declaration is a definition unless it declares a function without  specifying the function's body (_dcl.fct.def_), it contains the extern  specifier (_dcl.stc_) or a linkage-specification1) (_dcl.link_) and  neither an initializer nor a function-body, it declares a static data  member in a class declaration (_class.static_), it is a class name  declaration (_class.name_), or it is a typedef declaration (_dcl.type-  def_), a using-declaration (_namespace.udecl_), or a using-directive  (_namespace.udir_).
• 6 A program is ill-formed if the definition of any object gives the  object an incompletely-defined object type (_basic.types_).

  • Only template classes or partially speciallized ones.. abstract classes are not deemed incomplete as you will read later on
• evaluated

  • evaluated at runtime
• typeid operator and does not designate an lvalue of polymorphic class  type (_expr.typeid_).

  • typeid on polymorphic classes are runtime evaluated others are compile time
• An inline function shall be defined in every transla-  tion unit in which it is used.
• --an expression is converted (either implicitly or explicitly) to type  T (_conv_, _expr.type.conv_, _expr.dynamic.cast_,  _expr.static.cast_, _expr.cast_), or   --an expression is converted to the type pointer to T or reference to  T using an implicit conversion (_conv_), a dynamic_cast  (_expr.dynamic.cast_) or a static_cast (_expr.static.cast_), or

  • abstract classes are complete..
• There can be more than one definition of a class type (_class_), enu-  meration type (_dcl.enum_), inline function with external linkage  (_dcl.fct.spec_), class template (_temp_), non-static function tem-  plate (_temp.fct_), static data member of a class template  (_temp.static_), member function template (_temp.mem.func_), or tem-  plate specialization for which some template parameters are not speci-  fied (_temp.spec_, _temp.class.spec_) in a program provided that each  definition appears in a different translation unit, and provided the  definitions satisfy the following requirements.

  • The reason you can include headers in multiple translation unit..
• The names declared by a declaration are introduced into the scope in  which the declaration occurs, except that the presence of a friend  specifier (_class.friend_), certain uses of the elaborated-type-speci-  fier (_basic.scope.pdecl_), and using-directives (_namespace.udir_)  alter this general behavior.
• The point of declaration for a name is immediately after its complete  declarator (_dcl.decl_) and before its initializer (if any), except as  noted below. [Example:  int x = 12;  { int x = x; }  Here the second x is initialized with its own (indeterminate) value.  ]
• 2 [Note: a nonlocal name remains visible up to the point of declaration  of the local name that hides it. [Example:  const int i = 2;  { int i[i]; }  declares a local array of two integers. ] ]
• 3 The point of declaration for an enumerator is immediately after its  enumerator-definition. [Example:  const int x = 12;  { enum { x = x }; }  Here, the enumerator x is initialized with the value of the constant  x, namely 12. ]
• 4 After the point of declaration of a class member, the member name can  be looked up in the scope of its class. [Note: this is true even if  the class is an incomplete class. For example,  struct X {  enum E { z = 16 };  int b[X::z]; //ok  };  --end note]

17 more annotations...