🚀 go-pugleaf

Pieter Philippaerts wrote:
> Ik weet niet zeker of dat voor IL ook zo is. IL heeft voor zover ik weet ongeveer
> alles wat x86 ook heeft en ik zie dus geen probleem om C++ te laten compilen
> naar IL (after all, het compiled al naar zoveel verschillende instructie
> sets).

Ik ben eens wat gaan zoeken in google en wat gaan lezen. Hopelijk krijgen
we daardoor een discussie op grond van feiten in plaats van
"gevoelens", "vermoedens", en "90% zeker".

Samenvatting:
* destructors en/of stack-based variabelen hebben een andere semantiek
  dan in C++ voorgeschreven is. Daarmee gooi je een belangrijk techniek
  in C++ (bekend onder de gekke naam RAII) overboord. Zonder RAII zou
  ik een stuk minder productief in C++ zijn.
* RTTI (RunTime Type Information) van IL is anders dan die van C++,
  dus je kunt de C++ RTTI niet gebruiken.
* geen non-public inheritance in .NET. Jammer, want dat heeft toch
  echt wel toepassingen.
* const (en volatile) worden niet ondersteund. En "const-correctness"
  is in C++ toch een zeer belangrijk concept.
* managed templates worden (nog) niet ondersteund.

Dus we houden over: C++ zonder destructors, stack based variabelen,
templates, const, en RTTI. Probeer maar eens een serieus, modern C++
programma te vinden dat die onderdelen niet gebruikt.

Mijn conclusie: "managed C++" is geen C++ want te veel onderdelen
van C++ zijn niet mogelijk.

Details:
[Alle quotes zijn voorafgegaan door "*", mijn commentaar staat ertussen]

http://msdn.microsoft.com/msdnmag/nettop.asp?page=/msdnmag/issues/01/07/vsnet/vsnet.asp&ad=ads.ddj.com/msdnmag/premium.htm
* Unfortunately, managed classes can't be created on the stack.
* They have to be created on the managed heap so that the garbage
* collector can manage them. .NET does have something called value types
* that can be allocated on the stack but, unfortunately, they are not allowed
* to have destructors. In fact, managed types don't really have destructors
* (the method that's called when the object goes out of scope) at all in
* the C++ sense.
C++ constructors kunnen dus niet in .NET worden gevangen.

Verderop:
* (.NET doesn't support managed templates yet.)
Dus ook de C++ templates kunnen we voorlopig nog vergeten.

http://www.gotdotnet.com/team/cplusplus/articles/mcspec.doc
Hoofdstuk 25 noemt wat beperkingen:
* There is no verifier for MSIL generated for Managed Extensions
  for C++ programs.
  Developers and testers need to check code for conditions that may
  have adverse effects. These include buffer and stack overflows, type
  correctness, and pointer operations.
* The C++ RTTI operators shall not be applied to managed objects.
  RTTI is not supported.
* The common language runtime has no representation for non-public
  inheritance.
* The const and volatile modifiers on member functions are not supported.

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dndotnet/html/drgui02132002.asp
*  But this power comes at a price: First, as you know, C++ is somewhat
*  more complicated than, say, C# or Visual Basic .NET. More importantly,
*  Visual C++ .NET code cannot be made verifiably type-safe. This means
*  that Visual C++ .NET modules must be trusted, so many of the scenarios
*  where you download code over the Internet from a source you don't totally
*  trust won't work with code generated by this version of Visual C++ .NET.
*  (Allowing Visual C++ .NET to produce verifiably type-safe code is a top
*  priority for a future release.)

Sjoerd Schreuder