常連

### 概要
・PC(USB)⇔相手機器(RS485)という形式で接続しシリアル通信を行っています
・PCからコマンドを送信すると相手機器はそれに反応し、結果をPC側に送信する仕様となります
・コマンドによって送信データのサイズは変動し、受信するデータのサイズもそれに合わせて変動します
・boost::asio::write関数で同期送信し、boost::asio::async_read関数で非同期受信をします
・現状のコードだとwriteによる送信で相手機器に反応はありますが、async_readのコールバック関数が呼ばれません

### 該当のソースコード

```C++
#include <iostream>
#include <iomanip>
#include <boost/thread/thread.hpp>
#include <boost/asio.hpp>

class CommSample
{
public:
    CommSample(const std::string& portname);
    ~CommSample();
    void test();
private:
    boost::thread _thread;
    unsigned char _receive_data[64];
    boost::asio::io_service _io;
    boost::asio::serial_port _port;
    void handler(const boost::system::error_code&, size_t);
};
CommSample::CommSample(const std::string& portname) : _io(), _port(_io)
{
        _port.open(portname);
        _port.set_option(boost::asio::serial_port_base::baud_rate(19200));
        _port.set_option(boost::asio::serial_port_base::character_size(8));
        _port.set_option(boost::asio::serial_port_base::flow_control(boost::asio::serial_port_base::flow_control::none));
        _port.set_option(boost::asio::serial_port_base::parity(boost::asio::serial_port_base::parity::none));
        _port.set_option(boost::asio::serial_port_base::stop_bits(boost::asio::serial_port_base::stop_bits::one));
        boost::asio::io_service::work w(_io);
        boost::thread t(boost::bind(&boost::asio::io_service::run, &_io));
        _thread = boost::move(t);
}
CommSample::~CommSample()
{
    _io.stop();
    _thread.join();
}
void CommSample::test()
{
    constexpr int receive_size = 8;
    unsigned char send_data[6]{0x01, 0x02, 0x03, 0x04, 0x05, 0x06};
    boost::asio::async_read(_port,
                            boost::asio::buffer(_receive_data),
                            boost::asio::transfer_exactly(receive_size),
                            boost::bind(&CommSample::handler,
                            this,
                            boost::asio::placeholders::error,
                            boost::asio::placeholders::bytes_transferred));
    boost::asio::write(_port, boost::asio::buffer(send_data));
}
void CommSample::handler(const boost::system::error_code& error, size_t bytes_transferred)
{
    for (size_t i = 0; i < bytes_transferred; i++)
    {
        std::cout << std::uppercase << std::setfill('0') << std::hex << std::setw(2) << (int)_receive_data[i];
    }
}
int main()
{
    CommSample a("COM3");
    while (true)
    {
        char c = getchar();
        if (c == 'q')break;
        if (c == 'a')a.test();
    }
    return 0;
}
```

### 試したこと
ネットで調べますとio_service::run関数は処理するものがないと終了するそうで
見様見真似ですがboost::asio::io_service::work w(_io);というものをスレッド作成前に呼んでいます
しかしio_service::stopped()関数はコンストラクタを呼んだ直後には既にtrueを返してしまいます

async_readではなく
read(_port,boost::asio::buffer(_receive_data),boost::asio::transfer_exactly(receive_size));
の同期関数に変更すると受信したいデータがちゃんと_receive_dataに格納されています
write関数の後にこれは書きました

どこを修正したら良いでしょうか？
write関数は今回の目的が実現できるのであればasync_write関数に変更可能です

C++ boost::asioを利用したシリアル通信で非同期受信(async_read)をしたい

boost::asioを用いたSSLによるhttp通信＆プロキシサーバの使用について、質問です。

**1. 番号リスト開発環境**
VS2017 15.4.4
boost-vc141 1.65.1
openssl-vc140-static-64

---
**2. 現状の問題点**
プロキシサーバへ接続する（handshake）ところで、「Handshake failed: asio.ssl.stream:1」というエラーが出てしまいます。
エラーコード:1はaddress_family_not_supported = EAFNOSUPPORTに該当するのですが、どこが間違っているか分かりません。。
もしかして、ipv6設定になってしまっているのでしょうか？

---
**3. 該当ソースコード**
```
#include <boost/asio.hpp>
#include <boost/asio/ssl.hpp>
#include <iostream>
#include <sstream>

namespace asio = boost::asio;
namespace ip = asio::ip;
using namespace std;

int main( int argc, char* argv[] )
{
	try {
		asio::io_service io_service;
		asio::ssl::context context( io_service, asio::ssl::context::sslv23 );
		asio::ssl::stream<ip::tcp::socket> ssl_sock( io_service, context );

		//ip::address ipaddr( ip::address_v4::from_string( "43.255.22.186" ) );
		//cout << ipaddr.to_string() << endl;
		//ip::tcp::endpoint endpoint( ipaddr, atoi( "8080" ) );

		ip::tcp::resolver resolver( io_service );
		ip::tcp::resolver::query query( "43.255.22.186", "8080" );
		ip::tcp::endpoint endpoint( *resolver.resolve( query ) );

		boost::system::error_code err = boost::asio::error::host_not_found;
		ssl_sock.lowest_layer().connect( endpoint, err );

		if( !err ){
			ssl_sock.handshake( asio::ssl::stream_base::client, err );

			if( !err ){
				//	connect
				{
					stringstream ss_proxy;
					ss_proxy << "CONNECT xxxx.com:443 HTTP/1.0\r\n\r\n";

					asio::streambuf req;
					ostream req_ostream( &req );
					req_ostream << ss_proxy.str();
					asio::write( ssl_sock, req );

					asio::streambuf res;
					asio::read_until( ssl_sock, res, "\r\n" );
					cout << &res << endl;
				}
				//	send & recv
				{
					stringstream ss_msg;
					ss_msg << "GET /xxx HTTP/1.0\r\n";
					ss_msg << "Host: xxxx.com \r\n";
					ss_msg << "\r\n";

					asio::streambuf req;
					ostream req_ostream( &req );
					req_ostream << ss_msg.str();
					asio::write( ssl_sock, req );

					asio::streambuf res;
					asio::read_until( ssl_sock, res, "\r\n" );
					cout << &res << endl;
				}
			}
			else {
				boost::system::error_code code = err;
				boost::system::system_error e( err );
				long lastResult = code.value();
				string errorString = e.what();
				ssl_sock.lowest_layer().close();
				cout << "Handshake failed: " << err << endl;
			}
		}
		else {
			boost::system::error_code code = err;
			boost::system::system_error e( err );
			long lastResult = code.value();
			string errorString = e.what();
			ssl_sock.lowest_layer().close();
			cout << "Connect failed: " << err << endl;
		}
	}
	catch( std::exception& e ){
		cout << endl << "[EXCEPTION] " << e.what() << endl;
	}

	return 0;
}

```
---
**4. 該当ソースコード（修正版）**
解決時の修正版コードです。
```
#include <boost/asio.hpp>
#include <boost/asio/ssl.hpp>
#include <iostream>
#include <sstream>

namespace asio = boost::asio;
namespace ip = asio::ip;
using namespace std;

int main( int argc, char* argv[] )
{
	try {
		//	error code
		boost::system::error_code err = boost::asio::error::host_not_found;

		//	sock
		asio::io_service io_service;
		ip::tcp::socket sock( io_service );

		//	proxy
		ip::tcp::resolver resolver( io_service );
		ip::tcp::resolver::query query( "43.255.22.186", "8080" );
		ip::tcp::endpoint endpoint( *resolver.resolve( query ) );

		//	connect
		sock.connect( endpoint, err );
		if( err ){
			boost::system::error_code code = err;
			boost::system::system_error e( err );
			long lastResult = code.value();
			string errorString = e.what();
			sock.close();
			cout << "connect failed: " << errorString << "(" << err << ")" << endl;
		}

		//	send & recv
		{
			stringstream ss_proxy;
			ss_proxy << "CONNECT xxxx.com:443 HTTP/1.0\r\n\r\n";

			asio::streambuf req;
			ostream req_ostream( &req );
			req_ostream << ss_proxy.str();
			asio::write( sock, req );

			asio::streambuf res;
			asio::read_until( sock, res, "\r\n" );

			istream is_res( &res );
			string http_version;
			unsigned int status_code;
			string status_message;

			is_res >> http_version;
			is_res >> status_code;
			getline( is_res, status_message );

			cout << "http_version: " << http_version << endl;
			cout << "status_code: " << status_code << endl;
			cout << "status_message: " << status_message << endl;
		}
		
		//	SSL sock
		asio::ssl::context context( io_service, asio::ssl::context::sslv23 );
		asio::ssl::stream<ip::tcp::socket> ssl_sock( io_service, context );

		//	move from sock to SSL sock
		ssl_sock.next_layer() = std::mode( sock );
	
		//	handshake
		ssl_sock.handshake( asio::ssl::stream_base::client, err );

		if( err ){
			boost::system::error_code code = err;
			boost::system::system_error e( err );
			long lastResult = code.value();
			string errorString = e.what();
			ssl_sock.lowest_layer().close();
			cout << "handshake failed: " << errorString << "(" << err << ")" << endl;
		}

		//	send & recv
		{
			stringstream ss_msg;
			ss_msg << "GET /xxx HTTP/1.0\r\n";
			ss_msg << "Host: xxxx.com \r\n";
			ss_msg << "\r\n";

			asio::streambuf req;
			ostream req_ostream( &req );
			req_ostream << ss_msg.str();
			asio::write( ssl_sock, req );

			asio::streambuf res;
			asio::read_until( ssl_sock, res, "\r\n" );
			cout << &res << endl;
		}
	}
	catch( std::exception& e ){
		cout << endl << "[exception] " << e.what() << endl;
	}

	return 0;
}
```

C++でHTTPS通信＆プロキシサーバの使用について

### 前提・実現したいこと
```
<faces>
  <face id='0'>
    <bounds x='41' y='49' width='426' height='426'/>
    <right-eye x='161' y='208'/>
    <left-eye x='336' y='208'/>
    <features s-avg='0.76' s-min='0.40' s-max='0.93'>
      <point id='PR' x='167' y='204' s='0.86'/>
      <point id='PL' x='334' y='207' s='0.77'/>
      <point id='BR2' x='222' y='151' s='0.40'/>
      </features>
  </face>
</faces>
このようなxmlファイルのidとxの値とyの値をコマンドプロンプトに表示したいと思っています.
visual studioのc++で行っています.
```
### 発生している問題・エラーメッセージ

```

ビルドは出来るのですが,デバッグをすると

ハンドルされない例外が 0x00007FFDACAAF218 で発生しました (RBF.exe 内): Microsoft C++ の例外: boost::exception_detail::clone_impl<boost::exception_detail::error_info_injector<boost::property_tree::ptree_bad_path> > (メモリの場所 0x00000053470FF268)。

と表示されてしまいます.


```

### 該当のソースコード

```c++
struct Book {
	std::string id;
	std::string x;

	Book() {}

	Book(const Book& other)
		: id(other.id), x(other.x) {}

	Book(const std::string& id, const std::string& x)
		: id(id), x(x) {}

	void print() const
	{
		std::cout << id << "," << x << std::endl;
	}
};


void load(const std::string& filename)
{
	using boost::property_tree::ptree;

	std::vector<Book> books;

	ptree pt;
	read_xml(filename, pt);

	foreach(const ptree::value_type& child_, pt.get_child("faces.face.features")) {
		const ptree& child = child_.second;
		const std::string id = child.get<std::string>("<xmlattr>.id");
		const std::string x = child.get<std::string>("<xmlattr>.x");

		books.push_back(Book(id, x));
	}

	std::for_each(books.begin(), books.end(), boost::mem_fn(&Book::print));
}
int main(int argc, char *argv[])
{
    load("parts.xml");
	return 0;
	
}
```

### 試したこと

xmlファイルの名前が間違ったりしてないか何度も確認したり,xだけboost::optional<int>型にしてみたりしましたが上手くいきません.
xmlを扱うこと自体初めてで,c++も初心者なのでかみ砕いて教えていただけるとありがたいです.
printfでどこまで通っているか試したところ,void loadの
const ptree& child = child_.second;までは通っているので
const std::string id = child.get<std::string>("<xmlattr>.id")
に問題があるようです.
よろしくお願いします.

属性付きxmlの値を取得したいc++

###**前提・実現したいこと**

　非同期で送信されるデータを，連続で受け取るプログラムの構築を目指しています．
具体的には「スレッドでデータ待機する→受け取る→表示する→データ待機する・・・」という処理を実現したいと考えています．
　またMain関数からはAsioのライブラリが見えないように構築したいと考えています．
###**現状**
BoostライブラリのAsioを用いて構築したコードを確認するために，送信したデータを表示して終了するプログラムを構築しました．（参考：https://boostjp.github.io/tips/network/tcp.html）
###**発生している問題・エラーメッセージ**
実行すると以下のエラーメッセージが表示されます．（IPReceiveData.cppのOnReceive関数）
```
receive failed: 供給されたファイルハンドルが無効です．
```
###**受信ソース**
###IPReceiveData.h
```c++
#ifndef __IPConnect_h__
#define __IPConnect_h__


enum TransportProtocol {
	TP_TCP = 1,
	TP_UDP = 0,
};

class IPReceive {
public:
	// TCPかUDPか選択（最初に選択することで，ＴＣＰＵＤＰ区別なく初期化・通信の関数を使える）
	IPReceive(TransportProtocol isTcp);
	~IPReceive();

	void iprInitialize();

	void iprReceiveMSG();

	char* GetLastData();

private:
	class IPReceive_impl* ipr_impl;
};

#endif
```
###IPReceiveData.cpp
```C++
#define BOOST_COROUTINES_NO_DEPRECATION_WARNING	
#define PIMP(x) ipr_impl->x

#include <iostream>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/asio/spawn.hpp>
#include "IPReceiveData.h"

namespace asio = boost::asio;
using asio::ip::tcp;
using asio::ip::udp;
using std::cout;
using std::endl;
using std::string;


// Pimplクラス
class IPReceive_impl {
private:
	tcp::acceptor	acceptor;
	tcp::socket	  socketTCP;
	//udp::socket	  socketUDP;
	//asio::strand	 strand;
	asio::streambuf  receive_buff_;



	// 接続が完了したか（async_accept用で、引数は固定）
	void OnAccept(const boost::system::error_code& error)
	{
		if (error) 
			cout <<  "connect failed : " + error.message() << endl;
		else
			cout << "Success connection." << endl;
	}


    // 受信が成功したか（async_read用で，引数は固定）
	void OnReceive(const boost::system::error_code& error, size_t bytes_transferred)
	{
		if (error && error != asio::error::eof) 
			cout << "receive failed: " << error.message() << endl;
		else {
			// 受信したデータをchar*に変換
			const char* data = asio::buffer_cast<const char*>(receive_buff_.data());
			lastData = const_cast<char*>(data);

			receive_buff_.consume(receive_buff_.size());
		}
	}


public:
	asio::io_service&	ioService;
	const bool		   isTCP;
	string			   receiveData;
	char*				lastData;


	// TCPとUDPを指定して初期化するコンストラクタ
	IPReceive_impl(asio::io_service& ioService, TransportProtocol isTcp)
		:	ioService	(ioService),
			acceptor	  (ioService, tcp::endpoint(tcp::v4(), 31400)),
			socketTCP	 (ioService),
			strand		(ioService),
			socketUDP	 (ioService),
			isTCP		 (isTcp) {}


	// デストラクタ
	~IPReceive_impl() {}


	// 指定IP，ポートでTCP接続
	void ConnectTCP(char *ipAddress, char *portNum)
	{
		// 接続後に呼ばれるコールバック関数を指定
		auto cbOnAccept(boost::bind(&IPReceive_impl::OnAccept, this, asio::placeholders::error));	

		// TCPソケットと上記で宣言したとコールバック関数を登録する
		acceptor.async_accept(socketTCP, cbOnAccept);
	}
	// 指定IP，ポートでUDP接続
	void ConnectUDP(char *ipAddress, char *portNum) {
	}



	// メッセージ送信
	void ReceiveTCP()
	{
		// 受信後に呼ばれるコールバック関数を指定
		auto cbOnReceive(
			boost::bind(&IPReceive_impl::OnReceive, this,
				asio::placeholders::error,
				asio::placeholders::bytes_transferred));	

		// データを受信する
		asio::async_read(
			socketTCP,
			receive_buff_,
			asio::transfer_all(),
			cbOnReceive);
	}
};



// IP通信の初期化を行う
IPReceive::IPReceive(TransportProtocol isTcp) {
	auto ioService = new asio::io_service;
	ipr_impl = new IPReceive_impl(*ioService, isTcp);
}

IPReceive::~IPReceive() {
	cout << "Finish" << endl;
	delete ipr_impl;
}


// TCP通信の初期化
void IPReceive::iprInitialize() {
	if (ipr_impl->isTCP)
		PIMP(ConnectTCP(ipAddress, portNum));
	else
		PIMP(ConnectUDP(ipAddress, portNum));
}

void IPReceive::iprReceiveMSG() {
	if (PIMP(isTCP)) {
		PIMP(ReceiveTCP());
		PIMP(ioService.run());
	}
}

char* IPReceive::GetLastData(){
	return PIMP(lastData);
}
```
###Main.cpp
```C++
#include "IPReceiveData.h"
#define __test__
#include <string>
#include <iostream>
int main() {
	// TCPで初期化
	IPReceive ipSending(TP_TCP);


	ipSending.iprInitialize();

	ipSending.iprReceiveMSG();


	std::cout << ipSending.GetLastData() << std::endl;
	return 0;
}
```

###試したこと
参考URLのようにReceiveTCP()をOnConnect()内で呼び出すと問題なく動作するのですが，今後連続でデータ待機を行う場合に毎回Connectを行う必要が出てくるので可能であればOnConnectからReceiveTCPを呼び出す方法は避けたいと考えています．

###補足情報(言語/FW/ツール等のバージョンなど)
Visual Studio 2017
Boost 1.65.1

###**追記**
###**受信ソース（修正箇所）**
```C++
	// 接続が完了したか（async_accept用で、引数は固定）
	void OnAccept(const boost::system::error_code& error)
	{
		if (error)
			cout << "connect failed : " + error.message() << endl;
		else
			cout << "Success connection." << endl;

//-----編集箇所--------------------------
		ReceiveTCP();
//-----編集箇所--------------------------
	}


	// 受信が成功したか（async_read用で，引数は固定）
	void OnReceive(const boost::system::error_code& error, size_t bytes_transferred)
	{
		if (error && error != asio::error::eof)
			cout << "receive failed: " << error.message() << endl;
		else {
			// 受信したデータをchar*に変換
			const char* data = asio::buffer_cast<const char*>(receive_buff_.data());
			lastData = const_cast<char*>(data);
			cout << lastData << endl;

			receive_buff_.consume(receive_buff_.size());

//-----編集箇所--------------------------
			if (lastData[0] != 'e') {
				cout << "endしないよ：" << lastData << endl;
				ReceiveTCP();
			}
			else			
				cout << "endするよ" << endl;
//-----編集箇所--------------------------
		}
	}
```
###**送信ソース**

参考URLのソースから，他ソースコードから送信したい文字列を指定できるように変更した．
###IPSendData.h
```C++
#ifndef __IPConnect_h__
#define __IPConnect_h__


enum TransportProtocol {
	TP_TCP = 1,
	TP_UDP = 0,
};

class IPSending {
public:
	// TCPかUDPか選択（最初に選択すれば、初期化やメッセージ送信ではＴＣＰＵＤＰ区別なく関数を使える）
	IPSending(TransportProtocol isTcp);
	~IPSending();

	void ipsInitialize(char* ipAddress, char *portNum);

	void ipsSendMSG(char* msg);

private:
	class IPSend_impl* ips_impl;
};

#endif
```
###IPSendData.cpp
```C++

#define BOOST_COROUTINES_NO_DEPRECATION_WARNING	// asioはcoroutine2をサポートしていないので警告を消す
#define PIMP(x) ips_impl->x

#include <iostream>
#include <memory>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/asio/spawn.hpp>
#include "IPSendData.h"

namespace asio = boost::asio;
using asio::ip::tcp;
using asio::ip::udp;
using std::cout;
using std::endl;
using std::string;
using std::shared_ptr;



class IPSend_impl {
private:
	tcp::socket	socketTCP;	// TCP
	udp::socket	socketUDP;    // UDP
	udp::resolver  resolver;     // UDP
	asio::strand   strand;	   // spawn
	udp::endpoint  receiver_endpoint;
	string         sendData;     // SendTCPでしか使わないが、使用する前にスコープ外へ出て消えてしまうので外


	// 接続が完了したか（async_connect用で、引数は固定）
	void OnConnect(const boost::system::error_code& error)
	{
		if (error)
			throw "connect failed : " + error.message();
		else
			cout << "connect correct!" << endl;
	}

	void OnSend(const boost::system::error_code& error, size_t bytes_transferred)
	{
		if (error) 
			throw "send failed: " + error.message();
		else 
			cout << "send correct!" << endl;	
	}


public:
	asio::io_service&	ioService;
	const bool		   isTCP;


	// TCPとUDPを指定して初期化するコンストラクタ
	IPSend_impl(asio::io_service& ioService, TransportProtocol isTcp)
		:	ioService (ioService),
		 	resolver  (ioService),
		 	strand    (ioService),
		 	socketTCP (ioService),
		 	socketUDP (ioService),
		 	isTCP     (isTcp){}

	// デストラクタ
	~IPSend_impl() {
	}


	// TCPの接続要求を行う
	void ConnectTCP(char *ipAddress, char *portNum) {
		// 接続するIPとポート番号を設定する
		auto address(	
			tcp::endpoint(
				asio::ip::address::from_string(ipAddress), atoi(portNum)));	
		
		// 接続時に実行するコールバック関数を設定する
		auto cbOnConnect(
			boost::bind(&IPSend_impl::OnConnect, this,
				asio::placeholders::error));

		// 上記で宣言したアドレスとコールバック関数を登録する
		socketTCP.async_connect(address, cbOnConnect);
	}

	// UDPの接続要求を行う
	void ConnectUDP(char *ipAddress, char *portNum) {
		auto query(udp::resolver::query(udp::v4(), ipAddress, portNum));
		receiver_endpoint = *resolver.resolve(query);

		socketUDP.open(udp::v4());
	}


	// TCPでメッセージを送信
	void SendTCP(char *msg)
	{
		sendData = msg;

		// 接続後に呼ばれる関数（今回は成否出力）
		auto cbOnSend(	
			boost::bind(&IPSend_impl::OnSend, this,	
				asio::placeholders::error,
				asio::placeholders::bytes_transferred));


		// ソケット、上記で宣言した送信データとコールバック関数を登録する
		asio::async_write(
			socketTCP,
			asio::buffer(sendData),
			cbOnSend);
	}


	// メッセージ送信
	void SendUDP(char *msg){
	}
};



// IP通信の初期化を行う
IPSending::IPSending(TransportProtocol isTcp) {
	auto ioService = new asio::io_service;
	ips_impl = new IPSend_impl(*ioService, isTcp);
}

IPSending::~IPSending() {
	delete ips_impl;
	cout << "Finalize IPSending." << endl;
}


// TCP通信の初期化
void IPSending::ipsInitialize(char *ipAddress, char *portNum) {
	if (ips_impl->isTCP)
		PIMP(ConnectTCP(ipAddress, portNum));
	else
		PIMP(ConnectUDP(ipAddress, portNum));
}

void IPSending::ipsSendMSG(char *msg) {
	if (PIMP(isTCP)) {
		PIMP(SendTCP(msg));
		PIMP(ioService.run());
	}
	else
		PIMP(SendUDP(msg));
}
```
###Main.cpp
```C++
#include <iostream>
#include "IPSendData.h"
#define __test__

int main() {
	char test[30];

	IPSending ipSending(TP_TCP);

	ipSending.ipsInitialize("127.0.0.1", "31400");

	while (true) {
		std::cout << "文字を入力してください：";
		scanf_s(aaa, 10);

		ipSending.ipsSendMSG(aaa);

		if (aaa[0] == 'e')
			break;
	}

	return 0;
}
```
実行結果
それぞれ1文字ずつ[a, b, c, d, e]と送信した場合
![イメージ説明](addcdf1c58916b195e3101ccd2141703.png)

BoostライブラリのAsioで非同期通信を構築し，連続でデータの受け取りを行いたい

こんにちは。Boost.Pythonを用いてC++で.pydファイルを作り、それをPythonの本スレッドとは別のスレッドで平行して起動することを試みています。ところが、C++で作った関数をスレッドで呼び出すと、他のスレッドが停止してしまいます。

pythonのコードです。このコードでは関数thread1, thread2を同時に実行することを試みています。関数Outer.InfLoopは延々と"out"を表示するものです。
```Python
import Outer

def thread1():      #1秒おきに0から4まで表示するスレッド
    for i in range(5):
        print(i)
        time.sleep(1)


def thread2():      #外部プログラムを実行するスレッド
    Outer.InfLoop() #1秒おきに5回"out"と表示する関数(C++で作られた)


th1 = threading.Thread(target=thread1)
th2 = threading.Thread(target=thread2)
th1.start()
th2.start()
```
C++のコードです。これをビルドしてOuter.pydができます。OuterをimportすることでPython上で関数Outer.InfLoop()を呼び出すことができます。
```C++
#include <boost/python/numpy.hpp>
namespace p = boost::python;

void InfLoop(){        //1秒おきに5回"out"と表示する関数
	for (int i = 0; i < 5; i++) {
		cout << "out" << endl;
		Sleep(1000);
	}
	return;
}

BOOST_PYTHON_MODULE(Outer) {
	Py_Initialize();
	p::def("InfLoop", InfLoop);      //関数InfLoopはPython上で"Outer.InfLoop()"で呼び出すことができる。
}
```

Pythonコードを実行すると、thread1とthread2は同時に実行されるはずですから、iと"out"が交互に表示されることが期待されます。しかし、実際には最初に0が表示された後outが５回続いてから数字が続きます。つまり、thread2が実行されている間thread1は停止していることになります。原因がわからず困っています。よろしくお願いします。
|期待|実際|
|:--|:--:|
|0|0|
|out|out|
|1|out|
|out|out|
|2|out|
|out|out|
|3|1|
|out|2|
|4|3|
|out|4|

Pythonのマルチスレッドで外部プログラムを呼び出しながら並列処理する方法を教えてください。

提示のコンソールですがErrorが出るのでcmakeにパスを通す必要があるのですがcmake Error部ように参考サイトを参考にやってもエラーになってしまいます。これはどうやってパスを通すのでしょうか？

参考サイト：　https://copyprogramming.com/howto/cmake-could-t-find-boost

##### Google 翻訳
```
あなたはそれを正しい方法でやっていると確信していますか？アイデアは、CMake が 自動的 BOOST_INCLUDE_DIR  に ,  BOOST_LIBRARYDIR  を 設定するというものです。 BOOST_ROOT で次のようにし  CMakeLists.txt  ます。
```


##### cmake Error
```
shigurechan@shigurechan-System-Product-Name:~/ダウンロード/LspCpp/_build$ SET(CMAKE_PATH ${CMAKE_INCLUDE_PATH} "/usr/lib/x86_64-linux-gnu/cmake/Boost-1.74.0")
bash: 予期しないトークン `CMAKE_PATH' 周辺に構文エラーがあります
```



##### Error
```
Could NOT find Boost: missing: date_time chrono filesystem system thread program_options (found /usr/lib/x86_64-linux-gnu/cmake/Boost-1.74.0/BoostConfig.cmake (found version "1.74.0"))
CMake Error at CMakeLists.txt:183 (message):
  Can't find boost,please build boost and install it.  or install boost with
  : sudo apt-get install libboost-dev
```
##### コンソール
```
shigurechan@shigurechan-System-Product-Name:~/ダウンロード/LspCpp/_build$ cmake ..
-- Configure compiler
Using GNU
C++ Flags:  -std=c++11 -Wall -Werror -Wno-parentheses link flags: 
Configuring documentation
-- Could NOT find Boost: missing: date_time chrono filesystem system thread program_options (found /usr/lib/x86_64-linux-gnu/cmake/Boost-1.74.0/BoostConfig.cmake (found version "1.74.0"))
CMake Error at CMakeLists.txt:183 (message):
  Can't find boost,please build boost and install it.  or install boost with
  : sudo apt-get install libboost-dev


-- Configuring incomplete, errors occurred!
See also "/home/shigurechan/ダウンロード/LspCpp/_build/CMakeFiles/CMakeOutput.log".
shigurechan@shigurechan-System-Product-Name:~/ダウンロード/LspCpp/_build$ 

```

cmakeにパスを追加する方法

現在visual studioのx86で動くC++のプログラムを作ってまして、最終的にはこれをBoostなどでラップしてpythonで読み込みたいと考えております。
ですがpythonは64bitを使っているのでもしかしたら読み込むことができないのではないかと気づきました。
C++とpythonの関係には疎いのでラップをして読み込むことが可能であるかご教示お願いします。

現在の状況
・使用しているC++用のDLLが32bit限定であるのでx64でコンパイルすることができません
・pythonはCUDAの関係で32bit版を使用することができません
・ラップはBoostで行こうかなと考えておりました

Python(64bit版)でC++(x86)のプログラムを読み込みたい

### 質問
cpp boostのbootstrap.batの実行が完了しない。
### 環境
winsows11
developer command prompt for VS2019
### 詳細
私はcppでboostライブラリを使おうと思い、以下のサイトからboostをダウンロードしました。
https://www.boost.org/users/history/version_1_79_0.html
様々なサイトを参考にboostの導入過程を見ると、まず最初にbootstrapを実行しb2.exeを作成する必要があるようです。
そこでダウンロードしたディレクトリへ移動し、bootstrapを実行したのですが、以下のエラーがでて完了できません。
```エラー
Building Boost.Build engine
'.\build.bat' は、内部コマンドまたは外部コマンド、
操作可能なプログラムまたはバッチ ファイルとして認識されていません。

Failed to build Boost.Build engine.
```
build.batが認識されていないと出ているのですが、これの実体がわからず、様々なパスが通っているDeveloper CMD上でなぜ実行できていないのかがわからないです。
### 教えてほしいこと
build.batの実体とこのエラーの具体的な解決法を教えていただけないでしょうか？
初歩的なことで申し訳ございません。どうぞよろしくお願いいたします。

### 追記
ビルドツールに触れていた以下のサイトを参考にVSを再インストールしてみました。
（2019→2022のアップグレードも兼ねて。）
https://www.kkaneko.jp/db/man.html#vs2022inst
チェックボックスも見逃さずチェックしています。
管理者権限での実行も忘れずに行っています。

解決するのではと期待したのですが、残念ながら解決しませんでした。
build.batとはなんなのか。



