David Ching said:
If I were just starting out, I would learn C#. But for experienced
C++ programmers, the situation is becoming clear: it is similar
to how C programmers could take their time learning C++ when
it suited them, and in the meantime, C was just fine. I think
my original plan to learn .NET with C++/CLI combined with
absorption of C# along the way (as most code samples are in C#)
is the way I will go.
I think you might be better off using C# for your .NET learning
- it will give you a clearer sense of how things are done in managed
code, and the learning effort from a C++ background is really a
matter of hours. If you learn .NET with C++/CLI, you might
inadvertently mix up managed and unmanaged coding style.
BTW I am trying to switch from C# to C++ and I must say, I found
the C# generics surprisingly easy to learn (though covariance would
have been nice at times) but C++ templates is a misty land I hesitate
to enter - I simply don't understand the implications of using them.
I recently had to do a binary search on an array, first in C# and
later in (unmanaged) C++.
In C#, this was easy. I examined the instance methods of the array
object, nothing relevant there so I tried the static methods of the
array class, and right there was a generic method that did what I
wanted. I had to ensure the comparison was done the right way,
but this wasn't too hard to find out from the docs.
With C++, things seemed more complicated. I soon figured out
STL had a binary_search template function and this was what
I needed. But it wasn't clear from the online help description
of the template how to make it work on an array. The template
required two iterators. It took me a good deal of browsing and
guessing, and a few questions to a colleague who is more
knowledgeable with C++ than I, to find a way out: I declared
two pointer variables, had them point to the first array element
and after the last, respectively, then passed them, and somehow
it seems the compiler "understands" that these variables can
be used as iterators. The resulting code looks nice but I don't
understand how the compiler casts my pointer variables as
iterators, and I'll probably step through the code in a disassembly
window before I dare trust that it does the right thing.
This seems to be the general picture: there seem to be nice
and elegant C++ solutions to the tasks I face, but it can take
much time and confusion to get there. Whereas C# helped
me on the track incredibly fast but there were things that
simply wouldn't get right - for this particular project I need
better control of the memory management etc. than I can get
with managed code, and that's my reason for learning C++.
I still think the clr is a big mistake but that's another matter...
)