C++相談室 part159 ->画像>1枚

前スレ
C++相談室 part158
http://2chb.net/r/tech/1636969758/

C（チンチン）+（プラ）+（プラ）

アセンブリとかC言語だと「この操作はするな」ってのを簡単には禁止できないからね

許可されてる(コンパイラから怒られない)操作が増えるとその分だけ不正解のコードを書くリスクが高くなる

structのこのフィールドは排他制御してから変更してねってのをC言語じゃ簡単には強制できんだろ
C++ならgetter作ればいいだけなのに

>>1乙
>>1000は宣言に従うこと

>>3
それぐらいはC程度の高水準言語であればｷﾞﾘ保証できる
クラスFooに対するgetterやsetterを経由しないアクセスを
Fooの構造体メンバ名を変えたときビルドエラーとして確実にあぶりだせる
ように書くことはFooを書く人の一存で一応できる

カプセル化が簡単にできるというのと、
　オブジェクトC := オブジェクトA + オブジェクトB
　オブジェクトE = オブジェクトC * オブジェクトD
　...
ここで:=は生成、+や*はなんらかのメッセージ（メソッド）
このようにオブジェクトからオブジェクトを作る、的な、
基本単位がオブジェクトなプログラミング環境が維持されないのは
オブジェクト指向プログラミングしているうちに入らないと
思うんですよねー（棒

format.hを待ってますた

>>3
でもそのC++からCを見て不正解のコードを書くリスクが高くなるという話がそのまま
RustからC++を見た場合も当てはまってしまうよな
Rustコンパイラならメモリ安全やデータ競合に問題がある操作をエラーで拒否するのにC++はなぜ許して致命的バグを生み出してしまうのだろう、と

無関係過ぎる
元はアセンブラ必須という人が書き込みがあったので、C++のコンパイラ(gcc)がSIMDを吐く条件についての話をしたんだが・・・
それについては正解できる人や惜しい人すら皆無で、馬鹿がC++全然関係ないOOの話を引っ張ってきて、今じゃC++と無縁な宇宙の話になっている

自分でこんなレスしといて今更何言ってるんだかw
> 組み込み機器用のCPUって特殊なんで、コンパイラが安定しないなんてよくある話
> オブジェクト指向のメリットの本質についての話なので、可能/不可能が実装言語に依存しないというのもよくある話(楽かどうかは別)
> 別に昭和でも平成でも令和でも変わってないけど、>> 991に伝わってないのは確か

馬鹿がID変えてまた登場

明示的にはSSEコンパイラ組み込み関数を使えば実現できるけど、多くのコンパイラはシングルレーンのループの一部を自動的にベクトル化してくれるのね

コンパイラが暗黙的なベクトル化をしてくれる条件ってシングルレーン以外に何があるんだろ

>>10
顔真っ赤じゃんw

その問題はもう答え書いた

恥の上塗りかよw
答えを書いたとか関係ないだろ
> 馬鹿がC++全然関係ないOOの話を引っ張ってきて
に乗っといて何言ってるんだよ

可哀想な馬鹿が勘違いしてるみたいだからちゃんと書いておくと、>>13は>>11へのレスな

人をバカにしても恥ずかしいレスは消えないよw

>>7
実際そうだよ
生のポインタを使ってる限りはどこに所有権があるか自分で管理するしかない

Rustの考え方はC++使いからすれば羨ましいわ

けんかをやめて ふたりを止めて
わたしのために 争わないで

きみC#さんだよね

>>17
だからスマポで出来るやん、それ
てか欧米産の大手ゲームの解析なんかしてると普通に向こうもスパゲッティコードだらけだけどな
なんだかんだで力技ゴリ押し開発になっちゃうんだよ結局

ゲームはハード性能をゴリゴリに引き出すのが正義だからスマポ程度のオーバーヘッドでも許容できないんよ

>>21
いや俺もゲーム開発しとるけどスマポどころかGC任せにするのがもうここ10年くらいは主流だぞ？（最終的にはネイティブ化されるけどそれでもゼロオーバーヘッドになる訳では全くない）

え？
ゲームでもスマートポインタは普通に使うよ

ああ、ゲームって最新の3Dグリグリのやつな（欧米の大手って言うからそっち想像しちゃった）
スマホゲーやブラウザゲーはまた別よ

>>24
タルコフ見て同じ事言える？

ID:mD/m0vxj は知ったかぶりだね
なんのためにC++相談室スレにデタラメを書き込んでるの？

共用体が良くわからないのですが、同じメモリーアドレスを複数のメンバで共用するとは
どういうことなのでしょうか？
メモリの節約と書いてあるのですが、よくわかりません。
同じ型の共用体が複数あったときに使ってないメンバ変数が勝手に消されるなんてわけないですよね
どなたか共用体と構造体の違いを教えていただければ幸いです。
(まだクラスについての知識はほとんどないです。)

PODで型変換するくらいしか使わんのでは

>>27
とあるデータの見方を複数用意するのが共用体
union { intptr_t integer; void* pointer; } value;
↑が構造体であればvalueはポインタ*2分のメモリを使うところ、共用体だとsizeof(value)は4(32bit)or8(64bit)って感じで変数1個でしかない
integerとpointerは実体は全く同じデータを見ていて、その見方を二つ用意しただけ
value.integer = 8;ってするとpointerも8になる

え！？メモリの節約ができるの！？
でも・・・制限があるんでしょ?
って感じで気になるのです。
ただ、基底クラスとか継承っていうのがわからないんだけど、
クラスについての記述がもう少し先にあるから、まだクラスの部分について読みたくない
、クラスを学んでから共用体について学んだほうが良いのでしょうか?

>>29
ありがとうございます今すぐ読みます

そのレベルなら共用体なんて使わないし使うべきじゃないから読み飛ばしていいよ
一通り学習してから戻ってきな

>>30
別に直接的にメモリの節約が出来る訳ではない
>>29の例で言った通り、一つのデータに対して複数の名前を付けるだけの話なのでデータは結局一つしか同時には入れられない
なんか実用的な例ありそうだけどunionはC++だとそんな使わないし積極的に使うべきでもないからすぐには思い浮かばない

variantとかは中身は共用体だった気がする

>>27
例えばスクリプト言語みたいに色んな型が入る変数を定義したい時に
struct {
char c;
int i;
double d;
};
みたいにするとdを使ってる時はc, iの領域が無駄だよね、そういう時に
union {
char c;
int i;
double d;
};
のようにすると領域が無駄にならない

なんか気になっちゃうのです。
union value { int test1; double test2; } ;
int main()
{
value test;
test.test1= 2147483647;
test.test2 = 1.4;
cout << sizeof test<<endl;
cout << test.test1 << endl << test.test2<<endl;
}
これなんですけど、共用体のサイズは8byteで構造体にすると16バイトになります。
でも、doubleって8byteですよね？
共用体valueの中には4byteのtest1と8byteのtest２があるはずなのですが、
なんで共用体valueは8byteなのでしょうか？
そもそも共用体の中に変数があると言う考え方が間違ているのでしょうか？

>>35
ありがとうございます。ちなみにその仕組みとかって・・・聞けたりとか・・・

structだと4byte無駄になるのですね。

何となくなのですが、構造体だと
メンバの中で一番大きな変数のサイズ＊メンバの数
分の領域が確保されるのかな？って思ってみたりしています。

>>36
だから正に"共用"体という名の通り、test1とtest2はメモリの場所を共用してる
君が言う通り、intは4byte、doubleは8byte
この場合はunion全体としてのサイズは大きい方に合わさるが、メモリの場所を共用してる事には変わりないためtest2(double)の下位4バイトとtest1(int)が重なってる事になる
intとdoubleだと出力分かりづらいからunion value { int test1; long long test2; } ;でやってみ

test1 = 0x5;
test2 = 0x2410000000000007;
こうするとtest1は7(0x00000007)、test2(0x2410000000000007)はとなる（下位4byteは共用されてる）

>>40
これがstructだとちゃんと4+8で12byteの構造体となる(アラインメントって概念によりそうでない事もあるけどそれはまた別で勉強したほうがいい)

test1 = 0x5;
test2 = 0x2410000000000007;
structだとさっきと同じ事をしてもtest1とtest2でメモリは共用されておらずそれぞれ独立しているため、test1は0x5、test2は0x2410000000000007となる

>>40
ありがとうございます。
すごいっす、メチャすごいっす。
あまりの喜びに敬語忘れてすみません。
"共用”なのですね。
ってことは共用体はいくつかメンバ変数を用意しておいて、一個だけ使なら使ってもいいよ。
しかも、いちばん最後に代入された値が採用されるよと言うことで大丈夫でしょうか？

ポイントだけ聞くようにして全部聞こうとすんなアホ

そもそもC++スレ

>>40
おかげさまで何とか理解できました。
自分の書いた上の記述(>>41)もちょっと違ってたような気がするけど
まぁ置いておいて・・・。
本当にありがとうございます。

共用体とビットフィールドでウハウハよ

>>20
スマートポインタを徹底すればできるが記述量が結構増えるのよ
結局面倒臭くなって使わなくなってしまった

共用体はデータ量をケチる目的では使わんでしょ
(マイコンとかバイナリデータとかの)データの配置順に意味があるやつとの相互運用にしか使ったことないぞ

union A{
struct{ char low; char high;};
short data;
};

union B{
struct { int head; double body;};
char data[12];
};

スマポは使えば楽できるときと
そうでないときがあるからな
見境のないスマポ厨はただのマゾ

>>48
大量に確保するデータの場合1バイト2バイトが大きく影響することもあるから、データ量目的でも使うよ

参照オブジェクトを処理するのに
何故か内部でスマポ使いだしたとしたら
予めそいつの代わりに謝っておいてやろう。スマポ。

共用体は特定のアーキテクチャで上位下位とか分けるのに使うのが多かったけど、上に書いたようにstd::variantで使うので主にメモリ節約だと思う

ところで↓でコメントにしてるエラーはなんか悔しくない？どうしてこういう仕様なんだろう？
#include <iostream>
using namespace std;
struct s {
int a;
};
int main() {
s o;
cout << sizeof(o.a) << endl;
cout << typeid(o.a).name() << endl;
cout << sizeof(int) << endl;
cout << typeid(int).name() << endl;
cout << sizeof(s::a) << endl;
//cout << typeid(s::a).name() << endl; // error
return 0;
}

sjis/utf8、utf16、utf32を一緒くたに扱う文字列クラスを作った時にそれぞれの型のポインタを共用体で持たせたな
キャストするより楽だったからw

>>48
それはお前の経験が足らんだけ
>>34が言うようなケースでも使うよ

>>51
これ何であかんの？

>>36
アセンブラでアライン覚えて来い青二才

共用体使うとシフト演算しなくていいし、
最近のCPU(っても20年まえぐらい)から1ビット操作命令もあるし、パフォーマンスがいいと思うぜ

>>54
std::variant見てきた
ただのunionラップクラスじゃねーか

>>58
> ただのunionラップクラスじゃねーか
それの何が不満なんだよw

ただのunionラッパーをunionの活用例かのような言い方をした >>54 に対する不満だ

米大統領と密談した「IQ1200の金星人」ヴァリアント・ソーとは ...

>>60
意味わからんw
ラッパーだと活用例じゃないとでも？

スマポの記述量が長い問題って皆どうしてんの？

C++のstd::variantとほぼ近い、
Rustのenum(＝格納付きenum＝タグ付きunion)を比べると
圧倒的にRustのenumが使いやすくてRust言語の核心部分となっていることからもわかるように
C++ではその分野の言語サポートが弱いんだよな

>>63
その件もRustが上手いことやってるよな

>>65
そうなのか
正直あんまり触ったことないんだが、そういう話なら触ってみようかな

Rustのことはスレ違いだけど、言語機能としてどこまでサポートするかは、分かりやすさと直結してると思う
C++のstd::variantの方が分かりやすいと思う人もいれば
Rustのenumの方が分かりやすいと思う人もいると思う

>>67
C++には十分なパターンマッチング機構がないからタグ付き共用体(Rustではenum)を便利に生かせないのが大きい
C++よりRustは記述がしやすいと言われている原因の大きな一つとなっている

ほんとに馬鹿ばかりだな・・・
そんな話はしてないしスレ違いだと言ってるだろ・・・
http://2chb.net/r/tech/1643289587/

>>52で主にメモリ節約が目的と言っているようだが
それはC++の言語によるサポートが貧弱すぎるための特殊な悲惨な状況であって
他の言語ではむしろvariantこそがプログラミングの中心、という話ではないか

馬鹿には分からないかもしれないけど、嫌なら自分で作ればいいという世界なんだよ

昔は全部ゼロから作ってたな

>>71
それは無理
様々な言語がなぜ言語レベルでパターンマッチングなどをサポートとしているかというと
言語レベルでサポートしないと無理なことが多数あるため
C++しか書いたことがない特殊な人でなければこれを理解することができる

http://2chb.net/r/tech/1643289587/

ところで>>52の
> ところで↓でコメントにしてるエラーはなんか悔しくない？どうしてこういう仕様なんだろう？
への回答はないの？

&s::aの型がint s::*な以上s::aの型はintにはならんからじゃない？

sizeofだけ許されてるのがわからん

ありがとう。全く同じ感想だわ。わからんよね。
#include <memory>
#include <cxxabi.h> // for gcc
#include <iostream>
using namespace std;
const char* demangle(const char* name) {
return abi::__cxa_demangle(name, NULL, NULL, NULL); // leaks
}
struct s {
int a;
};
int main() {
cout << sizeof(&s::a) << endl;
cout << demangle(typeid(&s::a).name()) << endl;
cout << sizeof(s::a) << endl;
//cout << demangle(typeid(s::a).name()) << endl; // error
return 0;
}

PPoEのことピッポエって読んでたらめっちゃバカにされてくやしいです。
どうしたらいいですか？

ボコしたら？

複数のプロセスから同時に同じファイルに書き込むにはどうすればいいですか？
ofstreamで実験(a.exeとb.exeを同時に起動して、同じtxtに10行ずつ書き込み)してみましたが、
a.exeで書き込んだ内容が10行並んだ後に、b.exeで書き込んだ内容が10行並ぶような結果になりました。
書き込んだ順に並ぶようにするにはどうすればいいですか？

OS固有の方法を使え

fprintf()とかの標準ライブラリだとcloseかflushするまで書き込みは反映されない

書き込みのタイムスタンプ順を保証するとなるとかなり面倒くさい
毎回flushするとかcloseするとかしないといけない
書き込んだ内容がもう一方のプロセスに上書きされて消えたりとかの問題も出てくる

ありがとうございます。
保証とまでは求めてなくて、だいたい秒オーダー程度の順でぱっと見の違和感なければいいかなと思っていますのでひとまずflushを入れて実験してみます。
(多少の順番ずれは問題ないですが、上書き消滅だけは絶対問題なので)

ロックしろ

・別々のファイルに吐き出しておいて後からマージ（リアルタイム性不要なら一番楽）
・書き込みの時に毎回排他ロックする（くそ遅い、書き込みが稀ならあり）
・書き込み専門のプロセスを設けてプロセス間通信（正しいけどめんどくさい）

>>80
書き込みプロセスを集約した方が制御はしやすいわ

こんなC++erばかりではもうダメだな・・・・
質問は最悪だけど、確認も回答もやばい
混ざった行が出来たり上書き消滅する日がいつか来る

>>87
ロックを使っても行が混ざるのかーすごいなー

ロックの仕方によるから
極論文字単位にロックしたら混ざるし

真面目に相手をするなら、質問の前提を明確にしないといけないから。
聞きたいことだけ書いてきて、状況が全く分からない質問に対して、あれこれ書いても意味はなく、最初にしないといけないのはまず確認。
環境やら現象やら具体的なコード、最終的なゴールがどこか、当たり前のモノが全て抜けていて、未だに8割方見えていない。

質問に対して状況を確認せず真っ先に>>81で抜けてる回答してる君がいうと説得力があるね

あれはいつものWIN32APIスレへの誘導しか意味してないｗ
.exeが出て来た時点で萎える

同時には無理やろ〜

// std::endlでflush()。時間測定と1行/秒機能付きバッファ懸念OS順序懸念あり。
// 混ざった行が出来たり上書き消滅してもいい人向け。
#include <iostream>
#include <fstream>
#include <chrono>
#include <thread>
using namespace std::chrono;
template<typename T, typename CallbackFunc, typename TargetFunc, typename... Args>
void measure(CallbackFunc callback, TargetFunc f, Args... args) {
auto start = high_resolution_clock::now();
auto result = f(args...);
auto end = high_resolution_clock::now();
callback(result, duration_cast<T>(end - start).count());
}
int write_to_file(const char* path, const char* sts) {
std::ofstream f(path, std::ios_base::app);
for (int i = 0; i < 10; ++i) {
f << sts << std::endl;
//std::this_thread::sleep_for(1s);
}
return 0;
}
int main(int argc, char* argv[]) {
int ret = -1;
measure<microseconds>(
[&](auto result, auto time) {ret = result; std::cout << time << std::endl; },
&write_to_file, "hoge.txt", (argc > 1 ? argv[1] : "hoge"));
return ret;
}

書き忘れた。異常系なし。

セマフォかミューテックス使えばいいだけやん

偉そうなこと言っといて>>83の上書き禁要件ガン無視してるのは草

消滅って実際あるもんかね？
unix系はなさそうな気がする

標準ライブラリの仕様で上書き消滅しないって保証されてれば問題ない

保証されてなければ20プロセスぐらいからchrono::system_clockのタイムスタンプとloopcountを出力させる負荷テストしてみて判断するしかない

>>99
> 保証されてなければ20プロセスぐらいからchrono::system_clockのタイムスタンプとloopcountを出力させる負荷テストしてみて判断するしかない
バカなの？
普通に排他制御すればいいだけだろ

俺は最初にWIN32APIスレへの誘導の意味で、OS固有の方法と書いてるよｗ ソースコードは回答ではなく、本来質問時に提示されるべき叩き台を俺がわざわざ書いただけｗ

ソースコードが分からないアホ向けに説明しておくと、OSに書き込みが発生するのは実際にファイルに書き込むAPIを叩いたとき(/システムコールかそれに準ずるものを呼んだ時(以下略))なので、それはバッファをフラッシュするタイミングになる。
それが発生するのは普通fに文字列を書き込むときバッファが溢れるかendlの呼び出し中(ライブラリの実装に依存する)。
文字列の長さがバッファから溢れない限り、endl中のAPI呼出が重なるかどうかが問題になる。
各プロセスでAPI呼出が運悪く重なった場合、ここからは一度に書き込まれる量と、OSのファイルシステム実装に依存するが、 混ざった行が出来たり上書き消滅する可能性が生まれる。
それが問題な場合は、主にOS固有の方法でIPCかファイルロックを行う必要がある。

なお要件が明確でない状態で何かを言う必要は全くないｗ

グダグタと意味不明な長文書いておいて
> なお要件が明確でない状態で何かを言う必要は全くないｗ
って笑いでも取ろうとしてるのか？

> 複数のプロセスから同時に同じファイルに書き込む
> 書き込んだ順に並ぶようにするには
同時に書き込んでるのに書き込んだ順が決まるわけないやろ〜

何したいのか知らないけど>>85で出てるようにタイムスタンプ付けて別のファイルとして書き出した後、
メモリ上でマージするなり第三のプロセスでマージしたファイルを書き出すなりするのが一番楽だな

>>103
秒オーダーで揃ってりゃいいって話だから多少の前後は気にすんな

ファイルOpenして書き込んですぐCloseするだけやん。

ほら何もかも要件の問題だろ？ｗ 馬鹿なんだよ質問者がｗ

馬鹿が馬鹿を笑う地獄絵図

質問のレベルが低くて恐縮ですが、クラスにおいてメンバ変数は各インスタンスに対してメモリが確保されますが、メンバ関数も各インスタンス毎にメモリ確保されるんでしたっけ？

メンバ関数はクラスで共有されるんでしたっけ？

共有されてて、呼び出すときにインスタンスのポインタが渡ります。

>>109
通常のメンバ関数の実体はそのクラスで１つ（共有される）でインスタンスのメモリ領域は消費しないが、
virtual関数はオーバーライド動作のためにインスタンスにポインタが確保される

>>110>>111
ありがとうございます！
virtualはともかくメンバ関数を書く際にあまりその点は気にしなくてよさそうですね、安心しました

>>110>>111
ありがとうございます！
virtualはともかくメンバ関数を書く際にあまりその点は気にしなくてよさそうですね、安心しました

main(exe)とlib(dll)の両方から参照されるクラスHoge(非dll・シングルトン)のインスタンスをmainとlibで共用する方法はないですか。
軽く調べてみたらHogeをdll化するかHogeのラッパーdllを作れと出てきたのですが
作らなくても実現出来る方法があれば教えてください

main(exe)とlib(dll)の両方から参照されるクラスHoge(非dll・シングルトン)のインスタンスをmainとlibで共用する方法はないですか。
軽く調べてみたらHogeをdll化するかHogeのラッパーdllを作れと出てきたのですが
作らなくても実現出来る方法があれば教えてください

virtualも継承されたクラスごとにポインタサイズの隠しフィールドができるだけで
virtual関数が増えてもクラスサイズは変わらないんじゃ？

>>114
>>115
C++17以降ならstatic変数がある
それ以前ならtemplate関数を使ってどうにかごまかせばいける

class C{};
inline C c=...; //C++17以降
template<int...>C& _dummy_func(){static C _back=...; return _back;}static C&c=_dummy_func();

ポインタサイズじゃないよ

static変数じゃねーわ inline変数

https://godbolt.org/z/P497GqYc7
struct s {
virtual void* func(){return this;}
virtual void* func2(){return this;}
};
struct s2: public s {
void* func(){return this;}
void* func2(){return this;}
};
s obj;
s2 obj2;
int main() {
s& o = obj2;
o.func();
o.func2();
return 0;
}
gcc/clang/msvcどれもポインタサイズだった模様ｗ

>>114についてはまた同じ馬鹿の質問だろうけど論外ｗ コードで示せアホｗ
「main(exe)とlib(dll)の両方から参照される参照されるクラスHoge(非dll・シングルトン)」？？？？
クラスHogeはシングルトンなのかそうでないのか？
lib(dll)から参照されるクラスHoge(非dll)とは？
どうして毎日こんな馬鹿な質問が出来るのか分からない。

仮にDLLが遅延ロードされず、シングルトンで、インスタンスの定義だけEXE側に入れたいというアホな要件を思いついた馬鹿がいるのだとしたら、dllexportを使わず、モジュール定義でやれ。
なお、inlineメンバ変数を使ってもdllexpportsならDLL側にインスタンスの定義が入る。

ヒント：　仮想継承

>>96
そうだねミューテックス使うね

Windowsなら名前付きミューテックスでファイルのオープンからクローズまでを排他するところやが
C++の標準規格でどうなっているのかわ知らん、

複数のプロセスから同一ファイルに書き込んで書き込み内容の順序（位置）を制御する方法は
　1. プロセス間の同期側で順序を担保する（イベント等による通信を併用
　2. ファイルのアクセス権を握ったプロセスがファイルの中身を読んで書き込み位置を決める
　3. ファイルのアクセス権を握ったプロセスがファイルを追記オープンして単純に追記していく
の大きく分けて3つの方法が取れる
普通は3が多いという印象　※ 個人の感想です
辞書化とかが必要なら専用のプロセスが適宜ファイルのアクセス権を獲得してやったらええ、

ちょっと処理が重なったくらいでデータが消えるようなコンピュータはまともに動かんと思うよ

そんなアホなことせんでもOSが同期取ってくれるやろ…

>>122-126
2日前からアホ質問者不在のまま要件不明案件でお蔵入りした質問を今更ほじくり返して質問者本人ですか？ｗ

頓珍漢な回答して相手にされないからっておれに当たるなよ。

回答してないけどｗ >>122-126は全て本人確定かなｗ

>>129 >120

>>130
>>120も回答じゃないけどｗ

126と86は俺だけど…

>>126
kwsk
複数プロセスから同一ファイルに対する同時書き込みオープンは当然できなず、後から開こうとしたプロセスはオープンに失敗する
その場合失敗したプロセスは（エラー要因を調べた上で）一定時間（例えばT秒後）後にオープンを再トライする必要がある
んまーそう作っても良いが（ファイルアクセス権獲得待ちをいつでも簡単にやめられるメリットがある）が、
失敗の度にT秒消費するというのをミューテックスを使えば短縮できる

オープン失敗したら100ms開けてリトライで十分だろう。待機が嫌なら非同期で実装するだけ。
T秒消費するというが同期オブジェクト使っても変わらん。

>>134
>T秒消費するというが同期オブジェクト使っても変わらん。
間違い。
同期オブジェクトを使えばプロセスAがファイルへのアクセス権を行使中、
プロセスBがアクセス権が回ってくるのを待っている状態で
プロセスAがアクセス権を放棄した瞬間にプロセスBにディスパッチされる
ことが気体できる
無駄というものが最小限で済む

同期オブジェクトってそんな低レベルで存在しとる概念なのかね

同期オブジェクトを機能させるためにスケジューラに負担をかけるので
待機時間が特に短いことがわかってるならスピンロックのほうが性能は出る可能性はある。
でもスピンロックを正しく実装できる気がしない。

同期のための仕組みを用意してくれてるんだからそれを使っておくのが基本的には楽だよ。
待機時間 100ms のところを 10ms とかに短縮できたところでなんだというんだ。
それが必要な場合もあるといえばあるけど、どちらがより良いかは状況による。

>待機時間 100ms のところを 10ms とかに短縮できたところで
プロセスAがファイルのアクセス権を握り続けている間、
プロセスBがファイルシステムを10 ms周期でcallすることになるな！

消費ってCPUリソースの話じゃないのか。
書き込みに100msの待機が問題となるようなリアルタイムな要件があるならともかく
ファイルの書き込みなんていう遅いものは非同期の実装に頭使うほうが効率的だろう。

非同期の実装を最小の時間ロスで安全に行うものにするにはミューテックスによる同期が必要なわけで（以下無限ループ

スピンロックは沼なんで、
OS が用意してくれとる仕組みを使えってことで FA 。

>>136
同期は機械語レベルの話じゃけんのう。
尻拭いの案件でよく見るが間違ってもCでグローバル変数でif文で切り分けとかしないでくれよ。
OSが提供する同期オブジェクト使うんだ。

タイミング合わせるために工夫をこらしたプログラムってのは見ていて嫌な気分になるのう
8bit機なら全部ビジーウェイトでいいんだけど

>>94のコードでコメントを外してビルドし、端末を2つ開いてほぼ同時にそれぞれ
./実行ファイル名 hoge1
./実行ファイル名 hoge2
で実行してやると分かるけど、オープンはできていて書き込みも行われるよ

ポーリングで見ようがロックできなければ>>101の解説どおり危険な瞬間(同時にAPIが呼ばれる瞬間)は必ず発生してしまう。
ポーリング間隔0をスピンロックとかビジーウェイトと言ってるのだと思うが、用語の使い方は置いておいて、0でも同様。

8bitのCPUなんて命令の消費clockでタイミング取るとか普通やん

ウェイト気にするんだったらI/O周りでガチャガチャするより書き込み要求をキューで受け付ける専門プロセス用意しろよ

>>117
ありがとうございます、inline変数を試してみます

>>120
コードは手元(スマホ)にはないので貼れないです、すみませんが日本語で理解してもらえると助かります。
クラスHogeは書いている通りシングルトンです。
よく分かっていませんがHogeは静的ライブラリ？というのでしょうか。
visual studioでいうと、
Hogeが入っているプロジェクトと
mainのプロジェクト、
dllのプロジェクトの3つがあって
mainとdllのプロジェクトの両方が「参照」でHogeが入ってるプロジェクトを依存関係？構築してます。

>>148
日本語で説明できてないんだよｗ
今も確認が必要になってるだろ
問題は何？
シングルトンオブジェクトが、プロセス内に2つ(exe側とdll側)あること？
dllは遅延ロードするの？

>>146
結局ここまで全部要件の問題ということで・・・

Hogeのヘッダとlibファイルをmainとdllのプロジェクトに追加するだけの話じゃないのか。

>>151
こんな感じになってるんだと思う
https://wandbox.org/permlink/ME0HLrM3vXDeMvoR
main.cpp(exeプロジェクト)
api.h(dllプロジェクト)
api.cpp(dllプロジェクト)
Sample.h(libプロジェクト)
Sample.cpp(libプロジェクト)
vc++で実行すれば分かるけど、dllとexeでインスタンスが2個出来る
IDEが作るファイルは使ってない(プリコンパイル済ヘッダ未使用vs2019で確認)

>>148
あーすまん.dllならinline変数でもダメだわ
.libとの変数共通ならいけるんだが

>>152
どうせ昼間のIDの誰かが質問者兼>>153だと思うので面倒なので補足しておく。

もし>>149の
> シングルトンオブジェクトが、プロセス内に2つ(exe側とdll側)あること？
がYesで
> dllは遅延ロードするの？
がNoなら
クラスSampleの宣言に__declspec(dllexport)を付けることで、1つにすることはできる。
ただし実体がdllに入るので、遅延ロードはできない作りになる。

質問者ではないけど俺は.hで完結させたい人種なので「dll側かexe側に変数の実体を作らなきゃいけない」という縛りを極端に嫌ってる

dllとも変数実体を共有したいなら.h完結を諦めて
・実体生成用の1つのcppでだけ#defineでなんか定義して実体を定義させる
ぐらいしかまともな回答は思いつかん

どうせ複数dllから1つの変数を共有したいって話にもなるから
実体生成用のcppはexe側が受け持つか管理用のdll(質問者はやりたくないようだが)を作ることになるだろうな

hogeの実装がどこにあるべきか決めてないとな。COMにするという手もあるな。

質問者本人の匂いがプンプンするけど、全部ヘッダならそもそもlibやdll要らないでしょ
昔からstaticメンバ変数にその手のマクロが付いてるヘッダオンリーなライブラリもどきはある
管理用のdllなるものを作るにしたって、exportされるAPIとしてインスタンス生成用メンバ関数を直に紐付ける方法がないと、公開された生成方法が必要になり、シングルトンとして十分制限できない。
COMにするならもうC#で作ればいいのにと思ってしまう。

Linuxには名前付きミューテックスないだっけ？
プロセス間の排他制御にflock使った思い出

pthreadにあるやつが使えるからあるんでしょう

mutexっていうかセマフォ使ってるかも

linuxのプロセス間同期にはセマフォを使うよ
https://man7.org/linux/man-pages/man7/sem_overview.7.html
boostでやりたければこんな感じらしい
https://www.boost.org/doc/libs/1_58_0/doc/html/interprocess/synchronization_mechanisms.html#interprocess.synchronization_mechanisms.mutexes.mutexes_named_example
※最近boost使ってないのでよく知らない

なるほどLinuxもセマフォは名前付きがあるのね
ありがとう！

条件変数が一番好きです

そのへんが全て最初から言語の型として標準で装備されていて
さらにコンパイルが通ればマルチスレッド時のデータ競合すら起きないことが保証されるRustが強いよな

openMPを使いたいけど使うと言えない

どうやってスレ立てるの？？

>>166
https://cpprefjp.github.io/reference/thread/thread.html

メモリ上で連続した多次元配列を動的に確保したいんですけど、どうするのがスマートなやり方ですか？

多次元配列を宣言する

>>168
「連続した」ってとこｋｗｓｋ
ハード的な事情があったりするのか？

スマートが何処にかかるのか

またスマートとか自分の希望要件すら言語化できないアホな質問来てるな・・・
いっぺん真で頭ガチャするのがスマート

「動的に確保」というのも、コンストラクトの時点で大きさが確定するというのと
後から伸長する可能性も含むというのでは事情が違う。

>>173
VLAのように実行時に全体の大きさを指定したいです

mallocや

小出しにしてんじゃねーよｗ
質問者のお前が聞かれたことに答えるんじゃなくて、せめて満たすべき最低限の要件くらい自分で明確にしろと言ってるんだよｗ
そんなこともできなければ真でくれと言われてるのｗ

>>174
ということは最初の割り付けでサイズが確定していて
途中でresizeはできなくていいんだな？

あるいは、CのVLAをC++で操作できるようにしたいのか？

初心者ですまんがVLAってvectorで代用できないの？

つvalarray

3次元配列なら
template<class T>
class V{
T*const ptr;
size_t s1,s2,s3;
public:
V(size_t s1,size_t s2,size_t s3):
s1(s1),s2(s2),s3(s3),
ptr(new T[s1*s2*s3]){}
T&operator()(size_t i1,size_t i2,size_t i3){
return ptr[i1*s2*s3+i2*s3*i3];
}
~V(){delete[]ptr;}
};
V<int> v(4,5,6);
v(1,2,3)=42;
みたいのでええんか？
大体こういうの自分で作るとバグらせるからあんまやりたくないけど

すでにバグってる気がする

boostにあるけどオーバーエンジニアリングっぽいんだよな

馬鹿にされたい馬鹿が小出しにしてる以上何とも言えないｗ
僕ちゃんboost使いたかったけど馬鹿だからよく分からないし、条件小出しなまま複数IDで汎用な答えが欲しいのぉって言ってるだけなのが透けて見えるｗ

何の情報が必要かすら分かってない初心者かもしれないんだから聞き出してやればいいのに
煽って出てくると思ってるなら考え甘いぞ、要件引き出せないようじゃ半人前

ちゃんとID変えて出てきてるし煽ってないし、僕ちゃん答えは欲しいのに分不相応なプライドだけ高くて素直になれないのぉって言われてもね

一方すぐ質問者にマウンティングしたがるおまえはすぐわかるなw

> ID:cGpWV2sd

おまえイラネ
無駄にうるせえ

こんなスレにいちいち相談する初心者なんてそうそういねーよ
もし初心者なら回答欲しいんだから何言われても何某か返事する
そういうのがなく単発IDなどが煽ってくるということはつまり・・・図星ってことｗ

ここ覗いてるのって技術系の雑談ネタとしか思ってないだろうが、
毎回、単発IDで質問して逃げてるとしたらクソ野郎だな。
学生の課題か何かだろう。おれたちは利用されてるんだ!!!

利用されるのが嫌ってこと？よくわからんが。
まぁ、学校の課題でズルしても本人のためにはならないんだから勝手にしとけって感じだな。

>>190 >>191
そう、お前のことだよ質問者兼回答者君
ただ学生じゃなくて社会不適合者だと思うし、毎日アホな質問しちゃぁ俺に馬鹿にされてるのに飽きないね

妄想えっぐ、糖質っぽいな

在日君なんだろうな

>>192
おれみたいなじーさんがおまえのような小便垂れの小僧に質問するわけないだろ…

なんで const なオブジェクトは const なメンバ関数しか呼べないの？

メンバ関数でメンバ変数が書き変わるとconstオブジェクトとして困るから

中が書き換わるかもしれないから

でもポインタで簡単に書き換えられるじゃん

意図的にconst外さなきゃconstのままだよ

何も考えずconst外すバカのことなんて知らん

constが役にたった場面にあったことがない。
自分で書き換えといて「書き換わるかもしれない!!」とかどんだけ適当にコード書いてんだか。

constは積極的に使うことでI/Fを分かりやすくしたりできるね
書き換えない想定を明示的にして最適化しやすくする効果もある
意味的に正しいことが保証できないときにconstを使うと泣くこともあるけどｗ

>>202
const使ったらコンパイラはどういった最適化するんだ？

constとprivateはテストの邪魔でしかない
使ってる奴は例外なく低脳

privateはインテリセンスがすっきりしていいじゃん

>>203
実際にやってみろ
>>204
サンプル説明以外で可視性やconst使ってない馬鹿はエアプ

自分で言い出しといて急にキレられてもな。

>>207
キレる？お前が調べもせずに聞いてくるから当たり前のことを言っただけだが

>>206
エアプは君だよ
製品レベルの緻密なテストセットをきちんと書き上げるためにはconstなしのオールpublicしかあり得ん
テストケースで様々な状態を作りだして動作確認するためには、全てを必要に応じて自由に書き換えられることが不可欠というもの
書き換え不可だのクラス専用だのの決め事は命名規則で担保するんだぞ

IFのシグネチャにconstついてないといちいち仕様書読まなきゃいけないから面倒くね？
char* token(char* str)とかあったら破壊的かどうか判別できん

>>209
struct最強伝説キタコレ

>>211
staticおじさんの生まれ変わりだろw

>>209
https://github.com/trending/c++
この辺のプロジェクトのソースでもいいし、chromiumのソースでもいいし、見てみたら？
製品レベルのコード見せてみろよ

const使ったらどんな最適化するんだろう？　言った本人はキレて答えてくれないし。

>>214
お前が1+1=って言ったら俺はお前のためにわざわざ2と言う必要があんのか？
自分で調べたことの事実を示せｗ

Rustは何も指定しないとimmutable(不変)にしちゃったから、そういう点でもわかりやすく、かつ、テストやデバッグも少数のmutableなものだけ対象にすればよくなってるね

>>215
全く必要ない。
キミは自分で言い出しといて逃げる人とよく分かったから他の人に質問してるだけ。
キミはスルーしてくれていいよ。

>>216
Rustは無関係なので巣に帰れ

constを使うのがいいことがよく分かった

constウイルスと言わざるをえないアホ仕様

だからさ、釣り針が太すぎるんだよな

constついてないコードは九分九厘ごみ
絶対に自分一人で書き上げて絶対に一生涯外に出さない保証があるなら付けなくても良い

本に載るほどの支持を覆すほどの権威と実例があるわけもなく

メンバ関数のconst修飾とか関数の引数のconstとかはわかるけど関数内部のローカル変数にconst付けるのはよくわからんな

const お会いしたらお茶しませんか？

>>224
コードが読みやすくなるし間違って書き換わることもないから
どの言語でもconstやそれ相当で宣言するのが最近は一般的
JavaScriptですらconstにするのが常識となった

ここ数年constをつけて再代入しないのが当然になってますってjavascriptの専門家に言われて殴りたくなりました

JavaScript程度はブラウザのカスタマイズしたり含めて誰でも使える言語だろ
まさかC++しか使えない新人かね

Pythonにはconstもprivateもない
大文字だけの名前はconst、アンダースコア始まりの名前はprivateという規約があるだけ
でもそれでみんな勝手に書き換えるべきでないと了解されてて完全に成立してる
とはいえ言語機能ではないのでテストとかでの必要に応じて規約を無視して値を変えることもできる
こういう実例を見るとわざわざコンパイラ機能として書き換え禁を強要してるconstやprivateは偏執的過ぎると思う

小さいオブジェクトにconst付けるとアドレスが割り振られて最適化が阻害されるみたいな話は聞いたな

日付が変わってまた湧いてるｗ
>>229 pythonみたいなゆるゆる言語と比較してconst/privateがないとかｗ
>>230 その話URLで示してｗ

ここまでconstつけると最適化されるという例はなし。

ここまで何を調べたかの記述なしｗ

move、右辺値参照、各種オペレータなどフルセットで対応するライブラリ的なクラスならconst対応した方が良いけど、
末端のアプリケーションにまで全部律儀にconst付けるのは面倒くさいだけだわな

そんなしょうもないものならわざわざC++で組むなよｗ 発想がアホの極みｗ

Rustなどは無指定デフォルト時がC++でのconst状態になってるよな
楽でいいよな

>>236
Rustの話はRustスレで

話題に沿ってるんだし少しくらいなら良いと思うけどね。アレルギーかよ

Goスレ見てると対岸の火事とは思えないｗ
Rustスレは静かなのに、そこで議論できない馬鹿がずっと他言語スレでRustのヘイトを稼いでるからなｗ
Rustくらいみんな知ってると言うのにｗ
ってわけで、特に今は各言語固有スレではその言語の話だけってことｗ

他所のスレのことは知らんけどこれをヘイト稼ぎと受け取るのは捻くれな気がするけどね
Rustのことも自分が知ってるからってみんな知ってるとかイキるのも良くない
知らない人だって当然いるだろうに

ヘイト稼ぎと解釈しない方が捻くれてるだろｗ
今どきC++やっててRust(やそれ以外の言語)知らん方がレアだし、その程度のやつは何を言われても仕方ない

その程度とか言い出した
パソコンの大先生かな？w

誰でも最初は初心者なんだけどね
ここオンラインの匿名掲示板なの忘れてない？
勝手に自分基準のレベルを周りに押し付けられてもね
そういうのは自分の納得できる閉じたコミュニティでやればいいと思う

いや、悪いけど>>241はレベル低いと思うよ・・・w

自動販売機のタバコじゃないんだけどね
もっと高級なのね

Rustってまだ言語マニアくらいしか使ってなくね
そもそも案件が少なすぎるしRsutでしか提供されていないライブラリやフレームワークやSDKなんて聞いたことないし
俺が知らないだけで実はコッソリ出現してるのか？？？

実際こうやってアレルギー反応（スレが荒れる）起こすからよその話はよそでやれってことだな

荒れてねーよｗ

>>246
色んな分野でRustがC++の立ち位置を侵食していってるよ
例えばブラウザ内だけでなく今は色んな所で使われるようになったWebAssembly(WASM)
WASMでプログラミングするための記述言語は当初C++が先行していたけど今はRustが逆転してトップになっているね

だいたい
http://2chb.net/r/tech/1524746903/652
http://2chb.net/r/tech/1524746903/659
と質問したら
http://2chb.net/r/tech/1524746903/661
やそうやし＼(^o^)／

>>249-251 こういうのが荒れてる状態

>>252 これもな

だいたいインターフェースにもconstつけちゃう
class IFoo {
　int bar(const int x, const double y, const RECT z) const = 0;
　double baz(std::string& buf) const = 0;
　/*...*/
};
とか

virtuarl ~IFoo() { }
を忘れたorz　（死

値渡しをconstにして何がしたいん？

固定ならconstexpr使おうや

>>257
文字通りconstにしたいのですヽ(`ー´)ﾉ
引数に再代入するのはガイジのやることなので（>>251

で関数定義でそうしたら、作業性のためにそれをコピペして極力弄らずにヘッダファイルにするから
宣言においても値渡しの引数にもconstが付くのでつ∀`；)

まあ非参照型でconstついてなかったらとりあえず
ひょっとして関数内で書き換えられるんかと疑ってかかるよね

>>232
IPAコーディング左方ガイド[C++言語編] (p.120)
https://www.ipa.go.jp/files/000055043.pdf
>M1.11.1 参照しかしない領域は、const 型であることを示
>す宣言を行う。
（中略）
>参照するだけで変更しない変数を const 型で宣言することで、その変数を変更しないことを明
>示できる。また、処理系の最適化処理でオブジェクトサイズが小さくなる可能性もある。この
>ため、参照しかしない変数は const 型にする。

やそうや；；；
具体的には知らん

引数に再代入するかどうかは呼び出し側の与り知らぬところなんで
それを公開インターフェースに乗せるのはどうかなぁ。

Rustだと値渡しだけでなく参照渡しも無指定デフォルト時は書き換え不能だよな
書き換えが起こる関数へは指定して可変参照を渡す

どこぞの馬の骨とも知れないIT後進国ジャップが言う事よりも天下のGoogle様のコーディング規約を真似るほうが無難だぞ
そしてGoogleのコーディング規約によると「可能な限りconst付けまくれ」との事
実際にGoogleが公開してるライブラリはCにしろC++にしろ関数の引数から大体const付いてる、ポインタは勿論constバーガーで

>>262
あずかり知らぬことならどうでもいいんじゃ……
コピペした後手作業でconstを消すとかｱﾌｫらしい漏れクラスの天才の単金は高いからな
やっぱ作る方の作業性優先で、

記憶モードだがVC++のインテリセンスは値渡しのconstは除去して提示してくれるはず……

でもconst書く方の手間は惜しまないんだ

> 処理系の最適化処理でオブジェクトサイズが小さくなる可能性もある。
> int bar(const int x,

これをどうやって小さくするんだ？ そもそもconstの値渡しの話だよな。

>>264
へぇ〜知らなかったわこれ
流石ゴーグル様やで

引数で明示的に書き換え禁止にしたいということはポインタ渡しか参照渡しだよな。
アドレスしか渡してないのに最適化でオブジェクトサイズが小さくなるというのはどういう意味だろう？

> 「可能な限りconst付けまくれ」
自分で設計、コーディングができなくてオープンソースをパクる側の意見だろう。
あくまでパクりすぎて訴えられて負けるググルくんの意見。

char*ならアドレス渡すより実値渡す方がサイズ小さくて済むとかじゃない？知らんけどね

>>269
値渡しだとしても関数内で決して書き換えませんよって意思表示でconst付けるんだわ
使う側はどうでもいいのかも知れないけど少なくてもメンテ側はその方が楽

実質in宣言だよね

まだ馬鹿がconst不要とかアホなこと言って荒らしてるのか・・・

もういっそのこと、constをメンバ関数宣言のデフォルトにして、volatileキーワードをメンバ関数宣言にそえないとメンバ変数の値を変更できないような仕様変更をしたほうがいいくらいだよ

ラムダ式の値キャプチャはデフォでconstだね
constつけたくないときはmutable

勝手な憶測だけどconst付けると即値埋め込み以外にもどの変数をレジスタに入れるかって辺りの最適化が効きやすくなりそうな気はする

class ClassA {
public:
int x, y;
ClassA(int n1, int n2) { x = n1, y = n2; }
virtual void VirFunc() = 0;
};

class ClassB :public ClassA {
public:
ClassB(int n1 = 0, int n2 = 0) :ClassA(n1, n2) { ; }
void VirFunc() { cout << "Disp1:x+y=" << x + y << std::endl; }
void Dummy() { ; }
};
void check(ClassA* obj)
{
if (typeid(*obj) == typeid(ClassB)) {
static_cast<ClassB*>(obj)->VirFunc();
}
}
int main()
{
ClassB objB(10, 20);
check(&objB);
}

クラスの継承やtyoeidで今躓いています。
objにclassBがなんで代入出来てなんでキャストできるのかわかりません。
check関数の中の引数、ClassAのポインタにClassBで実体化したオブジェクトのアドレスを入れると言うことは
継承した部分だけを見ることで同じ型として見ているのですか？
だとしたら派生先のクラスでできたメンバ？がどうなるんだろうと言うのもわからなかったりはします。

すみませんコードってどう上げれば良いんでしたっけ？

const の必要性ってこういうときにあると思ってる

struct T { int x; int y; T(int _x,int _y):x(_x),y(_y){}};
int test1(T &a){ return a.x*a.y;}
int test2(const T &a){ return a.x*a.y;}
int main() {
T a(10,5);
printf("%d",test1(a));//OK
printf("%d",test1(T(5,4)));//エラー
printf("%d",test2(a)); //OK
printf("%d",test2(T(4,6)));//OK
}

>>279
想像のとおりです
なのでメンバーが減るようなキャストはまずい

>>282
ありがとうございます。
アップキャストダウンキャストも関わっていたのですね
すぐにはわかりませんでした。
たとえばなんですけど派生クラスBは基本クラスAに別の名前を付けてかつBで新たに
加えられたメンバはBから紐づけられていて、これらをセットにして見やすくしたものが
派生クラスBになると言う感じなのです？

派生クラスのオブジェクトには基底クラスのオブジェクトが含まれる。
派生クラスの一部であるようなオブジェクト (基底やデータメンバ) をサブオブジェクトという。

>>284
ありがとうございます。
サブオブジェクトがサブオブジェクトと言われることにつながるのですね。

ダウンキャストは危険で、本来無条件にやっていいものではない
なので実行時型チェックをして使っている今回は問題ないだけ

なお、static_cast<ClassB*>(obj)->VirFunc()は最近のコンパイラ(gcc11.2)だと
最適化なし時はClassA*として仮想関数呼び出しと同じ方法で呼び出す
最適化あり時はvtableがClassB::VirtFunc()かどうか確認してインライン展開したものが実行される
(万一確認失敗したら仮想関数呼び出しと同じ方法で呼び出す)

ダウンキャストをするならstatic_castではなくdynamic_castを使うべき。
見ているobjの実体がclassBじゃないなら失敗してnullptrを返してくれる。

そもそもダウンキャストが必要になること自体良い設計ではないが

auto* pb=dynamic_cast<classB*>(pobj);
if(pb){
pb->...;
}

「キャストはなるべくするな、特にdynamicはコストが高い」と古文書にもあった

今回はそれをtypeidでやりたかったんでしょ

ダイナミックダイクマ

なんかC++が気になるので実践的な情報でもなんでもありがたいです。
C++で食べてる人と話したこともないし・・・

古文書には「#defineではなくconst,enum,inlineを使うといい」ってあるよ

死海文書では「constexpr, enum struct, enum class」を使うことで難を逃れたと書いてある

const使えば分かる。#defineのほうがやっぱり便利だわ。

C++のenumは機能が弱いからなあ
Rustのenumみたいに任意の型の変数値を格納できるようにしてほしい

>>275 >>276
その方針で全ての変数のデフォルトをC++のconst状態にしてしまったのがRustだね
代わりに値が変化する変数にだけミュータブル指定しないといけないけど
if-elseもループもブロックも値を返してくれるためほとんどの変数が変化しない

char*やシンプルな構造体ならconst使うのはメリットあると思うが、
あれこれ機能が詰め込まれるクラスになると不便さ、面倒さのほうが際立つ。
多重継承並にハゲる原因になる。

まーたしかにconst_castだらけになるかもしれないね

const_cast を正しく使うのは難しい。
const なオブジェクトから const を剥がして書き換えるのは未定義。
数年前に LLVM が const 指定の情報を最適化に活用する方向に舵を切ったというニュースもあった。
const ではないオブジェクトに対して const なポインタや参照を経由している場合には
const を外して書き換えるのは許されるはずだが、
それが必要になるようだと設計を見直したほうがいい。

現在のコンパイラは賢くて、 const 指定をしてなくても書き換えられる可能性がないことを見抜いて最適化することも多いんで、
const の指定自体は最適化にはそれほど寄与しないよ。
ただ、 const を前提とした設計はコンパイラにとって最適化しやすい構造である可能性はある。

�@ const を前提にした設計にできるもんならしたほうがいい
�A そうできないなら無理に const を付けないほうがいい (後で場当たり的に const_cast で const をはがすとどこかで間違う)

書き換えないコードの場合はどういう最適化がされるのかを知りたいのだが。

getterにlockを仕込む場合にgetterをconstにするべきかどうか悩む
const扱いにしてmutexに関してだけconstをはがすべきなのか

class C{
std::mutex _mtx;
int _a;
public:
int get_a(){
std::lock_guard lk(_mtx);
return _a;
}
void set_a(int a);
};

>>301
俺ならgetterにはconst付けてmutexメンバ変数にはmutable付けるね。

>>301
俺も >>302 には賛成。
mutex はあくまでも内部的な実装の都合であって、
それを mutable にしてもクラスの logical constness は維持されると判断する。

>>300
だからお前は何を調べたとずっと聞いてるんだがｗ

言い出した本人が逃げ出して答えないし、誰もはっきりと答えないんだからウソなんじゃね？

状況に依るけどmutableにするなら俺はunique_ptrとかにするかもしれない

>>305
言い出した本人はいるし、「お前は何を調べたとずっと聞いてる」のにしかも何度も聞いてるのに答えない＝お前が逃げ続けてるからだろ？ｗ

本人いたのか。自分で言い出したはいいが実はさっぱり分からないって感じか。
それはそれで仕方ない。発狂してたら余計にやっぱりウソなんだ〜ってなるだけだぞ。

もう寝るけど、お前がただただ煽りながら発狂しちゃってる間も、毎日何某か書いてるんだがｗ
いつになったらお前がどこまで何を調べたのか詳細に説明してくれるのか心待ちにしてるよｗ

>>302 >>303
ありがとうございます

なるほどフィールド側でconst扱いしないモードを初めから指定すればいいのか...

>>309
やっぱりウソなのか。散々暴れといてしょうもない奴だな、おまえ。

void f(const std::vector<int>&v){
for(size_t i=0; i!=v.size(); ++i)...
}

とかで
本来v.size()を毎回呼ばなきゃいけないけどconstだから1回呼ぶだけで十分って話とかじゃないの？

まあ俺も-O2コンパイル結果を読む気力はないからエアプ扱いしてもらって構わんが

constなんていつでもconst_castで引っぺがせるんだから、勝手に定数畳み込みとかは出来ないし
じゃあそういうのが無いのを検知すれば出来るだろというと、そんなに賢いならconst無しの変数でも同じ事が出来るはず
結論から言うとconstは最適化に何の影響も及ぼさない
畳み込ませたい定数はconstじゃなくenumか#defineで定義するのが正解

複数IDで暴れとるｗｗｗｗｗ 朝までに具体的な事例を書いてねｗ
環境も明記されてないコンパイルも通ってないモノでは想像で言ってるだけってことになるよｗ

>>312
この例は毎回v.size()呼んで遅くなりうる
それは最初に1回一時変数に受ければ解決するがそれがconstかどうかはまずパフォーマンスに影響しないだろう

もっというとこれは生のfor文の欠陥でこれからはstd::views::iotaを使っていくべき理由の1つだと思う

>>315
その例はconstにしようがしなかろうがインライン展開されるので最適化結果に違いはないよ
そもそも最適化しやすくなると言ってるだけで、違いがあるとまでは言ってなかったんだけどｗ

>>314に書いたとおり、煽るだけ君は結局「想像で言ってるだけ」なんだなｗ
妄想はほどほどにしてくれｗ

最適化コードに違いがある例が以下。マクロの定義を空にすればconstなしのコードになる。
https://godbolt.org/z/YavYzrE3z
#define CONST const
template<typename T>
struct s {
T value;
operator T() CONST {return value;}
};
CONST s<int> a[] = {1,2,3,4,5};
template<typename T> T func() {
T r = 1;
for (int i = 0; i < sizeof(a)/sizeof(a[0]); ++i) {
r *= a[i];
}
return r;
}
int main() {
return func<double>();
}

>>316
俺はこの話題に関して初めて書き込んだ者だが

>>316
都合の良い例にしすぎだろ

反証は1つで十分ｗ 具体例の1つも書けない人は黙ってようねｗ

ああすまん、変化しない例を出してるつもりだと思ってた
そんなコードでも変化したりするのね

古文書には#defineは良くないってあったけど今のC++ってその辺り改善されたんですか？

>>321
ある程度は。

>>321
「その辺り」って何？
スコープとの相性が最悪って意味なら変わってないぞ

>>323
他所からパクってきたコードですが、#defineはそのまま書き換えるだけだから以下や

#define SIX 1 + 5
#define NINE 8 + 1

int main(void)
{
printf( "What you get if you multiply six by nine: %d\n", SIX * NINE );
return 0;
}

以下の関数の呼び出しなどで意図しない挙動になったりとかです

#define SquareMulti(x, y) x * x * y
SquareMulti(++a, b)

>>324
その程度なら inline や constexpr を活用するのが今は良い作法

>>324
マクロに関してはそういう所は変わってない
餃子が言うようにマクロ以外の手段を使うというだけ

>>321
#defineじゃないとできない/面倒なパターンが減ったという意味ならある程度はマシになってる

<numeric>とか<source_location>とかconstexpr/constevalとか

>>321
#付いてるから、基本プリプロセッサ文だかんな

スコープ付きの#defineが欲しい時ってあるよね…w

ねーよｗ

#define NAMESPACE namespase
#define NS ns

NAMESPACE NS{
void f();
}
void g(){
NS::f();
}

このへんのコードをプリプロセスの段階で正しく解釈するのは無理なのがね

#pragma defines(push)
みたいのが言語標準になればいけるか？

馬鹿の妄想は放置して、マクロでないと困る例
#include <iostream>
#define PRINT_LOCATION() (::std::cout << __FILE__ ":" << __LINE__ << ":" << __PRETTY_FUNCTION__ << "\n")
namespace hoge {
void func() {
PRINT_LOCATION();
}
}
using namespace std;
using namespace hoge;
int main() {
PRINT_LOCATION();
func();
return 0;
}

友達いなさそうだな

そんなこと気になっちゃう程度の馬鹿よりは多そうだけど、多けりゃいいってもんでもないと思うぞｗ

多くの回答ありがとうございます
やはり可能な限り#defineは避けた方が良さそうですね
ただ#defineでもできないことや、#defineにしかできないこともあるので変に毛嫌いせず勉強を進めてこうと思います

例外中の例外なので、毛嫌いして全く問題なく、勉強する必要も全くないｗ

Include Guard Macro以外の#defineは忘れてもいいと思う。

ほんそれ
一生ソロプレイかつCにしがみつくつもりなら構わないけど
そうじゃないなら基本的に使わないべき遺物

ほぼ同じ演算子オーバーロードを延々と書く場合とかマクロでまとめていいと思うけどね
テンプレートではどうしようもないレベルのメタプログラミングの手段として未だに有効

むしろ、他言語にマクロ展開機能がないことが不満

そうなる仕組みもどうかと思うけど、必要悪として採用するケースが「あってもいい」という程度だよ

>>339
だよな

復号代入とかフルで揃えようとすると
毎回同じようなコードを延々書くからな

だよなじゃねーよｗ
本当にマクロでないとできないケースなのかすら怪しいｗ

>>339
テンプレートでできなくてマクロならできるとかそんなにはないだろ

>>340
C/C++ のマクロなんて PL/I から見たら子供騙しレベルだけどね

>>340
C++に一番近い言語であるRustが多様な各種マクロを充実させているので乗り換えるのもよいかもね
マクロ以外にも非常に多くの問題が解決される

ゴミのような文化を踏襲してしまった残念言語のRustさんのヘイトを上げるのはやめましょうｗ

C++使ってるおれすげーみたいな

C++を使いこなせないから皆下流行語の修得を目指す

>>343
怪しいって明確に判断できねえのかよ
そもそも俺そんな話してねえし

>>343
見てもないコードが明確に判断できたらこえーよ
そんな話じゃないって何いってんのｗ

>>350
アンカー間違った。>>349な。

>>350
おまえさん本当にC++使いか？
operator+とoperator+=みたいのの全組み合わせがマクロ使わずにできないとでも思うのか？

>>340
Cプリプロセッサを他言語で使ってもいいんですよ。

>>340
マクロを持つ言語は多い
Rustのように用途に応じてマクロが何種類もあるケースもある

struct B{...}*bP;
struct D1 : public B{...} d1;
struct D2 : public B{...} d2;
bP = (...)? &d1 : &d2;
これって駄目なんですね

>>355
3項演算子の引数型が互換性のないD1*,D2*だからね

C#9あたりがターゲット型から3項演算子の型推測やってた気がするがC++に導入される日か来るんだろうか

なるほど
素直にif文にしておきます

つ static_cast<bP>(&d#)

>>357
bP = (rnd() & 1)? (B*)&d1 : (B*)&d2;
ではあかんのか？

rnd() & 1
は無視してくれｗ

ああ、それでいいんですね
ありがとうございます

今度はCに毒されていくC++スレｗ
プリプロセッサはincludeパス的に言語や標準ライブラリを結構意識したりしますｗ

>>355
そういうのはRustがすっきり実現していていい感じ
静的モノモーフィングでコンパイル時に解決させる方法と
動的ディスパッチで実行時に解決させる方法の2種類を選びつつ簡単かつ安全に記述できる

なんでこんなとこにrust信者が湧いてるん？

C++のstatic_castで十分すっきりしてるし安全なんだがｗ

うむ
まあRustはトレイトを導入しているためもっとフレキシブルに機能毎に事実上のキャストができる点で先に進んでる感じ

std::visitで十分じゃないの？

>>364
メンタルはルビ基地と同じだから相手すんな

>>364
スレ違い野郎はNG推奨

RustはUnityで作られてるんだからC#スレ行けよ

有名なライブラリのコード覗いて見るとC++でもマクロ結構使ってるよね

まあそこは女性のウェストが50cmだと思ってるスペック厨のオタクと現実に生きて実用的なものを開発してる人の違いだね

有名ライブラリこそマクロに頼らないとやってられんとこあるからな

コンパイル環境(gcc/clang/MSVC)のスイッチとか
C++バージョンのスイッチとか(#define CONSTEVAL20 consteval/constexpr)

ボイラープレートの簡略化はどれぐらいやってるかは知らんが

条件コンパイルには#ifdefがいるね

文法ばかり勉強してコード書かないからマクロの必要性が見えないんだよ。

ああ、マクロ不要論者は自分でライブラリ書いたことないというオチか
腑に落ちたわ

まともにコード書く量も質も足りない人にはマクロの弊害を認識できてないんだろうなｗ
インクルードガードなどの条件コンパイルはプリプロセスではあるものの、一般的なマクロ置換処理ではないｗ

本気でいってんの？このバカ

単発IDで中身のない煽りだけの人が早速出現ｗ
臆病すぎｗｗｗｗ

> マクロ不要論者

誰？　いたっけ、そんなやつ

>>380
>>336あたりじゃね？

ああ、あのキチか
相手すると馬鹿が伝染るからやめようぜ

まだいたのか臆病者ｗ 答え教えてもらってもなお理解しない人に付ける薬はないよｗ
構ってちゃんやるなら別の板でやれ

コンパイル時にansiをunicodeに変換する簡単な方法あってある？
具体的にはmagic_enum::enum_namesで返ってくるstring_view配列をwchar_tとして貰いたいのだけど

exe野郎は口を開く権利なしｗ
ソースコードのエンコーディングを指定するか、エスケープした文字列まで正しく変換したソースを使った上で、必要なキャストをするか、プロジェクト設定を使えｗ

MSの教えどおりにマクロ使ってれば簡単なのにな。

そもそも言ってる内容が怪しいｗ ワイド文字の話とエンコーディングの話がごっちゃになってるｗ

ansiをunicodeにエンコードしたいって意味なんだけど自分でテーブルでもつくらないとconstevalには無理？
それ以外に方法がないならライブラリいじることにするけど

動くサンプルを載せてみろｗ

ansiってなにを指すん？

アメリカの国内規格

MS様のお庭ではローカルコードページくらいの意味だｗ

>>390
日本語WindowsMSVCだと"あ"はansi（shift-jis）として{ 0x82, 0xA0 }になる
これをunicodeの0x3042にエンコードするって感じでconstexprに生成されたansiを変換していきたい
ライブラリ内部では__FUNCSIG__等を利用して静的にenumから文字を生成してるからL#でもして端からunicodeを生成すれば良いんだけどその場合は他にも色々と変えないとダメだからそれは最終手段にしたい

>>393
ごたくはいいから動くサンプルを載せてみろｗ

>>394
動くサンプルって何？
動く見通しついてないからこうして質問してるんだけどとりあえずansi版でもいいからサンプル見たいってことか？

enum class AIUEO { あ, い, う, え, お };
void print(){
constexpr auto texts = constexpr auto texts = magic_enum::enum_nameptrs<AIUEO>();
for (auto& str : texts) puts(str.data()); //ほんとはここを_putws的なunicodeを受け取るものに投げたい
}

今即席でスマホのブラウザで書いたからconstexpr auto texts = constexpr auto texts = のところミスってるけどスルーしといて

main関数がないので動かんな
magic_enumもないので動かんな
これがお前の「動く」サンプルなのか？？？ｗ

出たよサンプルないと何もできないおじさん

https://qiita.com/ta_dragon/items/1828ceb16bc8733526e1
貼っとくよ。

constexpr std::string s="test";
constexpr std::wstring ws=L"test";

こいつらが通らない時点で俺は諦めた
最終的にほしい型はstd::wstring_viewだろうけど
std::array<wchar_t, size>ならなんとかなるかもしれん

そもそもウクライナに寄付しろとか言う前に他民族、多言語に対応しろとmagic_enum作者にメールすべき。

違うだろｗ こいつが動かせてないだけだろｗｗｗｗ

>>399
まさにnameofと同じ作者のものだけど、やっぱ__FUNCSIG__の部分からLつけていくしかなさそうだな

まだ動かせないんかいｗ

L##

C##

一応言っておくと__FUNCSIG__はリテラルじゃなくてシンボルだぞｗ
>type hoge.cpp
hoge(__FUNCSIG__);
>cl /P /std:c++17 hoge.cpp
Microsoft(R) C/C++ Optimizing Compiler Version 19.28.29912 for x86
Copyright (C) Microsoft Corporation. All rights reserved.

hoge.cpp

>type hoge.i
#line 1 "hoge.cpp"
hoge(__FUNCSIG__);

>
なんというか...ロクに動かせもしないアホが一足飛びに余計なことして普通なら瞬間に出来ることを他人様に何度も何度も聞いて回るというねｗ

>>407
>__FUNCSIG__ 外側の関数のシグネチャを含む文字列リテラルとして定義されます。
直接Lは付けられないが#define L(x) L##xを使えばちゃんとワイド文字リテラルとなる
ついでに言っておくとVSのこの手のマクロはANSIではなくUTF8だったと思うぞ（固定ではなくソースコードの文字コード依存の可能性あり）

utf8は正解なんだが、リテラルは不正解ｗ
https://godbolt.org/z/4G1vvhrEc
コンパイラがリテラルに置き換えるわけだけど、プリプロセッサではシンボルのままなので置換されると分からなくなるｗ

MSVCの場合 /execution-charset で指定した文字コード（デフォルトはsjis=cp932）になるんじゃなかったかな

未指定時はソースと同じらしい
https://docs.microsoft.com/ja-jp/cpp/build/reference/execution-charset-set-execution-character-set?view=msvc-170
でutf-8になってたようだな

ただし、__FUNCSIG__はそういうのに影響されずutf-8っぽい
普通のリテラルはちゃんとシフトJISで出るけど、__FUNCSIG__はutf8だな

ややこしいな、そういうのが一番困るんだよねw

MSにありがちｗ ただシンボルに日本語とかキチガイしかしないからｗ

>>414
だって規格で認めてるじゃん
ISO/IEC 14882:2020(E)
12.8 User-defined literals [over.literal]
8 [Example 1:
template <char...> double operator "" _\u03C0(); // OK: UCN for lowercase pi

引用が仕様ですらないし、引用元もないし、、、挙げ句内容的に__FUNCSIG__はシグニチャ付きの関数名がリテラルとして入るだけだぞｗ
その関数名に日本語使うのキチガイだけだろｗ
リテラル調べてどうするんだよｗ

関数名の一部ってことわかんない？

君に何かを理解してもらうのは諦めるよ
俺の力では無理

捨て台詞にしてももうちっとくらいマシなこと言えねえの？

>>395
初心者だけどこれってプログラム内の変数名や関数名に日本語を出したいってこと？
あ = 3;
みたいな

規格上はもうUnicodeの文字はだいたい使えるぞ
移植性やコーディングスタイルや常識の観点での良し悪しは別にして

>>420
俺抜きでレスバしてて恐縮だが
enum class AIUEO { あ, い, う, え, お };
const wchar_t* aiueo[] = { L"あ", L"い", L"う", L"え", L"お" };
enumに合わせてこんな感じで文字列も欲しいってこと
utf8からutf16へのエンコードは割と簡単に実装出来るという事が判明して、200行くらいかかったけどconstevalなu8_to_u16関数作ってmagic_enum::detail::n部分からwide版作っていくことで解決できた

ええやんプルリクしといてよ

いいけど既に同じようなissue出してる人いて「constexprに文字列返されるので別の形にしたいならそっちで自由にやって」みたいな感じだったからな

これだから白人は嫌なんだよね。

昔からキチガイがシンボルに日本語使ってたりしたし、規格仕様の該当項目も挙げてないのに可能というのはおかしく
またソースコードや出力設定が何かに依るのが正しい可能性だって普通にある
またutf8というかunicodeとそのエンコーディング形式は簡単な計算式で可換
200行あればvc++固有ならmagic_enumの使用機能全て載せられるし、そもそも不要
そもそも情報小出しな時点、puts使ったりしてる時点、vc++を好き好んで使ってる時点でもうね・・・
挙げ句説明なくても5分もあれば気づくことに何日かかってるのかって人のプルリクが通るわけないだろｗ

>>425
まぁ面倒だからってよりこのスレにもちらほらいるようにASCII文字だけを想定してて
それだけなら1文字づつキャストするだけで簡単に出来るだろうしusing string_view = std::string_viewの所を上書きできるようにしておくから自前でやってって感じだな

「ASCII文字だけを想定してて」ｗｗｗｗｗ

マクロ騒動で脳が破壊されてしまった子がいるね

SEXの時は動かずにマグロになってしまったようですね
やっぱりロボトミー手術してよかったですね

>>422
はえー解決したなら良かった
まだまだ勉強不足だから半分理解できなかったけどconstexprはstring_view型なら使えることは学んだ

はいはい、一人何役するのかねｗ

>>432
我々ギフハブがいつも見ているぞ

テンプレートの可変長引数って一般的な実装だとスタックに積まれるの？
てことはあんまり大きいデータは渡せない？

template-parameter-packは実行環境では普通の引数と全く同じだ
翻訳中の解釈でどんな「普通の引数」にするか判断してるだけ

template<class...T>void f(T...t){}

f(1,2,3,4); で実体化されるf<int,int,int,int>は、
void f(int,int,int,int){}
と同じ扱いをされる。
普通の関数と変わらんよ。

たぶん気にしてるのはこんな感じの再帰実装だろう
template<class First>auto sum(First first){return first;}
template<class First, class Second, class...Rest>
auto sum(First first, Second second, Rest...rest){
return first+sum(second, rest...);
}
sum(1,2,3,4,5,6,7,8,9);

最適化なしコンパイルだとクソ真面目に45*sizeof(int)と9段分のリターンアドレスとか諸々をスタックに積む

最適化ありコンパイルなら大体インライン展開されるからさほど大事にはならない

#include <utility>
template<class First>auto sum(First first){return first;}
template<class First, class... Rest>
auto sum(First first, Rest... rest){
return first+sum(rest...);
}
template <class T, T... Seq>
auto sum_seq(std::integer_sequence<T, Seq...>) {
return sum(Seq...);
}
int main() {
return sum_seq(std::make_index_sequence<100>());
}
こんな感じになるよ
https://godbolt.org/z/obj4ra671
途中経過のテンプレートも全て関数実体として展開される
最適化すると、この例だと全部定数で計算されるけど

流石にちょっと説明追加しておきます。
sum_seq(std::make_index_sequence<100>())の部分は
sum(0,1,2,3,...,97,98,99)と同じです。
sum(0,1,2,3,...,97,98,99)は
sum(0) + sum(1,2,3,...,97,98,99)で計算されます。第2項の
sum(1,2,3,...,97,98,99)は
sum(1) + sum(2,3,...,97,98,99)で計算されます。第2項の
sum(2,3,...,97,98,99)は
...
sum(98,99)は
sum(98) + sum(99)で計算されます。
つまりすごい再起的に呼び出してバカ正直に壮絶な計算をするため、スタック消費も大きいということ。

おれおれtemplateの例ですね。

普通はテンプレつかった可変引数でも、イニシャライザでforで回して足して終わりっしょ。
なぜ自分で再帰にして書くのやら。

>>440
一般には可変長テンプレート引数の型が一律とは限らないので

>>440
initializer_listは実行時の解釈なので
翻訳時に全てを解決できるテンプレートを使っていて
それが出てきてしまうと残念な気持ちになる

constexprでやればいいじゃん

なんでもtemplateにしたい病なんですよ。プロジェクトで一番迷惑なタイプです。
おれおれtemplateは可読性、保守性が一気に落ちるので勘弁してください。

読む方は溜まったもんじゃないが書くのも実行速度もなんだかんだテンプレートが一番早いんで…

>>444
純コンパイラ方式の言語を使ってるのに
中間コードを使わにゃならんところが出てくると
残念な気持ちにならん？

もっと極端に言うとアセンブラからBASICやBATを呼び出すようなこと
人それぞれで何も感じない人っているのかね

例えばさっきのシーケンスをランダムな数字をその場で生成みたいな感じにすると、
#include <random>
#include <iostream>
#include <utility>
using namespace std;
template<class First>auto sum(First first){return first;}
template<class First, class... Rest> auto sum(First first, Rest... rest){return first+sum(rest...);}
template<class... Args> auto print_and_sum(Args... args) {
for (auto e: {args...}) cout << e << endl; // ココ
return sum(args...);
}
template <typename F, size_t... Seq> auto gen_and_print_and_sum_impl(F func, index_sequence<Seq...> ) {
return print_and_sum(func(Seq)...);
}
int main() {
random_device seed_gen;
mt19937 engine(seed_gen());
const size_t n = 3;
cout << gen_and_print_and_sum_impl(
[&](size_t i){ return engine();},
std::make_index_sequence<n>{}) << endl;
return 0;
}
こんな感じになるけど、genとprintとsumを分けたいとなるとtupleにしたくなって、templateでparameter packとtupleを行き来することになり、結構煩雑になる気はする
今は分けずに初期化リストにぶち込んで誤魔化してるけど…
こういうのも分けてtemplateにする？

>>446
加算するだけの処理でtemplate使わない場合
どういった中間コードが作成されるのですか？

ちなみに分けてテンプレートにしてみた。もう1レスに収まらないので消えたらごめんｗ
https://godbolt.org/z/YoxG7b4ro

#include <random>
#include <iostream>
#include <tuple>
using namespace std; // 余計なコード消したらギリギリ入ったｗ
template<class First>auto sum(First first){return first;}
template<class First, class... Rest> auto sum(First first, Rest... rest){return first+sum(rest...);}
template<typename T, size_t... Seq>
auto sum_tpl_impl(const T& tpl, index_sequence<Seq...>) {return sum(get<Seq>(tpl)...);}
template<typename... Types> auto sum_tpl(const tuple<Types...>& tpl) {
return sum_tpl_impl(tpl, make_index_sequence<tuple_size<tuple<Types...>>{}>{});
}
template <typename T, typename F, T... Seq> auto gen_impl(F func, index_sequence<Seq...>) {
return make_tuple(func(Seq)...);
}
template <size_t N, typename F> auto gen(F func) {
return gen_impl<decltype((func)(0))>(func, make_index_sequence<N>{});
}
template <typename T, size_t... Seq> void print_impl(const T& tpl, index_sequence<Seq...>) {
for (auto e: {get<Seq>(tpl)...}) cout << e << endl;
}
template <typename T> void print(const T& tpl) {
print_impl(tpl, make_index_sequence<tuple_size<T>{}>{});
}
int main() {
random_device seed_gen;
mt19937 engine(seed_gen());
const size_t n = 3;
const auto tpl = gen<n>([&](size_t i){ return engine();});
print(tpl);
cout << sum_tpl(tpl) << endl;
return 0;
}

>>450
ちょっとバグってたので修正
template <typename F, size_t... Seq> auto gen_impl(F func, index_sequence<Seq...>) {
return make_tuple(func(Seq)...);
}
template <size_t N, typename F> auto gen(F func) {
return gen_impl(func, make_index_sequence<N>{});
}

>>451
言われた通りにやればいいやん

>>451
<algorithm>を見てみ。便利な関数があるから。

「STLアルゴリズム」の課題だからSTL使えばいいんだもんな…
自分でアルゴリズム実装しろって課題だったらちょっと面倒だが

>>453,454
ありがとうございます。
std::for_each()なんてのがあるんですね・・・

キャプチャモードを指定してあげれば…

>>458
ありがとうございます。以下で通りました！
[&out](const Hoge& hoge){ out << hoge; }

keyの値はコンパイル時に決まるん？

>>461
そうですね。
今のプログラムでは、main関数で sort_by_key("a"); のように呼び出しています。

>>463
やっぱそうですよね。
私も sort_by_keyを廃止して、sort_by_a と sort_by_b を作るくらいしか
思いつかないです。

ポインタとか文字列の勉強をしていてよくわからなくなってしまいました

char* test(char* &s){
　char* ans=“B”;
　s[0]=‘C’;
　s=ans;
　return ans;
}

int main(int argc,char *argv[]){
　char s1[]=“A”;
　char* s2=s1;

#if 1
　cout<<s2;
　cout<<test(s2);
　cout<<s2;
#else
　cout<<s2<<test(s2)<<s2;
#endif
　
　return 0;
}

上のようなものを動かす時、#if 1のときはABBと表示されて、#elseにするとBBCと表示されます

#elseのように一行にまとめた時に何が起こっているのかよくわからないので教えていただけると嬉しいです

よろしくお願いします

ポインタじゃなくて評価順の問題なのはわかるが
何が起きてるのかは俺もようわからん

char*&なんて20年C++プログラマやってて一度も使ったことないわ…
どういうときに必要になるん？

必要ないとは思うんですけど、理解を確かめるために色々試していたって感じです

>>467
おっちゃんやん

あーわかったけど説明めんどくさいな

とりあえず、if 1では１行ずつ評価（今の場合表示と読み替えても良い)が行われてるが
2行目の場合、評価（表示）の前に途中で関数が実行されて、値が書き換えられている、とだけ

コレ質問してるのもおっちゃん臭いんだよな
いつもVC++だし、MFCみたいな書き方するし

誤 2行目の場合→正 elseの場合

>>469
おう、最近白髪が気になってきた

そして答えてるのも同じおっちゃんｗ

そもそもそんな怪しいコーディングは普通のC++プログラマはしないから
warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]

文字列リテラルの型は const char[] だが、 C++03 時代は const をはがして char* に (暗黙に) 型変換することが許されていた。
文字列リテラル限定の特別な型変換規則。
C++11 以降ではその規則は削除された。
C++03 時代でも非推奨なんだけど昔の本だとちょくちょくやってるんだよなぁ。
俺は持ってないから知らんけどロベール本とか有名な本でもそういう記述があるらしい。

ロベール本は<iostream.h>とか書いてあったしC++03ですらないんじゃない？

>>470
すみませんやっぱりよくわからなかったです
アドレスとか調べてみてみました

元の初期化されたばかりのs2を�@、ansを�Aとします

•#if1において
最初の(1行目の)s2は�@を指している
最後の(3行目の)s2は�Aを指している


•#elseにおいて
最初の(左の)s2は�Aを指している
最後の(右の)s2は�@を指している

どうやらこうなっているようなのですが、なぜ逆になるのでしょうか？

>>471
VC++以外のがLinuxおじさんってイメージがある
実際ワイは平成2桁生まれやけどVC++しか触ったことないわ
Windowsじゃないとゲームしづらいし

そんな調べれば一瞬で分かるようなこと自分で調べろよおっさんｗ

お前の間違いをいちいち指摘するのは最近もう面倒ｗ ヒントはあげたしｗ

あなたには聞いたつもりはないのですけど…

どいつもこいつもおっさん

おっさんって大体C++17以降アレルギーもってるよな
言語の進化に付いていくのをやめると新機能への愚痴ばかり言う老害になっちゃうんだよな
ああはなりたくないからC++40くらいまでは初心を忘れず学習し続けると心に誓うわ

WinXPをサポートしている最新のC++規格となると選択肢が少なくなるのが嫌になる。

Rustに変わるのでは？

linuxだとgcc 9か10がデフォルトだし、9,10のデフォルトのc++標準は14だから
現状17,20は断らないと使えないので、自分で使う分以外は可能なら11、無理でも14までにしたいというだけ
VC++2022を除き20はデフォルトだと使えないので、自分で使う分でも20は滅多に使わない
twitterとかで記事を見かけたら23までは内容見たりするけど、自分で追っかけるのは17まで、興味があれば20までかな
23だとrangeがすごいことになってるみたいね

>>478
評価の順と関数の実行が同じとは限らない。
だったかな

要するに　cout<<s2�@<<test(s2)�A<<s2�B;

君の考えでは�@の評価、関数test(s2)�Aが実行されtest(s2)�Aの評価、最後にs2�Bが評価される、だろうけど
実際には先ににtest(s2)�Aが実行され、その後s2�@の評価、test(s2)�Aの評価、s2�Bの評価と続く
って感じと思う

>>478
言語バージョンはいくつ？
逆になってるというよりC++17未満だと#elseのほうの評価順は未定義だからてきとーになってるってことだと思うが

LinuxでDirty Pipeの脆弱性が出たからバージョンアップしとけよ。

>>488
>>489
ありがとうございます

https://cpprefjp.github.io/lang/cpp17/expression_evaluation_order.html
それっぽいのを見つけたので詳しく読んでみたと思います

言語のバージョンは多分C++11てやつです
GCC4.4.0のコンパイラーでした
本の付録についてきたものですが、結構古いやつだったみたいです

コンパイラー新しくすればもしかしたら動くのかもしれないですけど、あんまりこういうことはしないほうが安全なんでしょうかね

>>478
この手の副作用が2つ以上現れるような動作は未規定か環境依存か未定義動作だったりを疑わなきゃいけない

cout<<s2<<test(s2)<<s2; の評価順序は規格で決まってる？
Noならコンパイラの気分次第で変わったりする。

何が起きてるかを知るにはコンパイル結果の逆アセンブリを見るのが一番手っ取り早い

ちなみにVC++だと2019のオプション指定なし(C++17)で再現するんだけどねｗ

あ、14だったｗ
https://godbolt.org/z/fcPT6jjhf

gccは9でデフォルト(c++14)指定でも再現しない

おまえもうハゲ始めてるのに何若者のフリしてんだよw

なんやおっさんが書きこんだらあかんのか
おっさんがC++やったらあかんのか、ええおい！

今どきこんなスレ見てるのおっさんしかいねーよｗ

もう5ch自体がオッサンのすくつやしのう

>>499
YouTubeで動画投降して、視聴者の年齢層を見てみたら、100人以上ユニークユーザー
数がいるのに、なぜか、45〜54歳が 100% になっていた。
日本にはこの年齢しか存在せず、後は幻影であることが明らかと成った。

URLを提示しないと何とも・・・内容次第では？

>>484
昭和生まれだがclangが未だにstd::pmr::memory_resourceに未対応なことに怒ってるぞ
(experimentalにあるがほとんど実装されてない

昭和ってことは戦争体験したんですね

生家のすぐ隣が根岸の米軍住宅だったのが俺の最も古い記憶だな