doc/B.lwc-vs-C++

   1 Differences between C++ and lwc -- most of them
   2
   3
   4 A. C++ features not present in lwc
   5 ==================================
   6
   7 1. Access control (public, private, protected, friend) in classes
   8    is absent. Everything is accessible.
   9
  10 2. The scope operator '::' is not there. In lwc we have the
  11    dot '.' for declarations that would require '::'.
  12    In order to access specific members of parent classes
  13    (casts) are used. Example:
  14                 class A {
  15                         virtual int f ();
  16                 };
  17                 class B : A {
  18                         int f () {
  19                                 ((A*)this)->f ();
  20                         }
  21                 };
  22
  23 3. No initialization lists in constructors.
  24    Constructors can be called at any time with "ctor()",
  25    so calling ctors of parent classes does not require a section
  26    where expressions are interpreted differently.
  27
  28 3b. In constructors, virtual calls, are still virtual.
  29    In C++ in a constructor calls always call the current
  30    type's function as if the object type was known.
  31
  32 4. Destructors do not automatically call destructors of
  33    parent classes. This is generally cofused in C++.
  34    Constructors of Base not automagically called when
  35    constructing Derrived objects.
  36
  37 4b. Also, in the case below, no destructor is called at all!
  38         class A { ~A() {} };
  39         class B : A { };
  40         int f ()
  41         {
  42                 B b;
  43         }
  44    because 'B' doesn't have a destructor. Also, as a consequence
  45    of this, where C++ would require 'virtual destructors' to do
  46    proper deletion without crashes, lwc'd better have 'auto virtual
  47    destructors'.
  48
  49 5a. Exceptions do not throw types. Exceptions in lwc can
  50    be identified by a simple integer value.
  51
  52 5b. Exceptions can't call the destructors of local objects
  53    while unwinding the stack. Plain C can't help us implementing
  54    that. We need compiler support (EH frame).
  55
  56 5c. type_id NOT PRESENT (virtual variables are the general case
  57    of it).
  58
  59 6. Templates not implemented. Generic programming can be
  60    alternativelly implemented with lwc's "template classes".
  61    STL is not there.
  62
  63 6b. No template functions.
  64
  65 7. Virtual inheritance accross different files does not work
  66    without "virtual inheritance declarations": All files must
  67    agree that a class has the same virtually derrived classes.
  68
  69 8. Operator overloading casts not implemented.
  70
  71 9. If a function returns an object which is passed as a tmp
  72    to another function (common case in operator overloading),
  73    the destructor of the temporary object is never called!!
  74
  75 10. unions may have data members only. They can only be PODs.
  76
  77 11. C++ casts are absent (static, reinterpret, dynamic, const).
  78
  79 12. 'mutable' not present.
  80
  81 13. Pointer to member, etc, not implemented.
  82
  83 14. The virtual table ABI is much different. lwc's vtable
  84    ABI results in faster code.
  85
  86 15. At the moment, classes with virtual parents are not
  87   position independent.
  88
  89 16. lwc can call plain C functions without 'extern "C"'.
  90   plain C code can call lwc functions (but not overloaded ones).
  91
  92 16a. lwc in a way resurrects 'overload'. lwc invokes mangled overloading
  93   function names if it sees more than one declaration for a function.
  94   A problematic case in lwc is:
  95         # file1.c
  96         void foo () { }
  97         # file2.c
  98         void foo ();
  99         void foo (int);
 100         void bar () { foo (); }
 101   where in file1 foo is not an overloaded function while in file2 it is.
 102
 103 17. 'enum' is really an 'int' and it is not possible to overload
 104   functions based on different enum type arguments. enums in lwc
 105   are just 'generators of constants', as in C.
 106
 107 17b. Same applies to 'bool'. 'bool' in lwc is a synonym for 'int'
 108
 109 18. new and delete can't be used to allocate non-classes.
 110   new and delete are compatible with malloc() and free().
 111
 112 19. Namespaces are not implemented. Nor is the 'using' keyword.
 113
 114 20. Static class members not implemented. static class members
 115    only make sense with access control to 'hide' a global variable.
 116    In lwc, "virtual variables" do the right thing.
 117
 118 21. consts can't be used as array initializers, for example.
 119         const int X = 12;
 120         int A [X];
 121     generates C as it is, and it is invalid in C.
 122
 123 22. Destructors of global objects not called at exit (yet).
 124
 125 23. Inheritance and function overloading has slightly different rules.
 126   In C++ the code:
 127         class A {
 128                 int foo (int);
 129                 int foo (char*);
 130         };
 131         class B : A {
 132                 int foo (int);
 133                 int bar () {
 134                         foo ("Hi mom!");
 135                 }
 136         };
 137    does not work!!!
 138    In lwc it works and calls the foo(char*) function!
 139    But in general, function overloading is very primitive in lwc except
 140    from this design decission.
 141
 142 24. goto and destruction of local objects don't cooperate.
 143   Goto is considered harmful unless you are an expert. So experts
 144   can adjust their destruction of locals manually.
 145
 146 25. No generalized 'assignment is construction' declarations.
 147   This is not possible in lwc:
 148         int i (34);
 149
 150 26. No trigraphs :(((((
 151