Home » Blog » 2017 » November

November 2017

Abstraction design and implementation: `repeat` -- Vittorio Romeo

By Vittorio Romeo | Nov 13, 2017 11:37 PM | Tags: intermediate c++14

This series of two articles covers the train of thought behind the design and implementation of a simple `repeat` abstraction that, given a number `n` and a function object `f`, invokes `f` `n` times. The abstraction can be used to repeat actions both at run-time and compile-time. The articles also cover importance of propagating `noexcept`-correctness (and the pain caused by it!).

abstraction design and implementation: `repeat`

compile-time `repeat` & `noexcept`-correctness

by Vittorio Romeo

From the articles:

In my previous "passing functions to functions" and "zero-overhead C++17 currying & partial application" articles I've praised C++11 (and newer standards) for allowing us to write "more functional" code. [...] If I want to repeat an action n times, I exactly want to write that in my code:

    repeat(10, []
    {
        foo();
    });

Cannot get simpler than that - let's implement it!

2017 Albuquerque ISO C++ Committee Reddit Trip Report

By Adrien Hamelin | Nov 13, 2017 01:49 PM | Tags: community

Another report:

2017 Albuquerque ISO C++ Committee Reddit Trip Report

From the article:

The ISO C++ Committee met in Albuquerque, New Mexico, USA last week to continue work on C++ Technical Specifications and the next International Standard, C++20. C++17 is done; the final version was sent to ISO for publication in September. We started to firm up the schedule and feature set for C++20 at this meeting; we're hoping to land most of the major features by the first meeting of 2019...

Trip report: Fall ISO C++ standards meeting (Albuquerque)--Herb Sutter

By Adrien Hamelin | Nov 13, 2017 01:39 PM | Tags: community

C++ continues to evolve.

Trip report: Fall ISO C++ standards meeting (Albuquerque)

by Herb Sutter

From the article:

A few minutes ago, the ISO C++ committee completed its fall meeting in Albuquerque, New Mexico, USA, hosted with our thanks by Sandia National Laboratories. We had some 140 people at the meeting, representing 10 national bodies. As usual, we met for six days Monday through Saturday, including several evenings.

POCO Release 1.8.0 Available

By Alex Fabijanic | Nov 10, 2017 01:18 PM | Tags: None

POCO 1.8.0 is now available:

POCO Release 1.8.0 is out

by POCO Team

POCO C++ Libraries release 1.8.0 is available. This release brings Unix Domain Socket support in the Net library, Zip64 support in the Zip library, an XML stream parser API, the new Redis client library, support for connection string URIs in the MongoDB client library and a couple of other improvements and bugfixes.

In addition to optional C++11/14 features support, this release still supports C++03 compilers, including Visual C++ 2008. Support for OpenVMS has been removed. Full C++11/14 support coming soon in release 2.0.

 

Quick Q: What does the explicit keyword mean?

By Adrien Hamelin | Nov 9, 2017 02:46 PM | Tags: basics

Quick A: It tell the compiler not to do any implicit conversions of types.

Recnetly on SO:

What does the explicit keyword mean?

The compiler is allowed to make one implicit conversion to resolve the parameters to a function. What this means is that the compiler can use constructors callable with a single parameter to convert from one type to another in order to get the right type for a parameter.

Here's an example class with a constructor that can be used for implicit conversions:

class Foo
{
public:
  // single parameter constructor, can be used as an implicit conversion
  Foo (int foo) : m_foo (foo)
  {
  }

  int GetFoo () { return m_foo; }

private:
  int m_foo;
};

Here's a simple function that takes a Foo object:

void DoBar (Foo foo)
{
  int i = foo.GetFoo ();
}

and here's where the DoBar function is called.

int main ()
{
  DoBar (42);
}

The argument is not a Foo object, but an int. However, there exists a constructor for Foo that takes an int so this constructor can be used to convert the parameter to the correct type.

The compiler is allowed to do this once for each parameter.

Prefixing the explicit keyword to the constructor prevents the compiler from using that constructor for implicit conversions. Adding it to the above class will create a compiler error at the function call DoBar (42). It is now necessary to call for conversion explicitly with  DoBar (Foo (42))

The reason you might want to do this is to avoid accidental construction that can hide bugs. Contrived example:

  • You have a MyString(int size) class with a constructor that constructs a string of the given size. You have a function print(const MyString&), and you call print(3) (when you actually intended to call print("3")). You expect it to print "3", but it prints an empty string of length 3 instead.

Enforcing code contracts with [[nodiscard]]

By bfilipek | Nov 7, 2017 10:43 AM | Tags: None

More details about a new C++17 attribute

Enforcing code contracts with [[nodiscard]]

by Bartlomiej Filipek

From the article:

[[nodiscard]] is an excellent addition to all the important code: public APIs, safety-critical systems, etc. Adding this attribute will at least enforce the code contract. The compiler will help you detect bugs - at compile time, rather than finding in in the runtime.

C++ User Group Meetings in November

By Meeting C++ | Nov 2, 2017 07:25 AM | Tags: usergroups meetingcpp community

The monthly overview on upcoming C++ User Group Meetings...

C++ User Group Meetings in November

by Jens Weller

From the article:

The monthly overview on upcoming C++ User Group Meetings! With next weeks Meeting C++ 2017 conference, many members of the new and established C++ User Groups will meet in Berlin! I hope to motivate again many visiting folks to start attending a near by C++ User Group, or to start their own User Group, if it does not yet exist.

There are 5 new C++ User Groups: Core C++, Israel, Brisbane, Moscow, Lissabon, Canterbury...