Home » Blog » Categories » Articles & Books

Articles & Books

GotW #6a Solution: Const-Correctness, Part 1 -- Herb Sutter

By Blog Staff | May 24, 2013 03:48 PM | Tags: None

The solution to GotW #6a is now available:

GotW #6a Solution: Const-Correctness, Part 1 (updated for C ++11/14)

by Herb Sutter

From the article:

Starting with C++11, const on a variable that is possibly shared means read-only, safe to read concurrently without external synchronization.

If you perform any operation on a const shared variable x, or call a const member function on x, you can assume that operation does not change the observable value of x -- or even modify the bits of x in an observable way even in the presence of concurrency. ...

Guideline: Remember the “M&M rule”: For a member variable, mutable and mutex (or atomic) go together. ...

Quick Q: Why pass by value then move? -- StackOverflow

By Blog Staff | May 23, 2013 03:17 PM | Tags: None

Quick A: Because it's a new C++11 parameter passing pattern, also recently mentioned as part of GotW #4.

Why do we copy then move?

I saw code somewhere in which someone decided to copy an object and subsequently move it to a data member of a class. This left me in confusion in that I thought the whole point of moving was to avoid copying. Here is the example:

 

struct S
{
    S(std::string str) : data(std::move(str))
    {}
};

Here are my questions:

  • Why aren't we taking an rvalue-reference to str?
  • Won't a copy be expensive, especially given something like std::string?
  • What would be the reason for the author to decide to make a copy then a move?
  • When should I do this myself?

Lambdas vs. Closures -- Scott Meyers

By Blog Staff | May 22, 2013 08:34 PM | Tags: basics

This bears repeating:

Lambdas vs. Closures

by Scott Meyers

From the article:

In recent days, I've twice found myself explaining the difference between lambdas and closures in C++11, so I figured it was time to write it up. ...

GotW #5 Solution: Overriding Virtual Functions -- Herb Sutter

By Blog Staff | May 22, 2013 05:29 PM | Tags: None

The solution to GotW #5 is now available:

GotW #5 Solution: Overriding Virtual Functions (updated for C ++11/14)

by Herb Sutter

From the article:

Exactly one of the following can be true for a polymorphic type:

  • Either destruction via a pointer to base is allowed, in which case the function has to be public and had better be virtual;
  • or else it isn’t, in which case the function has to be protected (private is not allowed because the derived destructor must be able to invoke the base destructor) and would naturally also be nonvirtual (when the derived destructor invokes the base destructor, it does so nonvirtually whether declared virtual or not).

C++Now 2013 Trip Report -- Jens Weller

By Blog Staff | May 20, 2013 01:54 PM | Tags: None

Reporting from the just-concluded C++Now 2013 event:

C++ Now 2013 -- Trip Report

by Jens Weller

From the article:

This years sessions focused a lot on threading, which brought great talks about atomics, transactional memory or C++11 threading to the conference. I have to admit, that threading is not my main interest in C++, so not all of those talks were meant for me. But having three tracks always gives you a great choice. And also gave me the confidence that the decision to go for 3 tracks at this years Meeting C++ conference was right.

GotW #4 Solution: Class Mechanics -- Herb Sutter

By Blog Staff | May 20, 2013 12:45 PM | Tags: intermediate basics

The solution to GotW #4 is now available:

GotW #4 Solution: Class Mechanics (updated for C++11/14)

by Herb Sutter

From the article:

... To see why, consider the following canonical forms for how operator+= and operator+ should normally be implemented for some type T. 
T& T::operator+=( const T& other ) {
    //...
    return *this;
}

 

T operator+( T a, const T& b ) {
    a += b;
    return a;
}

Did you notice that one parameter is passed by value, and one by reference? That’s because if you’re going to copy from a parameter anyway, it’s often better to pass it by value, which will naturally enable a move operation if the caller passes a temporary object such as in expressions like (val1 * val2) + val3. We’ll see more on parameter passing in a future GotW. ...

.

GotW #3 Solution: Using the Standard Library (or, Temporaries Revisited) -- Herb Sutter

By Blog Staff | May 16, 2013 01:11 PM | Tags: intermediate basics

The solution to GotW #3 is now available:

GotW #3 Solution: Using the Standard Library (or, Temporaries Revisited) (updated for C++11/14)

by Herb Sutter

From the article:

With no other changes, simply using the standard find algorithm could do everything the range-based for loop did to avoid needless temporaries (and questions about them) [...] and it further increases our level of abstraction.

C++14 Committee Draft (CD) Published at isocpp.org -- Michael Wong

By MichaelWong | May 16, 2013 11:21 AM | Tags: None

[Ed.: Thanks to Michael Wong for sharing his commentary and perspective on the C++14 CD while on the scene at the C++Now conference. Posted at the IBM C/C++ Cafe blog.]

C++14 Committee Draft (CD) published at isocpp.org

C++14 Committee Draft is here and can be accessed at isocpp.org. This is in keeping with the practice of greater transparency ... [and] was also announced to the C++NOW crowd by Jens Weller at the Community evening session last night.