October 25, Pavia, Italy
November 6-8, Berlin, Germany
November 3-8, Kona, HI, USA
By Blog Staff | Nov 12, 2013 02:13 PM | Tags: intermediate
A nice nugget about a handy make_weak one-liner:
Automatically Made Weak
by Brett Hall
From the article:
I’ve been experimenting with the new “auto everything” style in C++. I also make regular use of
std::weak_ptr... [and wouldn't it be nice if] we can just typeauto weak = make_weak(shared);
By Blog Staff | Nov 12, 2013 10:06 AM | Tags: None
Coming next week on Microsoft Virtual Academy:
C++: A General Purpose Language and Library
by Kate Gregory and James McNellis
Live on November 19, 2013, 9:00am-5:00pm PST (other time zones), later on demand
Cost: Free
With these speakers, we expect a high quality talk. If you're new to C++, or know someone who is and would like to learn about the language, watch and recommend this talk. This event uses the Microsoft Visual Studio environment, but the content is applicable to new C++ developers using any compiler and platform.
From the announcement:
Attention developers: here’s a painless way to learn the basics of C++ from the ground up, whether you’re updating legacy code or writing brand new, efficient, and high-performance code for new platforms like phones and want to take advantage of C++. You’ll learn the fundamentals of the C++ language, how to use the language and its Standard Library effectively, and how to use the Visual Studio environment for developing C++, including debugging, exploring code, and understanding error messages. This is your starting point for building software in C++.
COURSE OUTLINE
- Introduction to Programming Concepts
- Getting Started
- The C++ Object Model
- Pointers and Indirection
- RAII – Resource Acquisition is Initialization
- The C++ Standard Library (STL)
INSTRUCTOR TEAM
Kate Gregory | Partner, Gregory Consulting Limited | @gregcons
Kate Gregory is a C++ expert who has been using C++ since before Microsoft had a C++ compiler, an early adopter of many software technologies and tools, and a well-connected member of the software development community. She has over three decades of scientific and engineering programming experience in a variety of programming languages. Since January 2002 she has been Microsoft Regional Director for Toronto and since January 2004 she has been awarded the Microsoft Most Valuable Professional designation for Visual C++. In June 2005 she won the Regional Director of the year award, and she was one of the C++ MVPs of the year for 2010.
Kate is the author of over a dozen books, mostly on C++ programming; the latest, on massively parallel programming with C++ AMP, was published in fall 2012 by Microsoft Press. Her firm, Gregory Consulting Limited, is based in rural Ontario and helps clients adopt new technologies and adjust to the changing business environment. Managing, mentoring, technical writing, and technical speaking occupy much of her time, but she still writes code every week.James McNellis | Microsoft Senior Software Development Engineer | @JamesMcNellis
James McNellis is a computer programmer and C++ maven. A senior engineer on the Microsoft Visual C++ team, James builds modern C++ libraries and is the maintainer of the Visual C++, C Runtime (CRT), and C Standard Library implementation. He was previously a member of the Microsoft Expression Blend team, developing the XAML designer tools for Windows 8 apps. Prior to joining Microsoft in 2010, he spent several years working on real-time 3-D simulation and robotics projects in the defense industry. James is a prolific contributor on the Stack Overflow programming Q&A website and writes for the Visual C++ Team Blog.
By Blog Staff | Nov 11, 2013 01:26 PM | Tags: intermediate
Quick A: Yes. That's kind of the point, actually.
This weekend on StackOverflow:
Return value optimizations and side-effects
Return value optimization (RVO) is an optimization technique involving copy elision, which eliminates the temporary object created to hold a function's return value in certain situations. I understand the benefit of RVO in general, but I have a couple of questions.
The standard says the following about it in §12.8, paragraph 32 of this working draft (emphasis mine).
When certain criteria are met, an implementation is allowed to omit the copy/move construction of a class object, even if the copy/move constructor and/or destructor for the object have side effects. In such cases, the implementation treats the source and target of the omitted copy/move operation as simply two different ways of referring to the same object, and the destruction of that object occurs at the later of the times when the two objects would have been destroyed without the optimization.
It then lists a number of criteria when the implementation may perform this optimization.
I have a couple of questions regarding this potential optimization:
- I am used to optimizations being constrained such that they cannot change observable behaviour. This restriction does not seem to apply to RVO. Do I ever need to worry about the side effects mentioned in the standard? Do corner cases exist where this might cause trouble?
- What do I as a programmer need to do (or not do) to allow this optimization to be performed? For example, does the following prohibit the use of copy elision (due to the move):
std::vector<double> foo(int bar){ std::vector<double> quux(bar,0); return std::move(quux); }
By marshall | Nov 11, 2013 01:01 PM | Tags: None
Release 1.55.0 of the Boost C++ Libraries is now available:
Boost Version 1.55.0
These open-source libraries work well with the C++ Standard Library, and are usable across a broad spectrum of applications. The Boost license encourages both commercial and non-commercial use.
This release contains one new library and numerous enhancements and bug fixes for existing libraries.
New libraries:
By Blog Staff | Nov 11, 2013 10:39 AM | Tags: intermediate
Quick A: No. But you can and often should overload func(X&) with func(X&&) (with const on the parameter if appropriate in either or both).
Here is the salient part of the SO question -- ignore the question's original title, because it's perfectly fine to overload pass-by-reference and pass-by-rvalue-reference where the former can be implemented using the normal copy-and-swap idiom:
Move assignment incompatible with standard copy and swap
[...] Here the assignment to a should use the "Move Assignment" operator. But there is a clash with the "Standard Assignment" operator (which is written as your standard copy and swap).
> g++ --version Configured with: --prefix=/Applications/Xcode.app/Contents/Developer/usr --with-gxx-include-dir=/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.9.sdk/usr/include/c++/4.2.1 Apple LLVM version 5.0 (clang-500.2.79) (based on LLVM 3.3svn) Target: x86_64-apple-darwin13.0.0 Thread model: posix > g++ -std=c++11 String.cpp String.cpp:64:9: error: use of overloaded operator '=' is ambiguous (with operand types 'String' and 'String') a = String("Test Move Assignment"); ~ ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ String.cpp:32:17: note: candidate function String& operator=(String rhs) ^ String.cpp:54:17: note: candidate function String& operator=(String&& rhs) ^
By Blog Staff | Nov 8, 2013 07:50 AM | Tags: None
Trust Eric Niebler to deliver the goods -- when it comes to insightful discussion, cool code, and shameless puns:
Input Iterators vs. Input Ranges
by Eric Niebler
From the article:
The solution to
istream_iterator's woes will be to replace it withistream_range. Put simply, if we’re reading strings from a stream, the string needs to live somewhere. The iterator seemed like the logical place when we were all thinking strictly in terms of iterators. But with ranges, we now have a much better place to put it: in the range object.
By Blog Staff | Nov 8, 2013 12:47 AM | Tags: basics
Do you know a beginner who'd like to learn C++? Or even just learn how to program... using C++?
Recently, C++ author and trainer Kate Gregory made a new 7-hour course available via Pluralsight. And not just any introductory course, but teaching C++ the way it should be taught... not "C and pointers first."
It's highly-rated, as with all of Kate's courses. Know about it and recommend it to newcomers.
Learn How to Program with C++
Instructor: Kate Gregory
If you've never programmed before, and you think you'd like to learn C++, why not learn it first? This course covers what you need to start writing real applications in C++.
By Blog Staff | Nov 7, 2013 02:34 PM | Tags: None
A few hours ago, Clang completed checkin 194194 to be feature-complete for draft C++14 including both language extensions and standard library features. (Note: The library conformance requires using libc++, instead of libstdc++ which is supported on more platforms but is not as conforming.) Congratulations to the Clang team for this achievement!
With this progress, it appears that the next release of Clang and LLVM, expected in December or January, will be draft C++14 feature-complete. C++14 itself may still undergo final changes at the February 2014 ISO C++ meeting, which is expected to be the final meeting for technical tweaks to the contents of C++14.
By Blog Staff | Nov 7, 2013 12:20 PM | Tags: basics
Recently on SO:
Why does C++ not allow multiple types in one auto statement?
The 2011 C++ standard introduced the new keyword
auto, which can be used for defining variables instead of a type, i.e.auto p=make_pair(1,2.5); // pair<int,double> auto i=std::begin(c), end=std::end(c); // decltype(std::begin(c))In the second line,
iandendare of the same type, referred to asauto. The standard does not allowauto i=std::begin(container), e=std::end(container), x=*i;when
xwould be of different type. My question: why does the standard not allow this last line? ...
By Blog Staff | Nov 7, 2013 11:16 AM | Tags: performance intermediate efficiency boost
A nice short overview of when you might want your associative container to use a contiguous implementation instead of a tree under the covers:
Ode to a Flat Set
by Jon Kalb
From the article:
The Boost Container library has a family of
flat_*containers that have associative container interfaces and semantics, but are implemented as sorted vectors.In addition to faster lookup, the
flat_*containers have much faster iteration, less memory overhead, fewer allocations, and improved cache performance.However, as with all things, there are trade-offs.