October 25, Pavia, Italy
November 6-8, Berlin, Germany
November 3-8, Kona, HI, USA
By Jordi Mon Companys | Dec 10, 2014 08:29 AM | Tags: None
In case you missed it, this may be midly controversial but we felt it could be of interest:
Property Testing in C++
by Jeremy Wright
From the article:
One might say tests are shiny. I don't know if they are really shiny as much as I found another cool use for uniform_int_distribution<>...
By miltonm | Dec 10, 2014 08:19 AM | Tags: None
In case you missed it, now you can develop web apps in C++ to run natively on Google Chrome. This tutorial shows how to develop a Native Client module in C++ and build and run it using PNaCl toolchain:
C++ Tutorial: Getting Started (Part 1)
This tutorial shows how to build and run a web application using Portable Native Client (PNaCl). This is a client-side application that uses HTML, JavaScript and a Native Client module written in C++. The PNaCl toolchain is used to enable running the Native Client module directly from a web page...
Portable Native Client or PNacl, which is supported on Google Chrome at the moment, lets you compile and run native code developed in C or C++ within a secure sandbox in browser. PNaCl uses the LLVM toolchain to generate OS-independent and architecture agnostic intermediate bytecode which is later loaded, translated and executed by the browser. To get more information on PNaCl and it's less portable companion NaCl check the native client developer documentation.
By ltorje | Dec 10, 2014 01:53 AM | Tags: None
In case you missed it, from Nicolás Brailovsky's blog -- an interesting post after you get past a little ranting:
C++ Template Metaprogramming Introduction
by Nicolás Brailovsky
From the article:
First, we need to start with a little clarification: using
template <class T>to parametrize a class, something likestd::vectordoes, is not template metaprogramming. That’s just a generic class (Java-pun intended). That is indeed a useful case for templates, but it has little fun in it.Template metaprogramming is much more fun than mere generic classes...
A few notes:
By Bjarne Stroustrup | Dec 9, 2014 03:55 AM | Tags: None
[For your winter reading pleasure, we're pleased to present this three-part series of new material by Bjarne Stroustrup. This is part one; parts two and three will be posted on the following two Mondays, which will complete the series just in time for Christmas. Enjoy. -- Ed.]
by Bjarne Stroustrup
Morgan Stanley, Columbia University, Texas A&M University
In this three-part series, I will explore, and debunk, five popular myths about C++:
If you believe in any of these myths, or have colleagues who perpetuate them, this short article is for you. Several of these myths have been true for someone, for some task, at some time. However, with today’s C++, using widely available up-to date ISO C++ 2011 compilers, and tools, they are mere myths.
I deem these myths “popular” because I hear them often. Occasionally, they are supported by reasons, but more often they are simply stated as obvious, needing no support. Sometimes, they are used to dismiss C++ from consideration for some use.
Each myth requires a long paper or even a book to completely debunk, but my aim here is simply to raise the issues and to briefly state my reasons.
No. Learning basic programming using C++ is far easier than with C.
C is almost a subset of C++, but it is not the best subset to learn first because C lacks the notational support, the type safety, and the easier-to-use standard library offered by C++ to simplify simple tasks. Consider a trivial function to compose an email address:
string compose(const string& name, const string& domain)
{
return name+'@'+domain;
}
It can be used like this
string addr = compose("gre","research.att.com");
The C version requires explicit manipulation of characters and explicit memory management:
char* compose(const char* name, const char* domain)
{
char* res = malloc(strlen(name)+strlen(domain)+2); // space for strings, '@', and 0
char* p = strcpy(res,name);
p += strlen(name);
*p = '@';
strcpy(p+1,domain);
return res;
}
It can be used like this
char* addr = compose("gre","research.att.com");
// …
free(addr); // release memory when done
Which version would you rather teach? Which version is easier to use? Did I really get the C version right? Are you sure? Why?
Finally, which version is likely to be the most efficient? Yes, the C++ version, because it does not have to count the argument characters and does not use the free store (dynamic memory) for short argument strings.
This is not an odd isolated example. I consider it typical. So why do so many teachers insist on the “C first” approach?
However, C is not the easiest or most useful subset of C++ to learn first. Furthermore, once you know a reasonable amount of C++, the C subset is easily learned. Learning C before C++ implies suffering errors that are easily avoided in C++ and learning techniques for mitigating them.
For a modern approach to teaching C++, see my Programming: Principles and Practice Using C++ [13]. It even has a chapter at the end showing how to use C. It has been used, reasonably successfully, with tens of thousands of beginning students in several universities. Its second edition uses C++11 and C++14 facilities to ease learning.
With C++11 [11-12], C++ has become more approachable for novices. For example, here is standard-library vector initialized with a sequence of elements:
vector<int> v = {1,2,3,5,8,13};
In C++98, we could only initialize arrays with lists. In C++11, we can define a constructor to accept a {} initializer list for any type for which we want one.
We could traverse that vector with a range-for loop:
for(int x : v) test(x);
This will call test() once for each element of v.
A range-for loop can traverse any sequence, so we could have simplified that example by using the initializer list directly:
for (int x : {1,2,3,5,8,13}) test(x);
One of the aims of C++11 was to make simple things simple. Naturally, this is done without adding performance penalties.
No. C++ supports OOP and other programming styles, but is deliberately not limited to any narrow view of “Object Oriented.” It supports a synthesis of programming techniques including object-oriented and generic programming. More often than not, the best solution to a problem involves more than one style (“paradigm”). By “best,” I mean shortest, most comprehensible, most efficient, most maintainable, etc.
The “C++ is an OOPL” myth leads people to consider C++ unnecessary (when compared to C) unless you need large class hierarchies with many virtual (run-time polymorphic) functions – and for many people and for many problems, such use is inappropriate. Believing this myth leads others to condemn C++ for not being purely OO; after all, if you equate “good” and “object-oriented,” C++ obviously contains much that is not OO and must therefore be deemed “not good.” In either case, this myth provides a good excuse for not learning C++.
Consider an example:
void rotate_and_draw(vector<Shape*>& vs, int r)
{
for_each(vs.begin(),vs.end(), [](Shape* p) { p->rotate(r); }); // rotate all elements of vs
for (Shape* p : vs) p->draw(); // draw all elements of vs
}
Is this object-oriented? Of course it is; it relies critically on a class hierarchy with virtual functions. It is generic? Of course it is; it relies critically on a parameterized container (vector) and the generic function for_each. Is this functional? Sort of; it uses a lambda (the [] construct). So what is it? It is modern C++: C++11.
I used both the range-for loop and the standard-library algorithm for_each just to show off features. In real code, I would have use only one loop, which I could have written either way.
Would you like this code more generic? After all, it works only for vectors of pointers to Shapes. How about lists and built-in arrays? What about “smart pointers” (resource-management pointers), such as shared_ptr and unique_ptr? What about objects that are not called Shape that you can draw() and rotate()? Consider:
template<typename Iter>
void rotate_and_draw(Iter first, Iter last, int r)
{
for_each(first,last,[](auto p) { p->rotate(r); }); // rotate all elements of [first:last)
for (auto p = first; p!=last; ++p) p->draw(); // draw all elements of [first:last)
}
This works for any sequence you can iterate through from first to last. That’s the style of the C++ standard-library algorithms. I used auto to avoid having to name the type of the interface to “shape-like objects.” That’s a C++11 feature meaning “use the type of the expression used as initializer,” so for the for-loop p’s type is deduced to be whatever type first is. The use of auto to denote the argument type of a lambda is a C++14 feature, but already in use.
Consider:
void user(list<unique_ptr<Shape>>& lus, Container<Blob>& vb)
{
rotate_and_draw(lst.begin(),lst.end());
rotate_and_draw(begin(vb),end(vb));
}
Here, I assume that Blob is some graphical type with operations draw() and rotate() and that Container is some container type. The standard-library list (std::list) has member functions begin() and end() to help the user traverse its sequence of elements. That’s nice and classical OOP. But what if Container is something that does not support the C++ standard library’s notion of iterating over a half-open sequence, [b:e)? Something that does not have begin() and end() members? Well, I have never seen something container-like, that I couldn’t traverse, so we can define free-standing begin() and end() with appropriate semantics. The standard library provides that for C-style arrays, so if Container is a C-style array, the problem is solved – and C-style arrays are still very common.
Consider a harder case: What if Container holds pointers to objects and has a different model for access and traversal? For example, assume that you are supposed to access a Container like this
for (auto p = c.first(); p!=nullptr; p=c.next()) { /* do something with *p */}
This style is not uncommon. We can map it to a [b:e) sequence like this
template<typename T> struct Iter {
T* current;
Container<T>& c;
};
template<typename T> Iter<T> begin(Container<T>& c) { return Iter<T>{c.first(),c}; }
template<typename T> Iter<T> end(Container<T>& c) { return Iter<T>{nullptr}; }
template<typename T> Iter<T> operator++(Iter<T> p) { p.current = c.next(); return this; }
template<typename T> T* operator*(Iter<T> p) { return p.current; }
Note that this is modification is nonintrusive: I did not have to make changes to Container or some Container class hierarchy to map Container into the model of traversal supported by the C++ standard library. It is a form of adaptation, rather than a form of refactoring.
I chose this example to show that these generic programming techniques are not restricted to the standard library (in which they are pervasive). Also, for most common definitions of “object oriented,” they are not object-oriented.
The idea that C++ code must be object-oriented (meaning use hierarchies and virtual functions everywhere) can be seriously damaging to performance. That view of OOP is great if you need run-time resolution of a set of types. I use it often for that. However, it is relatively rigid (not every related type fits into a hierarchy) and a virtual function call inhibits inlining (and that can cost you a factor of 50 in speed in simple and important cases).
In my next installment, I’ll address “For reliable software, you need Garbage Collection.”
By Patrick Niedzielski | Dec 8, 2014 12:34 PM | Tags: intermediate
Quick A: By exposing wrapped iterators in your interface.
From Programmers StackExchange, StackOverflow's sister site:
Allow iteration of an internal vector without leaking the implementation
I have a class that represents a list of people.
class AddressBook { public: AddressBook(); private: std::vector<People> people; }I want to allow clients to iterate over the vector of people. The first thought I had was simply:std::vector<People> & getPeople { return people; }However, I do not want to leak the implementation details to the client. I may want to maintain certain invariants when the vector is modified, and I lose control over these invariants when I leak the implementation.
What's the best way to allow iteration without leaking the internals?
By ltorje | Dec 8, 2014 10:40 AM | Tags: advanced
In case you missed it, from Functional C++:
Continuation Passing Style
by whanhee
From the article:
Continuation passing style (CPS) is a method of programming which allows for intricate manipulation of control flow while still maintaining functional purity.
Continuations can be used to implement a whole range of things from exceptions to coroutines, but today we’ll just introduce them and a few interesting and useful concepts...
As summarized in Wikipedia: "continuation-passing style (CPS) is a style of programming in which control is passed explicitly in the form of a continuation."
By Adrien Hamelin | Dec 8, 2014 01:58 AM | Tags: intermediate
Bartlomiej Filipek shares with us five algorithms using the C++ STD:
Top 5 Beautiful C++ STD Algorithms Examples
by Bartlomiej Filipek
From the article:
Some time ago I've seen an inspiring talk from CppCon 2013: "C++ Seasoning" by Sean Parent. One of the main points of this presentation was not to use raw loops. Instead, prefer to use existing algorithms or write functions that 'wraps' such loops. I was curious about this idea and searched for nice code examples. Here is my short list of usage of algorithms from the C++ std library that might help in writing better code.
Of course. I could not skip two prominent examples from the original "C++ Seasoning" talk: slide and gather...
By Mark | Dec 8, 2014 01:02 AM | Tags: None
A discussion on Valgrind's capacity to detect undefined behavior:
Valgrind is *NOT* a leak checker
by Mark Isaacson
From the article:
Valgrind is one of the most misunderstood tools I know of in my community. Valgrind is not a leak checker. It has a leak checking tool. I'd argue that this tool happens to be the least useful component.
Without changing the way you invoke Valgrind, you get so much more useful information than most people realize. Valgrind finds latent bugs even when they don't cause your program to fail/crash; it doesn't just tell you where the bug happened, it tells you why it happened, in English. Valgrind is an undefined behavior checking tool first, a function and memory profiler second, a data-race detection tool third, and a leak checking tool last...
By Blog Staff | Dec 8, 2014 12:47 AM | Tags: None
Speaking of Python-C++ convergence:
A Slice of Python in C++
by Eric Niebler
From the article:
This post describes a fun piece of hackery that went into my Range-v3 library recently: a Python-like range slicing facility with cute, short syntax. It’s nothing earth-shattering from a functionality point of view, but it’s a fun little case study in library design, and it nicely illustrates my philosophy of library design...
By Blog Staff | Dec 4, 2014 09:34 PM | Tags: None
This week on SO:
Is a constexpr more “constant” than const?
The C++ Programming Language Fourth Edition - Bjarne Stroustrup: (emphasis mine)
2.2.3. Constants
In a few places, constant expressions are required by language rules (e.g., array bounds (§2.2.5, §7.3), case labels (§2.2.4, §9.4.2), some template arguments (§25.2), and constants declared using constexpr). In other cases, compile-time evaluation is important for performance. Independently of performance issues, the notion of immutability (of an object with an unchangeable state) is an important design concern (§10.4).
It seems that Stroustrup is suggesting here that
constexprensures immutability of an object better than a traditionalconstdeclaration. Is this correct? Are there ways in whichconstexprcan be more secure/less volatile thanconst, or does Stroustrup simply mean that since there are ways to useconstexprthat are not supported withconst(see Is constexpr really needed?), in those cases immutability can be ensured usingconstexpr?