今回は、論文の本数が多いのと、ドワンゴに雇われているので、本気でじっくりと論文を読んで解説しているし、ライブラリの論文も読み飛ばさずに読んでいるので、いつもより時間がかかる。そのため、いくつかのパートに分けて公開することにした。
今回はドラフトの更新はなし。
今回の新機能の提案の論文には、SG10のためのマクロ名の提案が目立つ。SG10というのは、Cプリプロセッサーによる機能テストのマクロ名を標準化しようという提案のStudy Groupだ。醜悪で将来廃止されるべきCプリプロセッサーに依存する機能をこれ以上増やさないで欲しいのだが。
N3824: make_array
std::array<T>を返すmake_arrayの提案。以下のように使う。
// make_arrayの利用例
std::array<int, 3> a = std::make_array( 1, 2, 3 ) ;
std::array<long, 2> b = std::make_array( 1, 2L ) ;
// narrowing conversionは違法になる
auto a = std::make_array( 1, 2U ) ; // エラー
// 明示的に型を指定する例
auto a = std::make_arrary<long>( 1, 2U ) ; // OK
// make_arrayの利用例
auto a = std::make_array( 1, 2, 3 ) ;
auto b = std::make_array( 1, 2L ) ;
// RAIIの例
class raii_holder
{
int * owned ;
public :
explicit raii_holder( int * ptr )
: owned( ptr ) { }
raii_holder( raii_holder const & ) = delete ;
raii_holder & operator =( raii_holder const & ) = delete ;
int * get() { return owned ; }
~raii_holder()
{
delete owned ;
}
} ;
int main()
{
raii_holder r( new int(0) ) ;
*r.get() = 123 ;
// 自動的にdeleteされる
}
// 提案中のライブラリ
int main()
{
auto r = std::make_scoped_resource( &::operator delete, new int(0) ) ;
// 自動でdeleteされる。
}
// System defined APIs:
void* VirtualAlloc(
void *pAddress,
size_t size,
unsigned int fAllocationType,
unsigned int fProtect);
bool VirtualFree(
void *pAddress,
size_t size,
unsigned int uiFreeType);
// VirtualFreeにもらくらく対応
int main()
{
auto r = std::make_scoped_resource( &VirtualFree,
VirtualAlloc( nullptr, PAGE_SIZE, MEM_COMMIT, PAGE_HARDWARE ),
0,
MEM_RELEASE ) ;
// 自動的にVirtualFree
}
// 0個のリソースを管理する例
int main()
{
auto r = std::make_scoped_resource(
[]{ std::cout << "I'm exception safe. Thank you very much." << '\n' ; }
) ;
// 自動的にlambda式が呼ばれる
}
// SIMD loop
for simd ( int i = 0 ; i < 10 ; ++i )
{
// 処理
}
// SIMD forの条件式で使える式
relational-expression < shift-expression
relational-expression > shift-expression
relational-expression <= shift-expression
relational-expression >= shift-expression
equality-expression != relational-expression
// SIMD関数の例
int f() simd { }
[]() simd { } ; // もちろんlambda式にも使える
// 五原則の例
struct X
{
~X() { }
}
int main()
{
X x1 ;
X x2 = x1 ; // エラー、五原則
}
// 文字列リテラルからconst性をなくす例
int main()
{
// well-formed in C++03
// ill-formed in C++11
char * ptr = "hello" ;
}
// observer_ptrの例
#include <memory>
int main()
{
// std::observer_ptr<int> ptr = new int(0) ; と同じ
auto ptr = std::make_observer( new int(0) ) ;
auto p2 = ptr ; // コピーできる
delete ptr ;
}
// 間違ったサイコロの実装
int roll( )
{
return std::rand()%6 + 1 ;
}
template< class PopIter, class SampleIter, class Size, class URNG >
SampleIter
sample( PopIter first, PopIter last, SampleIter out, Size n, URNG&&g)
{
using pop_t = typename iterator_traits<PopIter>::iterator_category;
using samp_t = typename iterator_traits<SampleIter>::iterator_category;
return __sample( first, last, pop_t{},
out, samp_t{},
n, forward<URNG>(g) );
}
// C++11では違法
using type = std::common_type<int, int *>::type ;
// SFINAEとはならない例
// 共通の型がある場合のみ候補に上がるべき関数テンプレート
template < typename T1, typename T2,
typename COMMON_TYPE = std::common_type<T1, T2>::type >
void f( T1, T2 ) { }
// その他の関数fのオーバーロード
int main()
{
int a1 = 0 ;
int * a2 = nullptr ;
f( a1, a2 ) ; // コンパイルエラー
}
invoke function defined with result_of that fails to compile because it (result_of) is not SFINAE-friendly. It also calls out std::common_type as another trait that would benefit from being SFINAE-friendly.
FDIS の不満点 - 野良C++erの雑記帳
現状、 std::result_of や std::common_type といった﹁型を取得するメタ関数﹂は、与えられた型が前提条件を満たさない場合、クラステンプレートの内部でコンパイルエラーとなるため、 SFINAE に使うことが出来ません
[PDFは割り切れない思い] N3845: Greatest Common Divisor and Least Common Multiple
最大公約数を計算するgcdと、最小公倍数を計算するlcmを<cstdlib>に追加する提案。
最大公約数や最小公倍数のアルゴリズムは、義務教育でも習うほど初歩的なものであるが、たとえ実装が一行にせよ、コードを書いて、正しく動くかどうかテストするのは難しい。しかも、このような基本的な関数の用途はかなり広い。標準ライブラリに存在するべきだ。
提案されているgcdとlcmは、constexpr関数かつ関数テンプレートで、二つの整数型の引数を取る。
また、gcdとlcmを実装するために、constexpr関数でテンプレート関数版のabsも追加される。
その実装は、コード量だけで言えば、とても短い。この記事に引用できるほどだ。
// N3845のリファレンス実装例
// 仮にclib名前空間内に置く
namespace clib {
// 任意の整数型で動くテンプレート版のabs
template< class T >
constexpr auto abs( T i ) -> enable_if_t< is_integral<T>{}(), T >
{
return i < T(0) ? -i : i; }
}
// 二つの実引数が整数型であるかどうかを確認し、また共通の型を返すメタ関数common_int_t
template< class M, class N = M >
using common_int_t = enable_if_t< is_integral<M>{}() and is_integral<N>{}()
, common_type_t<M,N>
> ;
// 最大公約数
template< class M, class N >
constexpr auto gcd( M m, N n ) -> common_int_t<M,N>
{
using CT = common_int_t<M,N>;
return n == 0 ? clib::abs<CT>(m) : gcd<CT,CT>(n, m % n);
}
// 最小公倍数
template< class M, class N >
constexpr auto lcm( M m, N n ) -> common_int_t<M,N>
{ return abs((m / gcd(m,n)) * n); }
// C++11のstatic_assertの例
static_assert( true, "This can't be possible!") ;
// BOOST_STATIC_ASSERTの実装
#define BOOST_STATIC_ASSERT(B) static_assert(B, #B)
BOOST_STATIC_ASSERT(( sizeof(int) == 4 )) ;static_assert(( sizeof(int) == 4 ), "( sizeof(int) == 4 )") ;#define STATIC_ASSERT(B) static_assert(B, #B)#define STATIC_ASSERT(B) static_assert(B, "ouch")// 案4の利用例
static_assert( sizeof(int) == 4,
"Oops, the size of int is not 4! Use this:", sizeof(int),
" Also check the size of long, just in case :D :", sizeof(long)
) ;
// N3847提案のpick_a_number
#include <random>
int main()
{
int a = std::pick_a_number( 1, 6 ) ;
double b = std::pick_a_nubmer( 1.0, 6.0 ) ;
}
// N3850の例
#include
int main()
{
std::vector v ;
// vに値を入れる
// 従来のsort、暗黙にシーケンシャル実行ポリシー
std::sort( v.begin(), v.end() ) ;
// 明示的にシーケンシャル実行ポリシー
std::sort( std::seq, v.begin(), v.end() ) ;
// 並列実行ポリシー
std::sort( std::par, v.begin(), v.end() ) ;
// ベクトル実行ポリシー
std::sort( std::vec, v.begin(), v.end() ) ;
}
// N3851時点での提案の例
std::size_t M = 32 ;
std::size_t N = 64 ;
std::vector<float> v( M * N ) ;
std::array_view<float, 2> view{ { M, N }, v } ;
view[{ 3, 3 }] = 0 ;
// N3851時点でのイテレーター
std::bounds_iterator<2> first = std::begin( view.bounds() ) ;
std::bounds_iterator<2> last = std::end( view.bounds() ) ;
float sum = 0.0 ;
std::for_each( first, last,
[]( std::index<2> index )
{
sum += view[index] ;
}
// 数値区切りの例
int x = 1000'000'000 ;
// 変換関数に関数の戻り値の型推定を適用する例
struct Zero
{
operator auto() { return 0 ; }
} ;
int main()
{
Zero zero ;
int x = zero ;
}
// 昔のforループ
void once_upon_a_time( std::vector<int> & range )
{
for ( std::vector<int>::iterator first = range.begin(),
std::vector<int>::iterator last = range.end() ;
first != last ; ++first )
{
std::cout << *first << '\n' ;
}
}
// 今のforループ
void and_now( std::vector<int> & range )
{
for ( int elem : range )
{
std::cout << elem << '\n' ;
}
}
// auto specifierの利用
for ( auto elem : range ) ;
// Range-based for loopとauto specifierの問題点
void f( std::vector< std::string > & range )
{
for ( auto elem : range )
{
std::cout << elem << '\n' ;
}
}
// コピーが発生してしまうコード
void f( std::map< const int, int > & range )
{
for ( std::pair< int, int > const & elem : range )
{
// ...
}
}
// プロクシーに対応できない例
void f( std::vector<int> &v)
{
for ( auto & elem : v )
{
std::cout << elem << '\n' ;
}
}
int main()
{
std::vector<int> non_proxy{ 1, 2, 3 } ;
f( non_proxy ) ; // well-formed
std::vector<bool> proxy{ true, true, true } ;
f( proxy ) ; // ill-formed!
}
// 新旧比較
std::add_pointer<int>::type old = nullptr ;
std::add_pointer_t<int> latest = nullptr ;
template < typename T > add_pointer_t = std::add_pointer<T>::type ;C++14には、変数テンプレートも追加されたので、これの値版を追加する提案。すなわち、
// 新旧比較
bool old = std::is_integer<int>::value ;
bool latest = std::is_integer_v<int> ;
template < typename T >
constexpr bool is_integer_v = is_integer<T>::value ;
// C++11のfuture
#include <future>
int main()
{
auto f = std::async( [](){ return 123 ; } ) ;
auto result = f.get() ;
}
// C++11の例
#include <future>
int main()
{
// まあ、これはいいか
auto f1 = std::async( [](){ return 123 ; } ) ;
auto r1 = f.get() ;// え、俺がやるの？
// またかよ・・・
auto f2 = std::async( [&](){ return r1 + 456 ; } ) ;
auto r2 = f2.get() ; // で、また俺がやるの？
}
// then
#include <future>
int main()
{
auto f2 = std::async( []() { return 123 ; } )
.then( []( auto f ){ return f.get() + 456 ; }
)
auto r2 = f2.get() ;
}
// unwrapの例
#include <future>
int main()
{
// outer_futureはstd::future< std::future< int > >
auto outer_future = std::async( []{
return std::async( [] {
return 123 ;
} ) ; // inner
} ) ; // outer
auto inner_future_proxy = outer_future.unwrap() ;
inner_future_proxy.then([]( auto f ) {
auto result = f.get() ;
} ) ;
}
// is_readyの例
#include <future>
void do_something_or_other( std::future<int>f)
{
if ( f.is_ready() )
{
int value = f.get() ; // ブロックしない
}
else
{
// getはブロックするので、なにか別のことをする
}
}
// when_anyの例
#include <future>
int main()
{
std::future<int> futures[] = {
std::async( []{ return 1 ; },
std::async( []{ return 2 ; },
std::async( []{ return 3 ; }
} ;
// std::future< std::vector< std::future<int> > >
auto vec_future = std::when_any( std::begin(futures), std::end(futures) ) ;
// std::future< std::tuple< std::future<int>, std::future<int>, std::future<int> > >
auto tuple_future = std::when_any( futures[0], futures[1], futures[2] ) ;
vec_future.then([]{
// どれかが完了している
} ) ;
}
// 値をセット済みのfutureを作る
template <typename T >
std::future< typename std::decay_t<T> > make_ready_future( T && value )
{
std::promise< typename std::decay<T>::type > p ;
p.set_value( std::forward<T>( value ) ) ;
return p.get_future() ;
}
// future.thenの例
future<int> f(shared_ptr<stream> str)
{
shared_ptr<vector<char>> buf = ...;
return str->read(512, buf)
.then([](future<int>op)
// lambda 1
{
return op.get() + 11;
});
}
future<void> g()
{
shared_ptr<stream> s = ...;
return f(s).then([s](future<int>op)
{
s->close();
});
}
// resumable functionの例
future<int> f(stream str) resumable
{
shared_ptr<vector<char>> buf = ...;
int count = await str.read(512, buf);
return count + 11;
}
future<void> g() resumable
{
stream s = ...;
int pls11 = await f(s);
s.close();
}
// resumableキーワード
std::future<int> f() resumable ;
[]() resumable {} ;
// 関数のresumable指定子の位置
struct S
{
std::future<int> f() & resumable noexcept ;
} ;
// lambda式のresumable指定子の位置
[]() mutable resumable noexcept -> std::future<int>{ return 0 ; }
// lambda式かつresumable functionの戻り値の型推定
// 戻り値の型はstd::future<int>
[]() resumable { return 0 ; }
await expr//awaitの例
std::future<void> f() resumable
{
// 事前の処理
int r1 = await std::async( []{ return 0 ; } ) ;
// 事後の処理
int r2 = await std::async) [] { return 0 ; } ) ;
// さらに処理
return ;
}
// mutexの例
int x = 0 ;
int y = 0 ;
// x, yにアクセスする際は、かならずmをロックすること
std::mutex m ;
void f()
{
{
std::lock_guard< std::mutex > lock(m) ;
++x ;
++y ;
}
}
// N3859提案のTransactional Memoryの例
int x = 0 ;
int y = 0 ;
void f()
{
synchronized
{
++x ;
++y ;
}
}
// N3859提案のAtomic Block三種類
atomic noexcept { /* ... */ }
atomic commit_except { /* ... */ }
atomic cancel_except { /* ... */ }
// atomic noexcept
atomic noexcept
{
try
{
// ...
}
catch( ... )
{
// 絶対に外に例外を投げないように握りつぶす
}
}
// atomic commit_except
int x = 0 ;
int y = 0 ;
void f()
{
try
{
atomic commit_except
{
++x ;
throw 0 ;
++y ;
}
} catch( ... ) { }
// この時点で、他のスレッドを考慮に入れなければ
// xはインクリメントされている
// yは初期値のまま
}
// atomic cancel_except
int x = 0 ;
int y = 0 ;
void f()
{
try
{
atomic cancel_except
{
++x ;
throw 0 ;
++y ;
}
} catch( ... ) { }
// この時点で、他のスレッドを考慮に入れなければ
// xは初期値のまま
// yは初期値のまま
}
// 副作用は一斉に見えるか見えないか
int x = 0 ;
int y = 0 ;
void f()
{
atomic noexcept
{
++x ;
// #1
++y ;
}
// #2
}
ドワンゴ広告
この記事はドワンゴの勤務時間中に書かれた。
ドワンゴは本物のC++プログラマーを募集しています。
CC BY-ND 4.0: Creative Commons — Attribution-NoDerivatives 4.0 International — CC BY-ND 4.0
5 comments:
static_assertについては、 template constexper (char&)[N] printf(const char[],const T&&...); をかいてもらえば大分汎用性あるじゃないでしょうか。 static_assertってコンパイル時実行出来ましたよね？？ ただ、実行形式がでかくなりそうですけど。あと、VCユーザーなので宣言間違ってるかも。 それと、GDCとLCMがcmathに入らなかったのはなんでなんでしょうか？たまにつかうので歓迎なんですが、ヘッダー分けられるとちょっと大変だ。 それとローカル変数の返り値が全部ムーブになるのも歓迎です。
他にもいくつかありますが、全体的に面白かったです。 February 18, 2014 at 3:12 AM
失礼しましたー。 February 18, 2014 at 3:15 AM
Post a Comment