常連

リーダブルコードという本でSwap技法なるものを知りました。
調べてみるとvector型でClearを呼ぶ際にメモリが正常に開放されないからSwapを使うというものらしいです。
ただそれってvectorにあるeraseをfor文で回すのと変わらなくないかと思っています。
swapによるメモリ解放とeraseによるメモリ開放違いってなんなんでしょうか？

Swap技法について

### 質問内容

私は場合分けを減らすためにしばしば引数にコンストラクタのインスタンスを渡します．
引数にコンストラクタのインスタンスを渡している例や説明をあまりにも見かけないので心配になり質問しました．
エラーが出るわけではないですが，このような書き方はやめた方が良いのでしょうか．

### 該当のソースコード

```c++
#include <vector>
void func(std::vector<int> vec) {
	return;
}
int main() {
	func(std::vector<int>());
	return 0;
}
```

### 追記

以下の書き方はいずれも正しいのでしょうか．
```c++
	std::vector<int> vec1;
	// std::vector<int> vec2();
	std::vector<int> vec2{};
	std::vector<int> vec3 = std::vector<int>();
	std::vector<int> *pvec = new std::vector<int>();
	delete pvec;
```

引数にコンストラクタのインスタンスを渡すことの賛否

###前提・実現したいこと
現在C++とSiv3Dで落ち物パズルゲームを制作しています。


###発生している問題・エラーメッセージ
std::vectorを使用して'Block'クラスを格納しようとしていたのですが
(std::vector<Block> bronzeと宣言)
bronze[0]などとアクセスしようとするとエラーが起きてしまいました。
**発生した箇所はboard.cpp内のdropBronze関数です。**
```
Expression: vector subscript out of range
```

###該当のソースコード
```C+++
#pragma once
#include "Block.hpp"

///<summary>
///<para>Boardクラス</para>
///<para>・Boardのサイズは大きい方</para>
///<para>・位置＝画面上のもの</para>
///<para>・座標＝二次元配列のこと</para>
///</summary>
class Board {

public:
    Board() = default;
    Board(WhichPlayer _whichPlayer);
    ~Board();

public:
    const Point		    BOARD_VISUAL_SIZE;			//見た目上の二次元配列
    const Point		    BOARD_ACTUAL_SIZE;			//実際の二次元配列
    const Point		    BOARD_POINT_1P;			//1Pの画面上の位置
    const Point		    BOARD_POINT_2P;			//2Pの画面上の位置
    const Point		    INIT_BRONZE_COORDINATE;		//ブロンズの基準の初期座標
    const Point		    BOARD_RECTANGLE_SIZE;		//ボードのサイズ
    const int		    BLOCK_SIZE;
    const unsigned int	    BRONZE_MAX_SIZE;
    const int		    RED_NUM;
    const int		    BLUE_NUM;
    const int		    GREEN_NUM;
    const int		    YELLOW_NUM;
    const int		    PURPLE_NUM;
    const int		    SELULIAN_NUM;
    const int		    WALL_NUM;   
    const int		    NONE_NUM;

public:
    void		    init();
    void		    update();
    void		    draw() const;

    void		    boardInit();
    void		    bronzeInit();
    void		    boardDraw() const;
    void		    bronzeDraw() const;

    void		    addBlockToBronze(Point coordinate,BlockColor blockColor);
    void		    moveBronzeIndicator(int direction);
    void		    dropBronze();
    void		    checkBoardConnection();

    bool		    isCanMoveBronze(int direction);
    bool		    isCanAddBlockToBronze();
    bool		    isBronzeDontCollideWithBoard(Point _coordinate);
    bool		    isReachFallingDefaultCount();

private:
    std::vector<std::vector<BlockColor>>      board;
    std::vector<Block>	    bronze;
    std::vector<Point>	    candidates;
    Point		    bronzeIndicator;
    WhichPlayer		    whichPlayer;
    Point		    boardVisualPoint;
    Rect		    rectangle;
    int			    fallingCount;
    int			    fallingDefaultCount;
};


#include "Board.hpp"



Board::Board(WhichPlayer _whichPlayer) :
    whichPlayer(_whichPlayer),
    BOARD_VISUAL_SIZE(Point(7, 13)),
    BOARD_ACTUAL_SIZE(Point(9, 15)),
    BOARD_POINT_1P(150, 100),
    BOARD_POINT_2P(850, 100),
    INIT_BRONZE_COORDINATE(3,0),
    BOARD_RECTANGLE_SIZE(280,520),
    BLOCK_SIZE(40),
    BRONZE_MAX_SIZE(5),
    RED_NUM(0),
    BLUE_NUM(1),
    GREEN_NUM(2),
    YELLOW_NUM(3),
    PURPLE_NUM(4),
    SELULIAN_NUM(5),
    WALL_NUM(6),
    NONE_NUM(7)
{
    init();
}


Board::~Board() {

}

void Board::init() {
    boardInit();
    bronzeInit();
}


void Board::update() {
    if (Input::Key1.clicked) {
	dropBronze();
    }
}

void Board::draw() const {
    rectangle.draw();
    boardDraw();
    bronzeDraw();
}

void Board::boardInit() {
    board.resize(BOARD_ACTUAL_SIZE.x);
    for (int i = 0; i < BOARD_ACTUAL_SIZE.x; i++) {
	board[i].resize(BOARD_ACTUAL_SIZE.y);
    }

    for (int i = 0; i < BOARD_ACTUAL_SIZE.x; i++) {
	for (int j = 0; j < BOARD_ACTUAL_SIZE.y; j++) {
	    board[i][j] = static_cast<BlockColor>(NONE_NUM);
	}
    }
    for (int i = 0; i < BOARD_ACTUAL_SIZE.x; i++) {
	board[i][0] = static_cast<BlockColor>(WALL_NUM);
	board[i][BOARD_ACTUAL_SIZE.y - 1] = static_cast<BlockColor>(WALL_NUM);
    }
    for (int i = 0; i < BOARD_ACTUAL_SIZE.y; i++) {
	board[0][i] = static_cast<BlockColor>(WALL_NUM);
	board[BOARD_ACTUAL_SIZE.x - 1][i] = static_cast<BlockColor>(WALL_NUM);
    }

    if (whichPlayer == WhichPlayer::PLAYER1) {
	boardVisualPoint = BOARD_POINT_1P;
    }
    else {
	boardVisualPoint = BOARD_POINT_2P;
    }
    rectangle = Rect(boardVisualPoint, BOARD_RECTANGLE_SIZE);
}
void Board::bronzeInit() {
    bronzeIndicator = INIT_BRONZE_COORDINATE;
    std::vector<Block>().swap(bronze);
}
void Board::bronzeDraw() const {
    for (unsigned int i = 0; i<bronze.size(); i++) {
	TextureAsset(L"Block")(BLOCK_SIZE*static_cast<int>(bronze[i].getBlockColor()), 0, BLOCK_SIZE, BLOCK_SIZE).draw(boardVisualPoint +BLOCK_SIZE*(bronzeIndicator+bronze[i].getPoint()));
    }
}
void Board::boardDraw() const {
    for (int i = 0; i < BOARD_VISUAL_SIZE.x; i++) {
	for (int j = 0; j < BOARD_VISUAL_SIZE.y; j++) {
	    if (static_cast<int>(board[i + 1][j + 1]) < 5) {
		TextureAsset(L"Block")(BLOCK_SIZE*static_cast<int>(board[i + 1][j + 1]), 0, BLOCK_SIZE, BLOCK_SIZE).draw(boardVisualPoint + Point(i*BLOCK_SIZE, j*BLOCK_SIZE));
	    }
	}
    }
}

void Board::addBlockToBronze(Point coordinate,BlockColor blockColor) {
    for (auto& x : bronze) {
	x.setPoint(x.getPoint() + Point(0, 1));
    }
    bronze.emplace_back(Block(blockColor,coordinate));
}

void Board::moveBronzeIndicator(int direction) {
    bronzeIndicator += Point(direction, 0);
}

void Board::dropBronze() {
    Point dropBaseCoordinate = Point(0,0);
    for (auto& x : bronze) {

    }
 //   while (board[bronzeIndicator.x+1][(dropBaseCoordinate + bronze.front().getPoint()).y + 1] == BlockColor::NONE) {
	//dropBaseCoordinate += Point(0, 1);
 //   }
    for (auto& x : bronze) {
	board[bronzeIndicator.x + 1][x.getPoint().y + dropBaseCoordinate.y + 1] = x.getBlockColor();
    }
    
    bronze[0];
    bronzeInit();
}

bool Board::isCanAddBlockToBronze() {
    if (bronze.size() < BRONZE_MAX_SIZE) {
	bool isCanBronzeAdd = true;
	for (auto& x : bronze) {
	    if (!isBronzeDontCollideWithBoard(x.getPoint() + bronzeIndicator + Point(0, 1))) {
		isCanBronzeAdd = false;
	    }
	}
	return isCanBronzeAdd;
    }
    return false;
}

bool Board::isCanMoveBronze(int direction) {
    int valid = bronzeIndicator.x + direction;
    if (valid >= 0 && valid < BOARD_VISUAL_SIZE.x) {
	bool isCanBronzeMove = true;
	for (auto& x : bronze) {
	    if (!isBronzeDontCollideWithBoard(x.getPoint()+bronzeIndicator+Point(direction,0))) {
		isCanBronzeMove = false;
	    }
	}
	return isCanBronzeMove;
    }
    return false;
}

bool Board::isBronzeDontCollideWithBoard(Point _coordinate) {
    if (board[_coordinate.x + 1][_coordinate.y + 1] == BlockColor::NONE) {
	return true;
    }
    else {
	return false;
    }
}
```

###試したこと
brozneをfor文やfor auto文で回した場合エラーはありませんでした。
添字アクセスまたは、front()などでアクセスしてしまうとエラーが発生しました。


よろしくお願いいたします。

std::vectorの添字がうまく機能しません

### 前提・実現したいこと

3Dモデルの表面座標を取得するプログラムをPythonで作りたいと考えています。
ポリゴンで構成されているSTLファイル上で、マウスでクリックした表面の座標を取得したいです。



### 発生している問題・エラーメッセージ
まずSTLファイルを読み込めない。
3次元の座標位置を取得するためのアルゴリズムがわからない。

### 該当のソースコード

ソースコード
import pyvista as pv

filename='ファイル名.stl'
mesh=pv.read(filename)  

pv.Plotter.pick_click_position(mesh) #クリック位置の取得

cpos=mesh.show()

### 試したこと
Pyvistaの関数でPlotter.pick_click_position()が使えると聞いて試したものの、多分使い方が間違ってる。(データプロット用？)
他にも関数を変えてみたりしましたが、自力で解決は叶いませんでした…。

### 補足情報（FW/ツールのバージョンなど）
[環境]
Windouws10
Python3.8
Anaconda

メッシュで構成された3Dモデルの座標位置を取得したい

C++ のイテレータは演算ができますが、例えば以下のようなコードを書くと、簡単に無限ループになってしまいます。

```cpp
#include <vector>
#include <iostream>

int main()
{
        std::vector<int> a = {1, 2, 3};
        for (auto it = a.begin(); it != a.end(); std::advance(it, 2)) {
                std::cout << *it << std::endl;
        }
        return 0;
}
```

原因は、イテレータ演算を安全に扱う方法が無いせいだと思うのですが、普通はどのように行うのでしょうか。
つまり、

1. イテレータが範囲外の位置を指しているかどうかを判定する方法が無い
2. イテレータが範囲外の位置を指さないように演算する方法が無い

ということが原因だと思うのですが、これらをイテレータの機能で解決する方法はありますか？
それとも、範囲外にならないようにプログラマーが気をつけてコーディングするしか回避方法がないのでしょうか。

安全にイテレータ演算をするには？

二次元のstd::vectorについて、
一次元目のサイズを宣言時に決定し、二次元目をループ内でresizeしようとしています。

- 従来のfor(;;)を用いた場合
- 範囲ベースfor(auto: )を用いた場合

どちらのループを用いても実質は変わらないと今まで考えていました。
しかし、下記のコードに書き込んでいるように、実際は結果が異なっています。

なぜこのような挙動の違いがあるのでしょうか？
範囲ベースfor文は従来のfor文を改良したものという解釈は誤っているのでしょうか？



```C++
#include <cstdlib>
#include <iostream>
#include <vector>

int main( int argc, char **argv ) {

    std::vector< std::vector< int > > vector1( 10 );
    std::vector< std::vector< int > > vector2( 10 );

    for( int i = 0; i < vector1.size(); i++ ) {
        vector1[ i ].resize( 10, 0 );
    }
    for( auto vec : vector2 ) {
        vec.resize( 10, 0 );
    }

    std::cout << vector1[ 0 ].size() << std::endl;    // Output: 10
    std::cout << vector2[ 0 ].size() << std::endl;    // Output:  0

    system( "PAUSE" );
    return EXIT_SUCCESS;
}
```

なお、私の実行環境は以下の通りです。
- Windows 10 64bit
- Visual Studio Community 2015

C++11の範囲ベースfor文と従来のfor文の挙動の違いについて

ヘッダーファイルで困りました。
C++のSTL　vector, algorithm をインクルードするとエラーがでます。
どうやったら、このエラーは回避できるのでしょうか？

https://dxlib.xsrv.jp/index.html
ここのライブラリを使っています。
DxLib_android 版です。


```C++
#pragma once

using namespace std;
//#include <vector>		//	ここの２つ（片方でも）をインクルードすると
//#include <algorithm>	//	グローバルスコープにat_quick_exit,quick_exitがありません
						//	とエラーがでる

#include <stdio.h>
#include <math.h>


#define		DEF_STAGE1_INIT		100
#define		DEF_STAGE1_MAIN		110
#define		DEF_STAGE1_CLEAR	120
#define		DEF_PLAYER_SIZE		64


int		Stage1MainLoop();
int		Stage1Init();
int		Stage1Clear();

```


[環境]
統合開発環境：Visual Studio 2019 Community
使用ライブラリ：DxLib_android  STL
言語：C/C++


グローバルスコープにat_quick_exit,quick_exitがありません  とエラーがでる

### 前提・実現したいこと

vectorの`data()`メソッドで得た配列を関数に渡し、関数の中で配列に値を挿入したいです。

### 発生している問題

値は挿入されるようですが、`size()`メソッドで要素数を取得すると 0 のままとなっています。
ポインタ経由で値を更新した場合は、別途要素数を更新する必要があるのでしょうか。
その場合、どのように実施すればよいでしょうか。


### 該当のソースコード

```cpp
#include <iostream>
#include <vector>
using namespace std;

void insert(int* dst, int size) {
    for (int i = 0; i < size; i++) {
        dst[i] = i;
        cout << "dst " << i << " = " << dst[i] << endl;
    }
}

int main()
{
    std::vector<int> my_vector;
    my_vector.reserve(10);

    insert(my_vector.data(), 10);

    cout << "size = " << my_vector.size() << endl;
    for (int i = 0; i < 10; i++) {
        cout << "element " << i << " = " << my_vector[i] << endl;
    }
    return 0;    
}
```

```console
// 出力結果
dst 0 = 0
dst 1 = 1
dst 2 = 2
dst 3 = 3
dst 4 = 4
dst 5 = 5
dst 6 = 6
dst 7 = 7
dst 8 = 8
dst 9 = 9
size = 0
element 0 = 0
element 1 = 1
element 2 = 2
element 3 = 3
element 4 = 4
element 5 = 5
element 6 = 6
element 7 = 7
element 8 = 8
element 9 = 9
```

### 補足情報（FW/ツールのバージョンなど）

・Visual Studio 2019
・Windows 10 64bit