

C++11 use in Chromium - pdknsk
http://chromium-cpp.appspot.com/

======
heycam
The equivalent rules for Mozilla code: [https://developer.mozilla.org/en-
US/docs/Using_CXX_in_Mozill...](https://developer.mozilla.org/en-
US/docs/Using_CXX_in_Mozilla_code)

------
jcmakon
Visual Studio limiting progress as always..

~~~
pjmlp
Visual Studio 2014 is already much better.

[http://blogs.msdn.com/b/vcblog/archive/2014/08/21/c-11-14-fe...](http://blogs.msdn.com/b/vcblog/archive/2014/08/21/c-11-14-features-
in-visual-studio-14-ctp3.aspx)

Last time I checked, outside most C++ compilers were still catching up with
C++11.

There are more C++ compilers out there than just clang and gcc. Even those
aren't 100% compliant at library level, if I am not mistaken.

~~~
jonstewart
It must have been a while since you last checked. Many of the features listed
here as banned because of lack of VisualStudio support have been available in
gcc and clang for years.

~~~
pjmlp
GCC 4.9.1, was released on 2014-07-16.

Still quite a few rows with N.

[https://gcc.gnu.org/onlinedocs/libstdc++/manual/status.html#...](https://gcc.gnu.org/onlinedocs/libstdc++/manual/status.html#status.iso.2011)

I was only wrong about clang.

So my point still holds for gcc, and it doesn't change the fact, that there
are more compilers out there than the triad clang, gcc, vc++.

------
jesuslop
Move semantics banned until revision.

~~~
nhaehnle
I would be curious about the rationale behind this. Move semantics are a clear
win in many situations, and I don't see any obvious pitfalls associated with
them. I am curious especially about mere std::move; I'm aware that using
rvalue references directly can be a bit confusing initially, and it makes
sense to reduce their use.

~~~
kentonv
Last I heard the C++ style arbiters at Google (a handful of very-senior
engineers who dictate how everyone else at the company should write code) felt
that rvalue references were too hard to understand and would therefore lead to
more problems than they solve.

Admittedly my knowledge is a couple years old, but the rule specified here of
"you can only use them with explicit permission from the C++ style arbiters;
maybe we'll reconsider later" seems consistent with that reasoning.

I'm glad I don't follow their rules anymore. rvalue references are incredibly
useful in making ownership transfers explicit, and although they may sound
confusing on first description, once you get the hang of it, they are easy to
reason about.

~~~
ajross
The problem is you're demanding that the entire coding population of a large
company "get the hang of it" or else be confused by their tools. That is a
proposition with non-zero cost, so it needs to be weight against the derived
benefit.

And IMHO for move semantics, that benefit is pretty low. The overwhelming
number of allocation bugs with C++ code are treated very well by RAII already.
Move semantics tend to be best used in library code that implements some kind
of dynamic runtime. And let's be honest: that's stuff that (1) tends to be
done by experts already and (2) has been done successfully and robustly for
decades in C anyway. Larry and Guido didn't need move semantics...

~~~
kentonv
> The problem is you're demanding that the entire coding population of a large
> company "get the hang of it" or else be confused by their tools.

The fact of life in C++ is that you have to grasp a number of not-entirely-
intuitive concepts before you can be effective with it. Rvalue references are
not particularly hard compared to many of the others. Consider how much time
newbies spend wrapping their head around pointers -- something that
experienced C++ programmers have absolutely no trouble with.

The only reason we're holding rvalue references to a higher standard than any
other C++ feature is because they're new, which means that even people who
have been coding in C++ for decades suddenly find that there is a language
construct they don't immediately understand. Not having felt this way for a
very long time, they conclude that this particular construct must be much more
complicated than everything else, when in fact it's not.

> The overwhelming number of allocation bugs with C++ code are treated very
> well by RAII already.

Move semantics make it vastly easier to use RAII in the first place. Without
them, RAII does not play nicely with transferring ownership over a call or a
return. You can use reference-counted smart pointers, but they are slow
(require atomic ops). You can try to emulate move semantics via documentation
and conventions, but this is error-prone. Clean ownership transfers have
always been a sore spot in C++ prior to rvalue references.

I don't know about you, but the introduction of move semantics into my style
completely transformed my code for the better.

~~~
aboodman
Chromium uses move semantics all over the place:

[https://code.google.com/p/chromium/codesearch#search/&q=move...](https://code.google.com/p/chromium/codesearch#search/&q=move_only_type&sq=package:chromium&type=cs)

We don't allow the standard version yet partly for the reason explained
downthread: it requires stl support to be very useful and not all the
platforms we target are compatible yet.

------
femngi
Stuff like this makes me really regret being a C++ developer. Companies and
projects are adopting new features at a glacial pace and yet the programming
world is still moving forward and it feels like despite the best efforts of
the committee and the compiler teams C++ is doomed to continue being a 'legacy
language' as companies either continue migrating to C# or sticking with C++98.

~~~
CountSessine
Instead of living with regret, why not ask yourself what kind of software you
want to be writing and what kind of problems you want to be solving? Some
software _should_ be migrated to C# and Java. On the other hand, when it comes
to runtime performance, memory footprint, and compiler and runtime
availability, nothing matches (or even comes close yet) to C/C++.

~~~
pjmlp
Ada? D? Turbo Pascal? Modula-2?...

Some of C and C++ advantages come from having 30 years of compiler
optimizations, while compiler vendors stoped caring about implementations for
other languages.

I am big on C++, but as a language geek, I am looking forward to .NET Native
release, and see how far it can take C# in this language X vs language Y
discussions.

~~~
CountSessine
_Ada? D? Turbo Pascal? Modula-2?..._

All great languages, but try finding a D compiler for a Blackfin chip, or
something similarly esoteric. C++ just goes more places where you would want
it to go.

 _Some of C and C++ advantages come from having 30 years of compiler
optimizations, while compiler vendors stoped caring about implementations for
other languages._

Certainly - with a clean slate in 2014, you'd design something else -
something that would make static analysis easier and static constraints
possible. Basically, something like Rust. But C++11 is still pretty cool.

 _I am big on C++, but as a language geek, I am looking forward to .NET Native
release, and see how far it can take C# in this language X vs language Y
discussions._

I had no idea C# was 'going native'. I guess we've come full circle, what with
this and news of Android L moving to ahead-of-time-compiled 'java'. Still, I
have absolutely no interest in C#.

~~~
pjmlp
> All great languages, but try finding a D compiler for a Blackfin chip, or
> something similarly esoteric. C++ just goes more places where you would want
> it to go.

Historical accident of compiler market. Not directly related to the
programming languages themselves.

> I had no idea C# was 'going native'.

C# is already native when you target Windows Phone 8. It is just going native
on the remaining Microsoft platforms.

------
xpaulbettsx
Is there a great guide to C++11 as a language? Typing "Learn C++11" into
Google always results in information mixed with legacy C++

~~~
pjmlp
The new book from Bjarne "Tour of C++".

~~~
krylon
Thanks for the suggestion. I am not a C++ programmer[1], but I try to keep an
open mind about other languages. I loved reading Design And Evolution of C++,
Bjarne has a very nice writing style.

[1] Last year, I spent about a week doing maintenance on what you could call a
legacy C++ application at customer site (I work as a sysadmin at a process
engineering company). It was strangely fun (lucky for me, the application was
quite well-written and I could easily find my way around the code).

