Home » Blog » Tags » intermediate

intermediate

Parameter Types in Constructors -- Scott Meyers

By Blog Staff | Oct 12, 2012 12:23 PM | Tags: intermediate advanced

From the keyboard of Scott Meyers:

Parameter Types in Constructors

by Scott Meyers

I recently went through Sumant Tambe's presentation materials from his Silicon Valley Code Camp presentation, "C++11 Idioms."  He argues that an emerging idiom is to pass arguments to constructors by value, because this takes advantage of move opportunities when they are available.

I was surprised to read about this emerging idiom, in part because I had not heard of it (I'm supposed to be clued in about this kind of stuff) and in part because it runs contrary to my own thinking on the subject, which is to use perfect forwarding...

Universal References in C++11 -- Scott Meyers

By Blog Staff | Oct 9, 2012 11:32 AM | Tags: intermediate advanced

Recorded live at C++ and Beyond 2012:

Universal References in C++11

Scott Meyers

Given that rvalue references are declared using "&&", it seems reasonable to assume that the presence of "&&" in a type declaration indicates an rvalue reference. That is not the case...

In this article, I describe the two meanings of "&&" in type declarations, explain how to tell them apart, and introduce new terminology that makes it possible to unambiguously communicate which meaning of "&&" is intended. Distinguishing the different meanings is important, because if you think "rvalue reference" whenever you see "&&" in a type declaration, you'll misread a lot of C++11 code...

Padding and Rearranging Structure Members -- Dan Saks

By Blog Staff | Sep 20, 2012 02:17 PM | Tags: intermediate

Hot of the press at Dr. Dobb's:

Padding and Rearranging Structure Members

By Dan Saks

... Multibyte objects often have an alignment ... a "requirement that objects of a particular type be located on storage boundaries with addresses that are particular multiples of a byte address". The Standard leaves it up to each target processor to specify its alignment requirements. That is, a processor might require that a 4-byte integer or pointer referenced as a single object be word aligned — at an address that's a multiple of four. A processor also might require that an 8-byte floating-point number be word aligned, or maybe even double-word aligned — at an address that's a multiple of eight.

According to the C Standard, a program that attempts to access an improperly aligned object produces undefined behavior. This means that the program is in error, but the exact consequences of that error are platform-dependent. With many processors, an instruction that attempts to access improperly aligned data issues a trap. With other processors, an instruction that accesses misaligned data executes properly but uses up more cycles to fetch the data than if the data were properly aligned...

[more]

"Panel: Static If, C++11, Modern Libraries, and Metaprogramming" -- Alexandrescu, Meyers, Sutter

By Blog Staff | Aug 21, 2012 07:50 AM | Tags: intermediate experimental advanced

The first panel from C++ and Beyond 2012 is now available on Channel 9:

On Static If, C++11 in 2012, Modern Libraries, and Metaprogramming

Andrei Alexandrescu, Scott Meyers, Herb Sutter

Channel 9 was invited to this year's C++ and Beyond to film some sessions (that will appear on C9 over the coming months!)...

At the end of day 2, Andrei, Herb and Scott graciously agreed to spend some time discussing various modern C++ topics and, even better, answering questions from the community. In fact, the questions from Niners (and a conversation on reddit/r/cpp) drove the conversation.

Here's what happened...

[more]

Destructors That Throw: Evil, or Just Misunderstood? -- Jon Kalb and Dave Abrahams

By Blog Staff | Aug 17, 2012 09:01 AM | Tags: intermediate advanced

Interesting new C++Next article about destructors that throw:

Evil, or Just Misunderstood?

by Jon Kalb and Dave Abrahams

From the script-style intro:

UDT (putting down drink and looking deep into CODER’s eyes): By the way, in my destructor I throw if the file fails to close properly.

CODER: I can live with that. [...] I’ve always been a sucker for dangerous types.

FADE TO BLACK

NARRATOR (V.O.): We invite you to journey with us now, into the heart of darkness, where we seek out throwing destructors and stare Evil™ in the face. Will CODER survive his encounter with exceptional destruction? The answers lie beyond the frontiers of usual best practice…

Continue reading...

Core C++, 3 of N: Overload Resolution -- Stephan T. Lavavej

By Blog Staff | Jul 24, 2012 07:36 PM | Tags: intermediate advanced

Core C++, 3 of N: Overload Resolution -- Stephan T. Lavavej

Stephan T. Lavavej, aka STL, will take us on a journey of discovery within the exciting world of Core C++. We know lots of folks are either coming back to C++, coming to C++, or have never left C++. This lecture series, in n parts, is for all of you! Only STL can make that work (novice, intermediate, and advanced all bundled together and presented in a way only STL can do).

In Part 3, STL digs into Overload Resolution. A function template can overload non-template functions of the same name. In this scenario, function calls are resolved by first using template argument deduction to instantiate the function template with a unique specialization (STL taught us all about TAD in Part 2). If template argument deduction fails, the other function overloads are considered to resolve the call. These other overloads, also known as the candidate set, include nontemplate functions and other instantiated function templates. If template argument deduction succeeds, then the generated function is compared with the other functions to determine the best match, following the rules for overload resolution. [source]

As STL says: "I walk through why foo(const T&) beats foo(const T *), when given int *. The reason is surprisingly subtle."

Tune in.

Core C++, 1 of N: Name Lookup -- Stephan T. Lavavej

By Blog Staff | May 16, 2012 07:30 PM | Tags: intermediate advanced

Core C++, 1 of N: Name Lookup -- Stephan T. Lavavej

Stephan T. Lavavej, aka STL, will take us on a journey of discovery within the exciting world of Core C++. We know lots of folks are either coming back to C++, coming to C++, or have never left C++. This lecture series, in n parts, is for all of you! Only STL can make that work (novice, intermediate, and advanced all bundled together and presented in a way only STL can do).

In the following code, which functions are called? Why? Analyze the implications?

 

namespace A {
      struct X;
      struct Y;
      void f( int );
      void g( X );
}

namespace B {
       void f( int i ) {
            f( i );   // which f()?
        }
        void g( A::X x ) {
             g( x );   // which g()?
        }
        void h( A::Y y ) {
             h( y );   // which h()?
        }
}


We recommend you watch this entire episode before playing around with Herb's sample above (and don't read the GotW answer, either! That's cheating. Learn from STL. He's an outstanding teacher, as you know).

Tune in. Enjoy. Learn.