10

I try such simple code:

#include <cstdio>
#include <string>

int main()
{
   const std::string s = std::string("a") + "b";
   puts(s.c_str());
   return 0;
 }

I expect that compiler(gcc 4.8.2/clang 3.5.0) optimize such code to

 int main()
 {
   puts("ab");
   return 0;
 }

But I can not get such result, I try different options like "-Ofast", "-flto", "-static-libstdc++", but always see in disassembler output three functions call:

...
callq  0x4017e0 <_ZNSsC2EPKcRKSaIcE>
... 
callq  0x401690 <_ZNSs6appendEPKc>
...
callq  0x401490 <_ZNSs4_Rep10_M_disposeERKSaIcE>

The first one is call to std::basic_string, std::allocator >::basic_string(char const*, std::allocator const&).

So are any compiler around, that can optmize such code to just puts("ab"); or at least to "std::string s("ab");"?

And if there are no such compiler, what make such optimization difficult to implement?

Update About real world usage. I see/saw many places in real code with such pattern:

  std::string s = std::string(string_const1) + string_const2 + string_variable + string_const3;

And if performance is important, of course it is possible to rewrite such code in more optimal ways.

But modern compilers do great jobs to optimize code. And gcc, for example have __builtin functions for malloc/free/strcpy/strcat and so on. And if std::basic_string from libstdc++ from gcc use them this functions(malloc,free,strcpy,strcat) for part of implementation, why not predict the result of functions usage and give answer.

Improve this question
3
  • 1
    Because C++ class constructors and operators are functions, they are not algebraic, thus it is difficult to detect algebraic optimizations. Commented Nov 4, 2014 at 0:40
  • 2
    You didn't say why you want to do this, but would 'const std::string s = "a" "b";' fit your needs? String literals auto paste when written next to each other. Commented Nov 4, 2014 at 1:00
  • To be clear, the C++ standard permits the program to be optimized to puts("ab"); or equivalent. But compilers don't do it. I guess you would have to ask a compiler developer, but perhaps part of it has to do with respecting the wishes of the programmer. If they followed the as-if rule ultimately then there would be a lot of complaints; e.g. making a system call to write something on the screen, or do a sleep, has no observable behaviour as per the definition in C++14. Commented Nov 4, 2014 at 4:33

1 Answer 1

Reset to default
8

std::string involves dynamic allocation of storage and, in most cases, an extremely complex implementation and can therefore not be reduced to compile-time semantics, no matter how well the compiler has constant folding down to a fine art.

However: If your string is actually declared like this why didn't you use a char array in the first place but chose string? If you need to work with some strings to produce others, there are still tools that can do that job with char arrays, especially since C++11 introduced variadic templates and constexpr. A future version of C++ will hopefully also introduce std::string_literal to further ease that.

Improve this answer
Sign up to request clarification or add additional context in comments.

7 Comments

Would it be possible to use C++14 features to have a constexpr std::string::operator+ and implement OP's request?
@liori I should think so since string_literal is based on C++14.
There is also the complicating issue that GCC's std::string is still copy-on-write.
@Columbo Yes. It's non-conforming, but changing it would be ABI-breaking.
>why didn't you use a char array in the first place but chose string? Because of it is not real code, and where code similar to above occurs , it is not worth manual optimization, but I am curios why compiler can not optimize it for me.
|

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.