3. • C - an older programming language that is described as Hands-on. As
the programmer you must tell the program to do everything. Also this
language will let you do almost anything. It does not support object
oriented code. Thus no classes.
• C++ - an extension language per se of C. In C code ++ means increment
1. Thus C++ is better than C. It allows for highly controlled object
oriented code. Once again a very hands on language that goes into
MUCH detail.
• C# - Full object oriented code resembling the style of C/C++ code. This
is really closer to JAVA. C# is the latest version of the C style languages
and is very good for developing web applications.
4. • Both C and C++ give you a lower level of abstraction that, with increased
complexity, provides a breadth of access to underlying machine functionality
that are not necessarily exposed with other languages.
• C++ adds the convenience (reduced development time) of a fully object oriented
language which can, potentially, add an additional performance cost. In terms of
real world applications, I see these languages applied in the following domains:
• C is a Kernel level software for Hardware device drivers withApplications where
access to old, stable code is required.
• C,C++ is a Application or Server development where memory management
needs to be fine tuned (and can't be left to generic garbage collection solutions).
• Development environments that require access to libraries that do not interface
well with more modern managed languages.
• Although managed C++ can be used to access the .NET framework, it is not a
seamless transition.
5. • C# provides a managed memory model that adds a higher level of abstraction again. This level
of abstraction adds convenience and improves development times, but complicates access to
lower level APIs and makes specialized performance requirements problematic.
• It is certainly possible to implement extremely high performance software in a managed
memory environment, but awareness of the implications is essential.
• The syntax of C# is certainly less demanding (and error prone) than C/C++ and has, for the
initiated programmer, a shallower learning curve.
• C# is a Rapid client application development. With High performance Server development
(Stack Overflow for example) that benefits from the .NET framework.
• Applications that require the benefits of the .NET framework in the language it was designed
for.
• Johannes Rössel makes the valid point that the use C# Pointers, Unsafe and Unchecked
keywords break through the layer of abstraction upon which C# is built. I would emphasize
that type of programming is the exception to most C# development scenarios and not a
fundamental part of the language (as is the case with C/C++).
6. Garbage Collection
• Garbage Collection (GC) is the single most important factor in differentiating between these
languages.
• While C and C++ can be used with GC, it is a bolted-on afterthought and cannot be made to
work as well (the best known is here) - it has to be "conservative" which means that it cannot
collect all unused memory.
• C# is designed from the ground up to work on a GC platform, with standard libraries also
designed that way. It makes an absolutely fundamental difference to developer productivity
that has to be experienced to be believed.
• There is a belief widespread among C/C++ users that GC equates with "bad performance". But
this is out-of-date folklore (even the Boehm collector on C/C++ performs much better than
most people expect it to).
• The typical fear is of "long pauses" where the program stops so the GC can do some work. But
in reality these long pauses happen with non-GC programs, because they run on top of a
virtual memory system, which occasionally interrupts to move data between physical memory
and disk.
7. • Since adopting C# about 18 months ago I've gone through several phases of
pure performance tuning with a profiler, and the GC is so efficient that it is
practically invisible during the operation of the program.
• GC is not a panacea, it doesn't solve all programming problems, it only really
cleans up memory allocation, if you're allocating very large memory blocks
then you will still need to take some care, and it is still possible to have what
amounts to a memory leak in a sufficiently complex program - and yet, the
effect of GC on productivity makes it a pretty close approximation to a
panacea!
• There is also widespread belief that GC can be replaced with shared_ptr, but
it can't; the irony is that in a multi-threaded program, shared_ptr is slower
than a GC-based system.
• There are environments that are so frugal that GC isn't practical - but these
are increasingly rare. Cell phones typically have GC. The CLR's GC that C#
typically runs on appears to be state-of-the-art.
8. Undefined Behavior
• C++ is founded on the notion of undefined behavior. That is, the language
specification defines the outcome of certain narrowly defined usages of language
features, and describes all other usages as causing undefined behavior, meaning in
principle that the operation could have any outcome at all (in practice this means
hard-to-diagnose bugs involving apparently non-deterministic corruption of data).
• Almost everything about C++ touches on undefined behavior. Even very nice
forthcoming features like lambda expressions can easily be used as convenient way to
corrupt the stack (capture a local by reference, allow the lambda instance to outlive
the local).
• C# is founded on the principle that all possible operations should have defined
behavior. The worst that can happen is an exception is thrown. This completely
changes the experience of software construction.
• (There's unsafe mode, which has pointers and therefore undefined behavior, but that
is strongly discouraged for general use - think of it as analogous to embedded
assembly language.)
9. Complexity
• In terms of complexity, C++ has to be singled out, especially if we
consider the very-soon-to-be standardized new version. C++ does
absolutely everything it can to make itself effective, short of assuming
GC, and as a result it has an awesome learning curve.
• The language designers excuse much of this by saying "Those features
are only for library authors, not ordinary users" - but to be truly
effective in any language, you need to build your code as reusable
libraries. So you can't escape.
• On the positive side, C++ is so complex, it's like a playground for
nerds! I can assure you that you would have a lot of fun learning how
it all fits together. But I can't seriously recommend it as a basis for
productive new work (oh, the wasted years...) on mainstream
platforms.
10. • C keeps the language simple (simple in the sense of "the
compiler is easy to write"), but this makes the coding techniques
more arcane.
• Note that not all new language features equate with added
complexity. Some language features are described as "syntactic
sugar", because they are shorthand that the compiler expands
for you. This is a good way to think of a great deal of the
enhancements to C# over recent years. The language standard
even specifies some features by giving the translation to
longhand, e.g. using statement expands into try/finally.
• At one point, it was possible to think of C++ templates in the
same way. But they've since become so powerful that they are
now form the basis of a whole separate dimension of the
language, with its own enthusiastic user communities and
idioms.
11. Libraries
• The strangest thing about C and C++ is that they don't have a standard
interchangeable form of pre-compiled library. Integrating someone else's code
into your project is always a little fiddly, with obscure decisions to be made
about how you'll be linking to it.
• Also, the standard library is extremely basic - C++ has a complete set of data
structures and a way of representing strings (std::string), but that's still
minimal.
• Is there a standard way of finding a list of files in a directory? Amazingly, no! Is
there standard library support for parsing or generating XML? No. What about
accessing databases? Be serious! Writing a web site back-end? Are you crazy?
etc.
• So you have to go hunting further afield. For XML, try Xerces. But does it
use std::string to represent strings? Of course not!
12. • And do all these third-party libraries have their own bizarre
customs for naming classes and functions? The situation in C#
couldn't be more different;
• the fundamentals were in place from the start, so everything
inter-operates beautifully (and because the fundamentals are
supplied by the CLR, there is cross-language support).
• It's not all perfect; generics should have been in place from the
start but wasn't, which does leave a visible scar on some older
libraries; but it is usually trivial to fix this externally.
• Also a number of popular libraries are ported from Java, which
isn't as good a fit as it first appears.
13. Closures (Anonymous Methods with Local
Variable Capture)
• Java and C are practically the last remaining mainstream languages to lack
closures, and libraries can be designed and used much more neatly with them
than without (this is one reason why ported Java libraries sometimes seem
clunky to a C# user).
• The amusing thing about C++ is that its standard library was designed as if
closures were available in the language (container
types, <algorithm>, <functional>). Then ten years went by, and now they're
finally being added! They will have a huge impact (although, as noted above,
they leak undefined behavior).
• C# and JavaScript are the most widely used languages in which closures are
"idiomatically established". (The major difference between those languages
being that C# is statically typed while JavaScript is dynamically typed).
14. Leave feedback & question in the comments
for our channel updates
Hit on like button below
For more visit our website
www.sirykt.blogspot.com
