Comment Feed for Channel 9 - C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank] http://media.ch9.ms/ch9/b648/6ebef5c4-c798-4856-8e28-88439928b648/CB2012HerbSutterYouDontKnow_220.jpg Channel 9 - C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank] Herb Sutter presents a "startling realization he had about C++11", and he thinks it may be a bit startling for others too. Tune in. This was filmed at C++ and Beyond 2012Download Herb's slides for this session. Abstract: In addition to the many new C++11 features that everyone's listing, it has dawned on me over the winter that there's actually another major change that isn't being talked about anywhere, or even being listed as a change in C++11 at all as far as I know, because I and other key experts and committee members I've asked didn't fully realize that we altered the basic meaning of not one but two fundamental keywords in C++. It's a change that has profound consequences, that rewrites and/or invalidates several pieces of pre-C++11 design guidance, and that's directly related to writing solid code in a concurrent and parallel world. This isn't just an academic change, either — everyone is going to have to learn and apply the new C++11 guidance that we'll cover in this session. I plan to talk about it first at C&B, in a session tentatively titled as above — I'll fill in the keywords later. You may already guess a few keyword candidates based on the description above, and here's a final hint: You'll hardly find two C++ keywords that are older, or whose meanings are more changed from C++98 to C++11. (No, they aren't auto and register.) en Fri, 24 May 2013 19:32:29 GMT Fri, 24 May 2013 19:32:29 GMT Rev9 Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank] does c++11 provide yield return and extension methods as we know them from C#?  Does it do away with header files?

 

posted by SteveRichter

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634925673097656340 Mon, 31 Dec 2012 16:15:09 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634925673097656340 SteveRichter Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank] Thanks Smiley

posted by felix9

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634925673424920516 Mon, 31 Dec 2012 16:15:42 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634925673424920516 felix9 Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank] posted by Christian Semmler

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634925681979287636 Mon, 31 Dec 2012 16:29:57 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634925681979287636 Christian Semmler Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank]
struct Foo {
int value;
void Mutate() const {
const_cast<int&>(value) = 42;
}
};

struct Bar {
mutable int value;
void Mutate() const {
value = 42;
}
};

const Foo foo = {};
const Bar bar = {};

int main() {
foo.Mutate(); // Undefined Behavior.
bar.Mutate(); // OK.
}

posted by Roman Perepelitsa

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634925770912670507 Mon, 31 Dec 2012 18:58:11 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634925770912670507 Roman Perepelitsa Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank] Ah the perfect end to 2012! This has been the best year for native code at Microsoft in well over a decade. Going into 2013 please keep up the investment in native, there has been much ground lost in both market and mindshare over the past ~12 years, but I passionately believe you guys can turn this around. Deliver the RTM parts previewed in the VC++ November CTP and you're well on your way to having IMO the best C++ 11 dev experience out there.

posted by tomkirbygreen

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634925783073349720 Mon, 31 Dec 2012 19:18:27 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634925783073349720 tomkirbygreen Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank] dot_tom: We're not letting up!! C

posted by Charles

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634926037163432211 Tue, 01 Jan 2013 02:21:56 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634926037163432211 Charles Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank] Why is const needed anyway?  C# does not have the concept.

Another C++ request ...  enum class.  Have a built in ToString method or enable enum class to have member functions, or add extension methods to the language.  The purpose being to enable enum specific code, like Parse and ToString, to be called using dot notation from an enum instance.

enum class Colors { red, white, blue } ;
Colors color = Colors::red ;
auto textColorName = color.ToString( )
auto anotherColor = Colors::Parse( textColorName ) ;

Bigger picture. Give me a native version of C#. Or enhance the struct handling capabilites of C#. ( C# cannot efficiently handle PIDLs used by windows shell. ) Microsoft to this day says that windows shell code written in C# is unsupported. A C# like native code language would be awesome.

 

posted by SteveRichter

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634926547474410577 Tue, 01 Jan 2013 16:32:27 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634926547474410577 SteveRichter Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank] posted by Tianyu

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634926605079590048 Tue, 01 Jan 2013 18:08:27 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634926605079590048 Tianyu Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank] Well, that's an interesting insight. It's going to take me a moment to wrap my head around this Smiley. I keep coming up with ways to invalidate it, but then go "oh, no, it still holds..."

posted by PhrostByte

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634926721204961388 Tue, 01 Jan 2013 21:22:00 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634926721204961388 PhrostByte Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank]
Shouldn't the following mean the same?

mutable std::mutex<int> m1;
const std::mutex<int> m2;

If not, why?

posted by petke

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634926810076391501 Tue, 01 Jan 2013 23:50:07 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634926810076391501 petke Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank]
When you have a const object, you're telling the compiler to forbid use of all non-const functions; the compiler can, in that manner, enforce the const/thread-safe guarantees that the class writer gave you.

When you call something mutable under the new definition, you're stating 'I trust the author of this type to have made it entirely synchronized/thread-safe'. The compiler will then not restrict what methods you can call.

I would argue that mutable is a keyword indicating your trust in the author, whereas const is about the author providing compiler-enforceable guarantees for the user.

Code example:
struct myStruct {
const mutex m1;
mutable mutex m2;

void f1() const { m1.lock(); } //COMPILE-TIME ERROR
void f2() const { m2.lock(); }
};

int main() {
const myStruct x;
x.f2(); //OK - author claims that myStruct is internally synchronized

return 0;
}

posted by turck3

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634927098864675196 Wed, 02 Jan 2013 07:51:26 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634927098864675196 turck3 Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank]

posted by petke

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634927315550998649 Wed, 02 Jan 2013 13:52:35 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634927315550998649 petke Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank] I think Herb is wrong. Const implies thread-safe, but thread-safe does not imply const, so the two are not equal/equivalent.

Concurrent containers etc will certainly be thread-safe but not all functions will be const.

posted by XTF

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634927323753274643 Wed, 02 Jan 2013 14:06:15 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634927323753274643 XTF Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank]
mutable class Mutex{/*...*/};

rather than

class A {
mutable Mutex m;
};


?

posted by Arkadiy Belousov

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634927331540869271 Wed, 02 Jan 2013 14:19:14 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634927331540869271 Arkadiy Belousov Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank]

Steve, the whole point of C++ is to give you the tools to make such a class.

 

but in practice Tianyu, you end up getting some inscrutable compile errors.

Find the error in this code.  Note the bullshit compile error.

  void Tester2( unique_ptr<std::wstring> pString )  {  }  void CallTester2( )  {    unique_ptr<std::wstring> pString ;    Tester2( pString ) ;  }

 

 4 IntelliSense: "std::unique_ptr<_Ty, _Dx>::unique_ptr(const std::unique_ptr<_Ty, _Dx>::_Myt &) [with _Ty=std::wstring, _Dx=std::default_delete<std::wstring>]" (declared at line 1447 of "C:\Program Files (x86)\Microsoft Visual Studio 11.0\VC\include\memory") is inaccessible c:\SkyDrive\democpp\Tester\Tester.cpp 379 14 Tester
Error 3 error C2248: 'std::unique_ptr<_Ty>::unique_ptr' : cannot access private member declared in class 'std::unique_ptr<_Ty>' c:\skydrive\democpp\tester\tester.cpp 382 1 Tester

posted by SteveRichter

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634927338347774433 Wed, 02 Jan 2013 14:30:34 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634927338347774433 SteveRichter Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank]
You can say this is a bug/undefined behavior (in the context of concurrent/parallel code) but this is an issue with the language/library if the standard say that constant member functions must be side-effect free but the language does not enforce this thus the compiler will never enforce this.

From my point of view const does not guarantee thread safety, this is only a promise that can be silently broken. This is not particular useful.

This change in C++11 is actually a breaking but silent change to existing code and you have no help from the language/compiler to find and fix any buggy code which is not C++11 compliant.

posted by snkkid

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634927366037561280 Wed, 02 Jan 2013 15:16:43 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634927366037561280 snkkid Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank] @SteveRichter: Clang gives a more readable diagnostic message:

source.cpp:6:79: error: call to deleted constructor of 'std::unique_ptr<std::wstring>'
void CallTester2( ) { std::unique_ptr<std::wstring> pString ; Tester2( pString ) ; }
                                                                     ^~~~~~~
note: function has been explicitly marked deleted here unique_ptr(const unique_ptr&) = delete;

See: http://liveworkspace.org/code/1zPqd0$1

In other words, copy constructor is deleted -- in other words, unique_ptr is non-copyable.

BTW, regarding enums, you can always implement something like this: http://www.ishani.org/web/2012/fancy-c-enums/

posted by Matt_PD

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634927377961465716 Wed, 02 Jan 2013 15:36:36 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634927377961465716 Matt_PD Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank] posted by Gary

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634927678718055343 Wed, 02 Jan 2013 23:57:51 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634927678718055343 Gary Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank]

@PhrostByte it is very easy to invalidate this, constant member functions do not enforce referentially transparency (pure functions) even in C++11. You can still modify global or (class) static unsynchronized variables in constant member functions or modify unsynchronized data members marked as mutable.

You can say this is a bug/undefined behavior (in the context of concurrent/parallel code) but this is an issue with the language/library if the standard say that constant member functions must be side-effect free but the language does not enforce this thus the compiler will never enforce this.

From my point of view const does not guarantee thread safety, this is only a promise that can be silently broken. This is not particular useful.

This change in C++11 is actually a breaking but silent change to existing code and you have no help from the language/compiler to find and fix any buggy code which is not C++11 compliant.

In other words, it's no different from most everything else in C++ -- helping you a good deal but still not "enforcing" anything, allowing you to do whatever the hell you want in the end Smiley

A compiler may not be able to catch and warn about all instances of broken code (you're right, this is a breaking change), but there's a lot of room here for it to help.

posted by PhrostByte

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634929477528854865 Sat, 05 Jan 2013 01:55:52 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634929477528854865 PhrostByte Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank] Thanks!

posted by DmitriyVilkov

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634930727398240121 Sun, 06 Jan 2013 12:38:59 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634930727398240121 DmitriyVilkov Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank] posted by Anonymous Coward

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634931941706958399 Mon, 07 Jan 2013 22:22:50 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634931941706958399 Anonymous Coward Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank] @Anonymous Coward: Watch and actually listen to what Herb says...
C

posted by Charles

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634932935481020171 Wed, 09 Jan 2013 01:59:08 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634932935481020171 Charles Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank]
I would think that saying that both mutable and const *imply* thread safe is better than stating they equal thread safe. After all, const also implies "not allowed to perform non-const operations on" while mutable implies the opposite, so mutable != const. But that's just a nitpicking comment ;). The presentation is very insightful.

posted by Andre Offringa

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634933144317292737 Wed, 09 Jan 2013 07:47:11 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634933144317292737 Andre Offringa Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank]
I have a question though. This mutable mutex story seems kind ow awkward to me.

You said that "const" now means "thread-safe", and that "mutable" means "known to be thread-safe". If the mutex is thread-safe, as you said in your talk, shouldn't all its methods be declared const ? Therefore, the mutex would not have to be declared mutable.

posted by kip

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634938849867156795 Tue, 15 Jan 2013 22:16:26 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634938849867156795 kip Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank]
And, in most cases, the compiler will not let you directly break your promise of immutable/non-modify. For that you have to explicitly cast the const thing to a non-const thing. OR you can say that thing is in fact mutable.

Now when you say something is mutable you're saying "Look, this is not immutable but I guarantee that it will not cause problems with concurrency/synchronization, it's already synchronized"

Const -> it's immutable, and as such thread-safe.
Mutable -> it's mutable, but let me use as immutable because I guarantee it's thread-safe.

posted by Alessandro Stamatto

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634940475986159612 Thu, 17 Jan 2013 19:26:38 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634940475986159612 Alessandro Stamatto Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank]
for me the point in this 'const/mutable' talk is, that you missed in your introducion a 'const':

#include <utility>
#include <future>
#include <vector>
using namespace std;
/**/const/**/ vector<int> v(1000); // <--
int main() {
auto x = async([/**/&/**/]{ pair<int,vector<int>> z{ 1, v }; });
auto y = async([/**/&/**/]{ pair<int,vector<int>> z{ 2, v }; });
x.wait(); y.wait();
}

without this /**/const/**/, you have to 'know' that nobody modifies 'v'.

am i right?

best regards
andreas pfaffenbichler

posted by Andreas Pfaffenbichler

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634940925778643990 Fri, 18 Jan 2013 07:56:17 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634940925778643990 Andreas Pfaffenbichler Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank]
Thanks for your answer, Alessandro. However, I can't say I fully agree, though I understand your point.

The conclusion of what you said is "Const -> it's immutable, and as such thread-safe."
This is precisely what puzzles me. Since a mutex is inherently thread-safe (thanks to some *internal* mechanism), why doesn't it expose its constness to the outside world ?
I think that the stl standard breaks the encapsulation rule here.
Basically, when you say that the lock method of a mutex is non-const, you're saying:
"OK, by some internal mechanism, I have to modify some private variables of the mutex, in order to make it thread-safe, therefore it is non-const". Basically, you're exposing the internal working of the mutex by saying its lock method is non const, though it's thread safe.

I hope I am clear in my explanation. Feel free to send me an email to further discuss this point (first-name dot last-name at gmail.com)

posted by Kip Coul

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634941864405703322 Sat, 19 Jan 2013 10:00:40 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634941864405703322 Kip Coul Re: C++ and Beyond 2012: Herb Sutter - You don't know [blank] and [blank]
I think the point is that const is not the same as thread safe. const implies thread safe, but thread safe does not imply const.

The mutex is not const, and in fact that is what allows it to synchronize, if the mutex is not locked you need to lock it to synchronize, but you can't change the state of the mutex if it is const (despite of what Herb might have said, const still means immutable).

That's where mutable comes in, because mutable (just like const) implies thread safe. But while const implies it since something that can't change by definition is thread safe, mutable is thread safe since you do you some form of synchronization.

I think the key to understanding is the fact that thread safe != const, you can use other means of synchronization (for example a mutex). And if your class is not const then the mutex is not const either, so if the mutex's functions are non-const that's OK.

posted by Erik W

]]> http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634966617291406542 Sun, 17 Feb 2013 01:35:29 GMT http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank#c634966617291406542 Erik W