N3899: Nested Allocation—Lawrence Crowl

A new WG21 paper is available. A copy is linked below, and the paper will also appear in the next normal WG21 mailing. If you are not a committee member, please use the comments section below or the std-proposals forum for public discussion.

Document number: N3899

Date: 2014-01-20

Nested Allocation

by Lawrence Crowl

Excerpt:

Stack allocation is generally faster than heap allocation. C and C++ have exploited this speed by allocating statically-sized local variables on the execution stack. With the exception of the rather limited alloca facility, all non-statically-sized objects could only be allocated on the heap.

That is, programmers had the choice between fast-but-limited and general-but-slow.

This paper explores some of the issues when refining allocation choices.

N3897: Auto-type members—Ville Voutilainen

A new WG21 paper is available. A copy is linked below, and the paper will also appear in the next normal WG21 mailing. If you are not a committee member, please use the comments section below or the std-proposals forum for public discussion.

Document number: N3897

Date: 2014-01-20

Auto-type members

by Ville Voutilainen

Excerpt:

This paper is a record of discussion about non-static data members with deduced types, aka auto members with non-static data member initializers. Such a facility has been proposed by various people at various times, and Faisal Vali created a prototype implementation for it. This paper is NOT a proposal, this paper merely records the discussion and records the reason why Vali ultimately decided not to go further with such a proposal.

N3896: Library Foundations for Asynchronous Operations—Christopher Kohlhoff

A new WG21 paper is available. A copy is linked below, and the paper will also appear in the next normal WG21 mailing. If you are not a committee member, please use the comments section below or the std-proposals forum for public discussion.

Document number: N3896

Date: 2014-01-20

Library Foundations for Asynchronous Operations

by Christopher Kohlhoff

Excerpt:

In this paper, we will first examine how futures can be a poor choice as a fundamental building block of asynchronous operations in C++. The extended std::future brings inherent costs that penalise programs, particularly in domains where C++ use is prevalent due to its low overheads. An asynchronous model based on a pure callback approach, on the other hand, allows efficient composition of asynchronous operations.

N3893-95: C++ Standard Library Issues List (Revision R86)—Alisdair Meredith

A new WG21 paper is available. A copy is linked below, and the paper will also appear in the next normal WG21 mailing. If you are not a committee member, please use the comments section below or the std-proposals forum for public discussion.

Document number: N3893-95

Date: 2014-01-20

C++ Standard Library Active Issues List (Revision R86)

C++ Standard Library Defect Report List (Revision R86)

C++ Standard Library Closed Issues List (Revision R86)

by Alisdair Meredith

Excerpt:

The purpose of this document is to record the status of issues which have come before the Library Working Group (LWG) of the INCITS PL22.16 and ISO WG21 C++ Standards Committee.

N3892: C++ Ostream Buffers—Lawrence Crowl

A new WG21 paper is available. A copy is linked below, and the paper will also appear in the next normal WG21 mailing. If you are not a committee member, please use the comments section below or the std-proposals forum for public discussion.

Document number: N3892

Date: 2014-01-20

C++ Ostream Buffers

by Lawrence Crowl

Excerpt:

At present, stream output operations guarantee that they will not produce race conditions, but do not guarantee that the effect will be sensible. Some form of external synchronization is required. Unfortunately, without a standard mechanism for synchronizing, independently developed software will be unable to synchronize.

... The general consensus in the July 2013 meeting of the Concurrency Study Group was that buffering should be explicit. This paper proposes such an explicit buffering.

N3890: Container<Incomplete Type>—Zhihao Yuan

A new WG21 paper is available. A copy is linked below, and the paper will also appear in the next normal WG21 mailing. If you are not a committee member, please use the comments section below or the std-proposals forum for public discussion.

Document number: N3890

Date: 2014-01-19

Container<Incomplete Type>

by Zhihao Yuan

Excerpt:

The goal of this paper is to allow recursive data structure definitions with STL containers, while to make the STL container instantiations well-formed even when some of the template arguments are incomplete types (in contrast to 17.6.4.8/2) is an approach to achieve the goal without breaking any language restrictions or existing practices.

N3889: Concepts Lite Speciļ¬cation—Andrew Sutton

A new WG21 paper is available. A copy is linked below, and the paper will also appear in the next normal WG21 mailing. If you are not a committee member, please use the comments section below or the std-proposals forum for public discussion.

Document number: N3889

Date: 2014-01-20

Concepts Lite Specification

by Andrew Sutton

Excerpt:

C++ has long provided language support for generic programming in the form of templates. However, these templates are unconstrained, allowing any type or value to be substituted for a template argument, often resulting in compiler errors. What is lacking is a specification of an interface for a template, separate from its implementation, so that a use of a template can be selected among alternative templates and checked in isolation.

N3887: Consistent Metafunction Aliases—Michael Park

A new WG21 paper is available. A copy is linked below, and the paper will also appear in the next normal WG21 mailing. If you are not a committee member, please use the comments section below or the std-proposals forum for public discussion.

Document number: N3887

Date: 2013-12-26

Consistent Metafunction Aliases

by Michael Park

Excerpt:

This paper recommends a systematic guideline to steer future WG21 decisions in deciding when a metafunction-name_t template alias should accompany a standard library metafunction. After applying this recommended guideline to the entire C++14 standard library, we conclude that tuple_element_t is the only missing alias. We then propose wording (a) to remedy this lack and (b) to take advantage of the proposed remedy. Finally, we also present an alternative guideline and its implications, and provide justi cations for favoring the recommended guideline.

N3886: A Proposal to add a DatabaseĀ   Access Layer to the Standard Library—Johann Anhofe

A new WG21 paper is available. A copy is linked below, and the paper will also appear in the next normal WG21 mailing. If you are not a committee member, please use the comments section below or the std-proposals forum for public discussion.

Document number: N3886

Date: 2014-01-18

A Proposal to add a Database  Access Layer to the Standard Library

by Johann Anhofe

Excerpt:

This document describes an easy to use database abstraction layer for C++. It describes a set of classes which can be used to access an arbitrary SQL based relational database system."

There exist a lot of different database systems in the world, with a lot of different API’s for accessing data within a C++ program. The most API’s are in plain old C, which make the usage even harder for novice programmers. So we need a simple harmonized layer which can be easily extended for new database systems and also easily used by programmers.

N3884: Contiguous Iterators: A Refinement of Random Access Iterator—Nevin Liber

A new WG21 paper is available. A copy is linked below, and the paper will also appear in the next normal WG21 mailing. If you are not a committee member, please use the comments section below or the std-proposals forum for public discussion.

Document number: N3884

Date: 2014-01-20

Contiguous Iterators: A Refinement of Random Access Iterator

by Nevin Liber

Excerpt:

This is a proposal to add contiguous iterators to the standard, which is a refinement of random access
iterators.

A contiguous iterator is a random access iterator that also meets the following requirements:

std::pointer_from(i) == std::addressof(*i) (when i is dereferenceable)

std::pointer_from(i + n) == std::pointer_from(i) + n (when i + n is a valid iterator)