Re: C programmer migrating to C++
On Jan 25, 1:50 pm, Bartosz Wiklak <bwik...@gmail.com> wrote:
Hello, I'm coding in C form many years but for a year or something
like that I'm trying to get rig of "bad" old habits and start to do
things better.
OK, I've been there. In my experience: C++ starts to work really well
once you accept that C++ is a different language and you try to do
things the C++ way. As long as you try to mix C and C++, the C++ part
will get in your way.
There are couple of annoyances in C++ I cannot solve - probably I'm
doing something wrong.
I wonder If someone could help me:
1)
Consider such function definition
void f( int k, const T* t, T2* t2=NULL);
Use references where you can and pointers where you have to. Functions
overloads can help here. Just implement the most general function with
all arguments and add some simplified overloads that forward into the
general function with the defaults filled in. This gives you much more
flexibility for defining the defaults than the f(T arg = defaultValue)
syntax does. Don't worry about possible overhead of nested function
calls, in C++ we leave these details to the compiler/optimizer.
2)
Returning objects:
Suppose I want to have a method that returns a "large" object, let it
be a "comp.lang.c++.moderated" string.
I can do it this way:
string& foo( string& buf ){ buf="comp.lang.c++.moderated"; return
buf; }
but I need do such things in my code:
string s;
foo(s);
I would like to do sth. like this:
string s = foo();
If I define foo function like that:
string foo(){ string buf="comp.lang.c++.moderated"; return buf; }
I'll work but as far as I understand it'll run several constructors
and copy constructors and I would like to make such operation work as
fast as [ string s("comp.lang.c++.moderated"); ]
BTW, is [ string s("comp.lang.c++.moderated"); ] faster than [ string
s ="comp.lang.c++.moderated"; ] or maybe it is compiler dependent?
Again choose the most straightforward approach:
string foo()
{
return "comp.lang.c++.moderated";
}
Trust the compiler to make this efficient. In the very atypical case
where detailed optimization matters: use a profiler to localize the
performance problem and only then fall back to less than
straightforward code to address it. You may be surprised to find that
modern compilers can turn high level C++ constructions into efficient
code.
Summary: Don't worry the low level details: think in abstract data
types and operations. Let the compiler optimize your code.
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]