常連

C++を使って組み込みソフトの仕事をしている三十路エンジニアですが、
恥ずかしながら最近になってムーブセマンティクスの勉強をしております。

[こちらのブログ](https://yohhoy.hatenablog.jp/entry/2012/12/15/120839)で理解は進んだのですが、普段仕事で多用している参照渡しとの使い分けが
しっかりと理解できていません。

例えば、vectorの要素を2倍にする関数を`std::move`で次のように書けると思います。
```cpp
#include <vector>
#include <utility>

std::vector<int> twice_vec(std::vector<int> vec) {
  for (auto& e : vec) {
    e *= 2;
  }

  return std::move(vec);
}

int main(void) {
  std::vector<int> a = {1, 2, 3};

  std::vector<int> b = twice_vec(std::move(a));

  return 0;
}
```

シンタックスは明らかに異なるものの、同じ「ような」ことを参照渡しで行うと以下のように書けると思います。
```cpp
#include <vector>

void twice_vec_2(std::vector<int>& vec) {
  for (auto& e: vec) {
    e *= 2;
  }
}

int main(void) {
  std::vector<int> a = {1, 2, 3};

  twice_vec_2(a);

  return 0;
}
```

当方の認識では、パフォーマンス的に参照渡しで書いたコードが劣ることはないと理解しています。
この差は、ムーブで書いたほうが各変数がimmutableなように書いてあって分かりやすい以外に何かあるのでしょうか。
どういう時はどっちのほうが良い、などあるのでしょうか。
（極端な話、今までポインタや参照渡しで書かれていたコードは全てムーブセマンティクスで書いたほうが良いというような話なのでしょうか）

何卒、よろしくお願いいたします。

C++ 参照渡し vs ムーブセマンティクス

### 実現したいこと

- C++の実行コードをヘッダに書くか、ソースに書くかについて、皆さんのご意見をうかがいたい
- 例えば「自分はベストプラクティスを知っているので広めたい！」という意見
- 例えば「自分はこういうケースでいつもこうしている」という意見
- 例えば「自分はよく知らないけど、こういうツールを知っている」という意見
- etc...

### 前提

- C++11(以降)
- 公開範囲については皆さんが想定されるケースを決めてください(言及しない場合はオープンソース)
- 規模感については皆さんが想定されるケースを決めてください(言及しない場合は数k行程度以内)
- 外部コードの有無については、皆さんが想定されるケースを決めてください(言及しない場合は自身がアプリから使用されるライブラリ)
- 処理系についてはgcc9以降限定
- プラットフォームについては限定しませんが、OSはあるものとしてください

### 発生している問題・エラーメッセージ

- (A)ヘッダに書く場合は、公開したくないコードまで公開する必要がある
- (B)ソースに書く場合は、テンプレートのインスタンス化が悩ましい
- (C)ヘッダに書く場合は、同じものが複数展開されるため、それぞれでコードが異なりうる懸念がある

(B),(C)については以下コードで例示します

### 該当のソースコード
環境構築用のスクリプトです。最後にビルドして実行します。
```bash
#!/bin/sh
cat >Makefile <<EOF
CC=g++
CXXFLAGS=-g -std=c++11 -Wall
all: main main_lib main_diff
clean:
        rm -f *.o *.a main main_lib main_diff
main: main.o
main_lib: main_lib.o libsub.a
        \$(CC) main_lib.o -L. -lsub -o main_lib
libsub.a: libsub.a(sub_lib.o)
main_diff: main_diff.o libsub2.a
        \$(CC) main_diff.o -L. -lsub2 -o main_diff
main_diff.o: main_diff.cpp sub_diff_v1.h
        cp sub_diff_v1.h sub_diff.h
        \$(CXX) \$(CXXFLAGS) \$(CPPFLAGS) \$(TARGET_ARCH) -c main_diff.cpp
sub2_diff.o: main_diff.cpp sub_diff_v2.h
        cp sub_diff_v2.h sub_diff.h
        \$(CXX) \$(CXXFLAGS) \$(CPPFLAGS) \$(TARGET_ARCH) -c sub2_diff.cpp
libsub2.a: libsub2.a(sub2_diff.o)
EOF
cat >main.cpp <<EOF
#include <iostream>
#include "sub.h"
int main() {
    Hoge hoge;
    hoge.print(std::cout);
    return 0;
}
EOF
cat >main_diff.cpp <<EOF
#include <iostream>
#include "sub_diff.h"
#include "sub2_diff.h"
int main() {
    Hoge hoge;
    hoge.print(std::cout);
    sub2();
    return 0;
}
EOF
cat >main_lib.cpp <<EOF
#include <iostream>
#include "sub_lib.h"
int main() {
    Hoge hoge;
    hoge.print(std::cout);
    return 0;
}
EOF
cat >sub.h <<EOF
#pragma once
#include <ostream>
struct Hoge {
    template<typename T> void print(T& out) { out << "ほげ" << std::endl; }
};
EOF
cat >sub2_diff.cpp <<EOF
#include <iostream>
#include "sub_diff.h"
#include "sub2_diff.h"
void sub2() {
    Hoge hoge;
    hoge.print(std::cout);
}
EOF
cat >sub2_diff.h <<EOF
#pragma once
void sub2();
EOF
cat >sub_diff.h <<EOF
#pragma once
#include <ostream>
struct Hoge {
    template<typename T> void print(T& out) { out << "ふが" << std::endl; }
};
EOF
cat >sub_diff_v1.h <<EOF
#pragma once
#include <ostream>
struct Hoge {
    template<typename T> void print(T& out) { out << "ほげ" << std::endl; }
};
EOF
cat >sub_diff_v2.h <<EOF
#pragma once
#include <ostream>
struct Hoge {
    template<typename T> void print(T& out) { out << "ふが" << std::endl; }
};
EOF
cat >sub_lib.cpp <<EOF
#include <ostream>
#include "sub_lib.h"
template<typename T>
void Hoge::print(T& out) {
    out << "ほげ" << std::endl;
}
template void Hoge::print(std::ostream&);
EOF
cat >sub_lib.h <<EOF
#pragma once
struct Hoge {
    template<typename T> void print(T& out);
};
EOF
make
./main
./main_lib
./main_diff
```

### (B)/(C)の説明
まずは基本となるmain.cppとsub.hを見てください。

**main.cpp**
```c++
#include <iostream>
#include "sub.h"
int main() {
    Hoge hoge;
    hoge.print(std::cout);
    return 0;
}
```
**sub.h**
```c++
#pragma once
#include <ostream>
struct Hoge {
    template<typename T> void print(T& out) { out << "ほげ" << std::endl; }
};
```
何の変哲もない「ほげ」って出力するだけのコードです。
ヘッダにコードが記述されているので、モジュールも1つだけになっている単純な例です。
自分のコードがsub.hで、これを公開すると思ってください。

#### (B)ソースに書く場合は、テンプレートのインスタンス化が悩ましい

sub.hの実行コードをソースに移し、(静的)ライブラリにする形態がmain_lib.cpp、sub_lib.h、sub_lib.cppになります。

**main_lib.cpp**
```c++
#include <iostream>
#include "sub_lib.h"
int main() {
    Hoge hoge;
    hoge.print(std::cout);
    return 0;
}
```
**sub_lib.h**
```c++
#pragma once
struct Hoge {
    template<typename T> void print(T& out);
};
```
**sub_lib.cpp**
```c++
#include <ostream>
#include "sub_lib.h"
template<typename T>
void Hoge::print(T& out) {
    out << "ほげ" << std::endl;
}
template void Hoge::print(std::ostream&);
```
気づきましたでしょうか？

sub_lib.cppの最終行に、テンプレートのインスタンス化用の定義が入っています。この行はstd::coutのクラスであるstd::ostreamが定義されています。これがないと main_lib.cpp 側の hoge.print(std::cout) 呼び出しでundefined referenceが発生しちゃうわけです。呼び出す側のコードで、T=std::outputstreamなメソッドを必要とするので、呼び出される側のコードでそのインスタンス化が必要になるということです。

つまり呼び出す側のコードで使いたいTが増えるごとに、呼び出される側にこの行が必要になるということになります。これが面倒だというのが(B)です。

#### (C)ヘッダに書く場合は、同じものが複数展開されるため、それぞれでコードが異なりうる懸念がある

説明のため、元のコードを以下のようにしています。
- main.cpp→main_diff.cpp
- sub.h→sub_diff_v1.h
さらに同じものを複数展開するために、
- sub.h→sub_diff_v2.h
- sub2_diff.h
- sub2_diff.cpp
というのを用意しています。ようはモジュールを2つに増やし、それぞれにsub.h相当をインクルードして呼び出させるということです。
sub2側はライブラリにして、main側からリンクします。

**main_diff.cpp**
```c++
#include <iostream>
#include "sub_diff.h"
#include "sub2_diff.h"
int main() {
    Hoge hoge;
    hoge.print(std::cout);
    sub2();
    return 0;
}
```
**sub_diff_v1.h**
```c++
#pragma once
#include <ostream>
struct Hoge {
    template<typename T> void print(T& out) { out << "ほげ" << std::endl; }
};
```
**sub_diff_v2.h**
```c++
#pragma once
#include <ostream>
struct Hoge {
    template<typename T> void print(T& out) { out << "ふが" << std::endl; }
};
```
**sub2_diff.h**
```c++
#pragma once
void sub2();
```
**sub2_diff.cpp**
```c++
#include <iostream>
#include "sub_diff.h"
#include "sub2_diff.h"
void sub2() {
    Hoge hoge;
    hoge.print(std::cout);
}
```
各.cppファイルでインクルードしてるファイルがsub_diff.hになっていますが、これは_v1/_v2というサフィックスがついたファイルをmake注にコピーして作成しています。何を意図しているかというと、main_diff側と、libsub2.a側で異なるバージョンのsub_diff.hを使ったケースの再現です。そのままビルドすると、main_diff側のコードに一本化されて動きますが、最適化させるとインライン展開されてそれぞれ異なるコードで動作します。

### 最後に

C++を使ってる人なら誰もが一度はどうしようかと悩むところだと思いますが、あっちを立てればこっちが立たずみたいな状況なので、意見を集めてみてもいいかなと思って、書いてみました。参考までに私は公開ソースなら全部ヘッダにしていて、非公開なら規模次第でソースにしてます。テンプレートは限定的な使い方にします。

※勘違いの指摘なども歓迎です


C++のコードをヘッダに書くか、ソースに書くかについて

いつもお世話になります。

double型の変数について、0.0であるか否かをチェックする時（例：ゼロ割チェック）
今まで以下のように書いていました。
```cpp
#include <cfloat>
#include <cmath>
double x = 0.0;
bool is_zero = (fabs(x) < DBL_EPSILON);
```

しかしながら、`DBL_MIN`というものも存在し、かつ定義がそれぞれ以下のようになっていることを知りました。

- `DBL_MAX`:1と1以上の最小の数との差を表す
- `DBL_MIN`:正の最小の数を表す
- 一般に `DBL_MIN < DBL_EPSILON` である

## 質問1
`double`型変数がゼロか否かを確認する際（とりあえずゼロ割回避のシーン限定で結構です）、
`DBL_MIN`と`DBL_EPSILON`、どちらを使うべきかの推奨はあるのでしょうか。
```cpp
bool is_zero = (fabs(x) < DBL_EPSILON);  // This or...
bool is_zero = (fabs(x) < DBL_MIN);      // THIS ?
```

## 質問2
`DBL_EPSILON`が「1と1以上の〜」となっていて、「0と0以上の〜」ではない理由が知りたいです。

推測は、以下のように`DBL_EPSILON`に掛け算をして、スケールに応じて使えるようにかな、と思いましたが、
正しいでしょうか。
（意味の定義を0と0以上の~にしてしまうと掛け算する意味がない？）
```cpp
#include <cfloat>
#include <cmath>

double x = 50.000000000000015;
double y = 50.00000000000002;

bool is_same = (fabs(x - y) < (DBL_EPSILON * std::max(x, y)));
```

大変浅学で恐縮です。
よろしくお願い致します。

## 参考リンク
- [DBL_MIN: cpprefjp](https://cpprefjp.github.io/reference/cfloat/dbl_min.html)
- [DBL_EPSILON: cpprefjp](https://cpprefjp.github.io/reference/cfloat/dbl_epsilon.html)

(C++) double型変数が0.0か否かの判定

以下のようなエラー文がでていて原因を調べても解決できていない状態なのでアドバイス頂きたいです。

```error
src/***.cpp: In member function ‘関数名’:
src/***.cpp:26: error: expected initializer before --
make: *** [obj/***.o] Error 1
```

状況としては特定のスレッドの中でクラスを作り、そのクラスのメソッド内で他のクラスを作りそのメソッドを実行しようとしています。そのメソッド内でなにもしないとコンパイルエラーは起こりません。しかしそのメソッドでなにか関数を呼ぶとその関数が -- のところに入った形でコンパイルエラーが起こります。宜しくお願い致します。。。

C++ のexpected initializer before *** のエラーについて

### 実現したいこと

- [ ] 日本語変換エンジンが不安定なので直したい

### 前提

C++/Win32で自作の日本語IMEの変換エンジンを作成しています。
こちらのリポジトリをダウンロードして、CMakeとVisual C++でビルドして下さい。

[https://github.com/katahiromz/mzimeja](https://github.com/katahiromz/mzimeja)

「`ime/convert.cpp`」が変換エンジンで、「`ime/tests.cpp`」がテストコードになっております。
「`ime/convert.cpp`」の「`MzIme::ConvertMultiClause`」関数が変換処理になります。
「`res/basic.dat`」が辞書データとなっております。

コンパイルしてできた「`imetests.exe`」がテストプログラムです。

### 発生している問題・エラーメッセージ

変換アルゴリズムが不安定で困っています。具体的には次のテスト項目の変換において途中で変換が勝手に終了して失敗することがあります。

![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2023-05-15/bc489d5e-9e2e-4768-b33b-57b2e7e86cda.png)

```cxx
DoEntry(L"とうたつします。とうたつしてください。とうたつしないでください。",
        L"到達します。到達してください。到達しないでください。");
DoEntry(L"とうたつするよ。とうたつしたぞ。とうたつできるな。とうたつしよう。",
        L"到達するよ。到達したぞ。到達できるな。到達しよう。");
DoEntry(L"これをたべないでください。", L"これを食べないでください。");
DoEntry(L"わかりづらいので、わかりやすくおねがいします。たべにくいです。たべやすいものがいいです。",
        L"分かりづらいので、分かりやすくお願いします。食べにくいです。食べやすいものが良いです。");
DoEntry(L"わたしがわたしたわたをわたがしみたいにたべないでくださいませんか",
        L"私が渡した綿を綿菓子みたいに食べないでくださいませんか");
```
### 該当のソースコード

```cxx
// 複数文節を変換する。
BOOL MzIme::ConvertMultiClause(const std::wstring& str, MzConvResult& result, BOOL show_graphviz)
{
    DPRINTW(L"%s\n", str.c_str());

    // 変換前文字列をひらがな全角で取得。
    std::wstring pre = lcmap(str, LCMAP_FULLWIDTH | LCMAP_HIRAGANA);

    // ラティスを作成し、結果を作成する。
    Lattice lattice;
    lattice.AddNodesForMulti(pre);
    lattice.AddExtraNodes();
    lattice.UpdateLinksAndBranches();
    lattice.CutUnlinkedNodes();
    lattice.AddComplement();
    lattice.MakeReverseBranches(lattice.m_head.get());

    lattice.m_tail->marked = 1;
    lattice.CalcSubTotalCosts(lattice.m_tail.get());

    lattice.m_head->marked = 1;
    lattice.OptimizeMarking(lattice.m_head.get());

    MakeResultForMulti(result, lattice);

    if (result.clauses.empty()) {
        MakeResultOnFailure(result, pre);
    }

    if (show_graphviz)
        ShowGraphviz(result);

    return TRUE;
} // MzIme::ConvertMultiClause
```

### 試したこと

テストコードを書き、テストを実施しました。直す方法が分かりませんでした。
外注しようかと思いましたが、解決できる人材が見つかりませんでした。

### 補足情報（FW/ツールのバージョンなど）

- Visual Studio Community 2019 (with Visual C++)
- CMake

日本語変換エンジンの変換アルゴリズムが途中で失敗するのを直したい（C++）

以下のようなfloatのポインタを引数として受け取るクラス内関数があるとき、どのようにpython側から呼べば良いのでしょうか？

```
#include <pybind11/numpy.h>
#include <pybind11/pybind11.h>

namespace py = pybind11;

class MyClass {
public:
  void myFunc(float *arr, int size) {
    for (int i = 0; i < size; i++) {
      arr[i] += 1.0f;
    }
  }
};

PYBIND11_MODULE(example, m) {
  py::class_<MyClass>(m, "MyClass")
      .def(py::init<>())
      .def("my_func", &MyClass::myFunc);
}
```

以下のようにpython側で呼んでいるのですが、エラーが出ていて困っている状況です。
```
import numpy as np
import sys
sys.path.append( "./build" )
import example

# Create an instance of MyClass
my_obj = example.MyClass()

# Create a NumPy array
arr = np.array([1.0, 2.0, 3.0], dtype=np.float32)

# Call myFunc with the NumPy array
my_obj.my_func(arr, arr.size)

# Print the updated array
print(arr)
```

以下がエラーです。
> Traceback (most recent call last):
>   File "test2.py", line 13, in <module>
>    my_obj.my_func(arr, arr.size)
> TypeError: my_func(): incompatible function arguments. The following argument types are supported:
>     1. (self: example.MyClass, arg0: float, arg1: int) -> None
> Invoked with: <example.MyClass object at 0x7f987db50ef0>, array([1., 2., 3.], dtype=float32), 3


pybind11で、クラス内関数にfloatのポインタを与える方法

c言語です！
コインをn回振った時に、連続した表の最大数がm
回以上の確率を書き出せ。
n=4の出力を、提出するソースコードの末尾に注釈として挿入せよ。

例)n=3の時
m, m回以上連続で表となる確率
0, 100.0%
1, 87.5%
2, 37.5%
3, 12.5%

という問題が出たのですがどなたか教えていただきたいです。
手も足も出ないです。。

コインの表裏の問題について

こんにちは。

C++11で対応された範囲ベースfor、すっごく便利なのでよく使っているのですが、たまにインデックス番号も欲しい時があります。
そんな時は、`for (size_t i=0; 云々`で回してます。ドン臭いし、既に範囲ベースforで書いているコードを書き換えるのも面倒です。

begin(), end()で回せばdistance()が使えることは分かっているのですが、`for (size_t i=0; 云々`と同様書き換えが面倒なのです。更にバグでイテレータがend()を越えるとちょっと怖いです。

頭で`size_t index=0;`してループの最後で`++index;`もありですが、`continue`使うとはまりそうです。

範囲ベースforで回している時にインデックス番号をスマートに計算する方法ってないでしょうか？
ありそうな気もするのですが、グーグル先生教えてくれないのです。orz

---
【閑話休題】
なぜに範囲ベースforはiteratorを返さないのでしょう？
[for-range-declaration = *__begin;](http://cpplover.blogspot.jp/2009/08/n2930-range-based-for-loop.html)じゃなくて、`for-range-declaration = __begin;`なら良かったのに。

---
【その後】
その後、調べていて、ランダム・アクセス・イレテータでないコンテナの場合、std:distance()はリストを追跡するらしいことが分かりました。ということは同様にoperator[]も追跡する筈ですね。（何を今更なのですが。）
今はvectorで範囲ベースforを使ってますが一部はforward_listへ変更します。これを見越すと、インデックスを使うためにはイテレータ型のfor文へ変更しインデックスも追加する必要があります。for文がごちゃごちゃになり、範囲ベースforとの落差に悶え死にそうでした。しかも、autoの型が変わってしまうし．．．

個人的にこれらが許せないので、yumetodoさんのリンク先の記事からヒントを得て、ツールを作りました。
考え方は、自作の隠しイテレータをコンパイラへ返して、それがインクリメントされた時にインデックスも一緒にインクリメントするイメージです。
ですので、listでも使えますし、listのイテレータをdistanceした時のような追跡処理も発生しません。そして、autoで推論される型は同じコンテナの要素のままですので、範囲ベースforブロック内の変更も不要です。

```C++
#include <iterator>

// ***************************************************************************
//      範囲ベースforにインデックス機能を追加する
// ***************************************************************************

namespace staff_only
{

//----------------------------------------------------------------------------
//      隠しイテレータ・クラス
//----------------------------------------------------------------------------

template<typename tValueType, typename tParentIterator>
class Iterator
{
    tParentIterator mParentIterator;
    std::size_t&    mIndexReference;
public:
    explicit Iterator(tParentIterator iIterator, std::size_t& iIndexReference) :
        mParentIterator(iIterator),
        mIndexReference(iIndexReference)
    { }

    tValueType& operator*() {return *mParentIterator;}
    tParentIterator& operator++()
    {
        ++mParentIterator;
        ++mIndexReference;
        return mParentIterator;
    }
    bool operator==(Iterator const& rhs) {return mParentIterator==rhs.mParentIterator;}
    bool operator!=(Iterator const& rhs) {return mParentIterator!=rhs.mParentIterator;}
};

//----------------------------------------------------------------------------
//      コンテナ
//----------------------------------------------------------------------------

template<class tContainer>
class Indexer
{
    typedef typename tContainer::value_type ValueType;
    typedef typename tContainer::iterator ParentIterator;
    typedef Iterator<ValueType, ParentIterator> InnerIterator;

    // Indexer実体
    tContainer&     mContainer;
    std::size_t&    mIndexReference;
public:
    explicit Indexer(tContainer& iContainer, std::size_t& iIndexReference) :
        mContainer(iContainer),
        mIndexReference(iIndexReference)
    {
        mIndexReference=0;
    }
    InnerIterator begin()
    {
        return InnerIterator(mContainer.begin(), mIndexReference);
    }
    InnerIterator const end() const
    {
        return InnerIterator(mContainer.end(), mIndexReference);
    }
};

//----------------------------------------------------------------------------
//      生配列
//----------------------------------------------------------------------------

template<class tValueType, size_t tDim>
class Indexer<tValueType[tDim]>
{
    typedef tValueType* ParentIterator;
    typedef Iterator<tValueType, ParentIterator> InnerIterator;

    // Indexer実体
    typedef tValueType Container[tDim];
    Container&      mContainer;
    std::size_t&    mIndexReference;
public:
    explicit Indexer(Container& iContainer, std::size_t& iIndexReference) :
        mContainer(iContainer),
        mIndexReference(iIndexReference)
    {
        mIndexReference=0;
    }
    InnerIterator begin()
    {
        return InnerIterator(&mContainer[0], mIndexReference);
    }
    InnerIterator const end() const
    {
        return InnerIterator(&mContainer[tDim], mIndexReference);
    }
};
}   // namespace staff_only

//----------------------------------------------------------------------------
//      API
//----------------------------------------------------------------------------

template<class tContainer>
staff_only::Indexer<tContainer> getIndexer(tContainer& iContainer, std::size_t& iIndexReference)
{
    return staff_only::Indexer<tContainer>(iContainer, iIndexReference);
}

// ***************************************************************************
//      使い方
// ***************************************************************************

#include <array>
#include <vector>
#include <forward_list>
#include <list>

#include <iostream>

int main()
{
    struct TestClass
    {
        int x, y;
    };
    TestClass                       wRawArray[] = {{5,1}, {4,2}, {3,3}, {2,4}, {1,5}, {0,6}};
    std::array<TestClass, 5>        wArray      ={{{4,2}, {3,3}, {2,4}, {1,5}, {0,6}}};
    std::vector<TestClass>          wVector     = {{3,3}, {2,4}, {1,5}, {0,6}};
    std::forward_list<TestClass>    wForwardList= {{2,4}, {1,5}, {0,6}};
    std::list<TestClass>            wList       = {{1,5}, {0,6}};

    std::size_t wIndex;

    std::cout << "raw-array\n";
    for (auto& wData : getIndexer(wRawArray, wIndex)) {
        std::cout << "[" << wIndex << "]=" << wData.x << ", " << wData.y << "\n";
    }

    std::cout << "\nstd::array\n";
    for (auto& wData : getIndexer(wArray, wIndex)) {
        std::cout << "[" << wIndex << "]=" << wData.x << ", " << wData.y << "\n";
    }

    std::cout << "\nstd::vector\n";
    for (auto& wData : getIndexer(wVector, wIndex)) {
        std::cout << "[" << wIndex << "]=" << wData.x << ", " << wData.y << "\n";
    }

    std::cout << "\nstd::forward_list\n";
    for (auto& wData : getIndexer(wForwardList, wIndex)) {
        std::cout << "[" << wIndex << "]=" << wData.x << ", " << wData.y << "\n";
    }

    std::cout << "\nstd::list\n";
    for (auto& wData : getIndexer(wList, wIndex)) {
        std::cout << "[" << wIndex << "]=" << wData.x << ", " << wData.y << "\n";
    }

    return 0;
}


```

msvc2015とMinGW 5.2.0で動作確認してます。

２点不満が残りました。orz
イテレータはこっそりインクリメントされているので、インデックスもこっそりインクリメントされます。範囲ベースforの仕様とも言えるのでこの点は許容することにしました。
インデックスのスコープがforの外側になってしまいます。内側にしたいのですが、範囲ベースforの構文に割り込めず諦め。