By Meeting C++ | Feb 5, 2015 03:41 AM | Tags: sql meeting c++ intermediate database c++11
A new video from Meeting C++ 2014:
Sqlpp11, An EDSL For Type-Safe SQL In C++
by Roland Bock
From the talk description:
Most C/C++ interfaces to SQL databases are string based. Theses strings effectively hide expression structures, names and types from the compiler. And they are vendor-specific. And they defer expression parsing and validation until the test phase or (even worse) production...
By Adrien Hamelin | Feb 4, 2015 02:12 PM | Tags: intermediate c++11
Quick A: To enabling moving out of *iterator.
Recently on SO:
What is move_iterator for?
If I understand it correct,
a=std::move(b)binds reference a to the address of b. And after this operation the content that b points to is not guaranteed.The implementation of
move_iteratorhere has this lineauto operator[](difference_type n) const -> decltype(std::move(current[n])) { return std::move(current[n]); }However, I don't think it makes sense to
std::movean element in an array. What happens ifa=std::move(b[n])?The following example confuses me also:
std::string concat = std::accumulate( std::move_iterator<iter_t>(source.begin()), std::move_iterator<iter_t>(source.end()), std::string("1234"));Since the concat will itself allocate a continuous chunk of memory to store the result, which will not have any overlap with source. The data in source will be copied to concat but not moved.
By Adrien Hamelin | Feb 4, 2015 02:08 PM | Tags: performance intermediate
Everything is in the title:
What Every Programmer Should Know About Compiler Optimizations
by Hadi Brais
From the article:
High-level programming languages offer many abstract programming constructs such as functions, conditional statements and loops that make us amazingly productive. However, one disadvantage of writing code in a high-level programming language is the potentially significant decrease in performance. Ideally, you should write understandable, maintainable code—without compromising performance. For this reason, compilers attempt to automatically optimize the code to improve its performance, and they’ve become quite sophisticated in doing so nowadays. They can transform loops, conditional statements, and recursive functions; eliminate whole blocks of code; and take advantage of the target instruction set architecture (ISA) to make the code fast and compact. It’s much better to focus on writing understandable code, than making manual optimizations that result in cryptic, hard-to-maintain code. In fact, manually optimizing the code might prevent the compiler from performing additional or more efficient optimizations...
By Adrien Hamelin | Feb 4, 2015 02:03 PM | Tags: c++11 advanced
Did you you know that...
Expressions can have Reference Type
by Scott Meyers
From the article:
Today I got email about some information in Effective Modern C++. The email included the statement, "An expression never has reference type." This is easily shown to be incorrect, but people assert it to me often enough that I'm writing this blog entry so that I can refer people to it in the future...
By Adrien Hamelin | Feb 4, 2015 02:00 PM | Tags: intermediate efficiency c++11
The CoderGears Team teaches us how to use clang-modernize:
Modernize your C++ code
by the CoderGears Team
From the article:
C++11 includes several additions to the core language and extends the C++ standard library. Some of these new features are very easy to use and bring a big added value to your C++ projects...
By Adrien Hamelin | Feb 4, 2015 01:57 PM | Tags: c++14 advanced
Sasha Goldshtein shares with us his thoughts about the printf function:
Compile-Time and Runtime-Safe Replacement for “printf”
by Sasha Goldshtein
From the article:
C++ 11 is truly beautiful. And one of the ways in which it is beautiful is how you can implement a compile-time and runtime-safe version of the popular C runtime function printf...
By Adrien Hamelin | Feb 4, 2015 01:53 PM | Tags: c++11 advanced
A new post on iterators:
Iterators++, Part 1
by Eric Niebler
From the article:
In the last post, I described the so-called proxy iterator problem: the fact that iterators that return proxy references instead of real references don’t sit comfortably within the STL’s framework. Real, interesting, and useful iterators fall foul of this line, iterators like vector<bool>‘s or like the iterator of the zip view I presented. In this post, I investigate what we could do to bring proxy iterators into the fold — what it means for both the iterator concepts and for the algorithms. Since I’m a library guy, I restrict myself to talking about pure library changes...
By Andrey Karpov | Feb 4, 2015 10:07 AM | Tags: basics
The article explains why one must never use the (this == 0) expression. It's a very bad code. It being able to work at times doesn't mean anything. By writing (this == 0), you let undefined behavior into your program.
Still Comparing "this" Pointer to Null?
by Dmitry Meshcheryakov
From the article:
In the same way the compiler can optimize the code comparing "this" pointer to null. According to the Standard, this cannot be null and therefore the checks and the corresponding code branches can be eliminated, which will greatly affect the code dependent on the comparison of "this" pointer to null. The compiler has a full right to "break" (actually just break it further) the code CWindow::GetSafeHandle() and generate machine code which doesn't contain the comparison and only reads the class field all the time.
...
GOOD LORD, the "this" pointer equals 0x00000004 on entering the method when compiled in Visual C++ 9, as the pointer initially set to null is adjusted so that it points to the beginning of a subobject of the corresponding class.
By Adrien Hamelin | Feb 4, 2015 08:00 AM | Tags: intermediate c++14 c++11
While we wait for CppCon 2015 in September, we’re featuring videos of some of the 100+ talks from CppCon 2014. Here is today’s feature:
Back to the Basics! Essentials of Modern C++ Style
by Herb Sutter
Summary of the talk:
This talk revisits basic questions, such as how to declare and initialize a variable, how to pass a value to a function, how to write a simple loop, and how to use smart pointers, in the light of experience with C++11 and the latest C++14 refinements. This involves examining auto, rvalue references, range-for loops, uniform initialization, lambda expressions, unique_ptr and shared_ptr, and more.
By Jordi Mon Companys | Feb 3, 2015 07:48 AM | Tags: stl monads continuation-ready algorithms
Monads in use, finally!!
Snail | Continuation-ready algorithms from STL algorithms
by Manu Sánchez
From the article:
Snail is my try to get a continuation-ready set of algorithms to operate on C++ containers, but instead of reinventing all the algorithms, addapting them through a continuation monad (or something resembling a continuation monad).