Re: Use of const for non-reference parameters

From:

Howard Hinnant <howard.hinnant@gmail.com>

Newsgroups:

comp.lang.c++

Date:

Thu, 16 Jun 2011 13:49:53 -0700 (PDT)

Message-ID:

<9e808451-1a06-4111-a302-c067d702fda1@t14g2000yqc.googlegroups.com>

On Jun 16, 4:22 pm, Michael DOUBEZ <michael.dou...@free.fr> wrote:

On 16 juin, 18:50, Howard Hinnant <howard.hinn...@gmail.com> wrote:

On Jun 16, 4:53 am, Urs Thuermann <u...@isnogud.escape.de> wrote:

I'm working on a project that uses const for function parameters that
are neither references nor pointers, i.e. something like this:

int foo(const int a) { ... }
int bar(const string b) { ... }

I don't see why this is useful. Since the argument is copied to th=

called function it doesn't matter to the caller whether the argument
is modified or not. So why would one want to write code like that?

There is a potential performance penalty with your second example
(const heavy-weight-type). Consider this slight modification of your
example bar:

   string bar(const string b);

If this function does nothing but modify a copy of b and return it,
then this is seriously prematurely pessimized, especially in C++11:

   string bar(const string b) // bad
   {
        string x(b);
        x += "more text";
        return x;
   }

This should instead be written:

   string bar(string b) // good
   {
        b += "more text";
        return b;
   }

When the argument to bar is an lvalue string, the first implementation
does 2 copies and 1 move. The second implementation will do 1 copy
and 1 move.

When the argument to bar is an rvalue string, the first implementation
does 1 copy and 1 move. The second implementation will do 0 copies
and 1 move.

Either way, the first implementation is always too expensive by 1
copy.

Are you sure of that ? Did you observe it on a compiler ?

Did you?

#include <iostream>

struct string
{
    string() {}
    string(const string&) {std::cout << "copy construct\n";}
    string& operator=(const string&) {std::cout << "copy assign\n";
return *this;}
    string(string&&) {std::cout << "move construct\n";}
    string& operator=(string&&) {std::cout << "move assign\n"; return
*this;}

    void operator+=(const char*) {}
};

#if SLOW

string bar(const string b)
{
    string x(b);
    x += "more text";
    return x;
}

#else

string bar(string b)
{
    b += "more text";
    return b;
}

#endif

int main()
{
    std::cout << "test lvalue\n";
    string s;
    string s1 = bar(s);
    std::cout << "\ntest rvalue\n";
    string s2 = bar(string());
}

$ clang++ -std=c++0x -stdlib=libc++ -DSLOW test.cpp
$ a.out
test lvalue
copy construct
copy construct

test rvalue
copy construct

$ clang++ -std=c++0x -stdlib=libc++ test.cpp
$ a.out
test lvalue
copy construct
move construct

test rvalue
move construct

Yet, this is pure speculation because compiler have ways to optimise
code beyond our abilities.

<cough>

Howard