C++相談室 part162

**sage** (ﾜｯﾁｮｲ fbf0-ofdD) · 2022/10/31(月) 14:29:35.57

!extend:checked:vvvvv:1000:512
!extend:checked:vvvvv:1000:512
↑同じ内容を3行貼り付けること

次スレは>>980が立てること
無理なら細かく安価指定

※前スレ
C++相談室 part161
https://mevius.5ch.net/test/read.cgi/tech/1653135809/

VIPQ2_EXTDAT: checked:vvvvv:1000:512:: EXT was configured

2022/11/10(木) 12:40:22.21

なんか書き込んでからどっちもコンパイル通らないような気がしてきた
忘れてくれ

2022/11/10(木) 13:04:32.16

>>38
その場合は曖昧だって怒られるだけ

2022/11/10(木) 13:24:31.23

初期化子をコンストラクタのオーバーロード候補(静的に決まる)にそれぞれ適合させてみて、どれもダメならエラー、複数当てはまるなら優先度に従って1個に絞れたらそれを選択、曖昧ならエラー

初期化子や優先度の複雑怪奇なルール詳細の事ならともかく、この大枠の話の何がそんなに原則外れで難しいと思ってるのか正直さっぱりわからない

2022/11/10(木) 13:24:55.21

>>37
[補足4]
fという名前だが仮引数の型が異なる持つ関数f()が複数ある場合は、
f(a);
と書いた場合、aの部分が完全に意味解釈されて、aの型が完全に決まってから、
どのf()が呼び出されるかを選択。
選択されたf()の仮引数の型Tと実引数aの型を比較して、異なっていれば、
aの型をTに変換する変換関数を呼び出し、変換後の値を関数f()の引数として
関数f()を呼び出す。

ところが、初期化子の場合、
T v = b;
と書くと、bの型を軽く調査するが、完全には b が意味解釈される前にどの T のコンストラクタ
を呼び出すべきかの調査が始まる。その時点では、bの型は完全には決まってない。

2022/11/10(木) 13:28:29.70

>>41
>初期化子をコンストラクタのオーバーロード候補(静的に決まる)にそれぞれ適合させてみて、どれもダメならエラー、複数当てはまるなら優先度に従って1個に絞れたらそれを選択、曖昧ならエラー
Tのどのコンストラクタを使うかが決まるまでは、初期化子の中身の型が決まりません。
なので、総当り的にチェックすることが不可能だということになります。
(原因と結果が逆なので)。
なお、Tのどのコンストラクタを使うかを決める際に、初期化子のある程度の様子は
必要になりますのでややこしくなっています。

2022/11/10(木) 14:13:26.85

>>36
関数だって定数（もしくは定数になる式）渡したら変換関数なんか呼ばずに変換後の値を渡すようにコンパイルするだろ

2022/11/10(木) 15:49:32.45

>>43
型が決まらないって何のこっちゃ
君の例だと"David Hyme"はconst char*だし123456はintだし、
{"David Hyme",123456}はEntry(に集成体初期化で暗黙変換可能)で、他の要素も全部そうだから初期化子全体はinitializer_list<Entry>(に暗黙変換可能)なのでvector(initializer_list<Entry>)が適合可能、って全部静的に決まる話だぞ（正確にはもっとややこしいけど）
どこに動的型が出てくると思った？

2022/11/10(木) 21:41:21.36

自分の認識と実際の動作の間に食い違いがあることを質問したのに
その認識の間違いを指摘されても認めたくない人って厄介だね。

2022/11/10(木) 21:44:22.55

プログラムは書いた通りにしか動かない

って奴だな

2022/11/10(木) 21:59:32.65

自分の認識の通りのコンパイラを作るってんならご自由にだが
そうでない以上認識を改める他なかろう

2022/11/10(木) 22:00:55.26

依存性逆転の原則または依存関係逆転の原則

2022/11/10(木) 22:21:23.00

>>45
動的な型のことは一切言及していません。
私のIQは170以上あるので、普通のプログラマには質問の意味が理解できてない可能性があります。

2022/11/10(木) 22:22:55.08

2ch/5chでレベルが高い質問をすると、バッシングを受ける傾向が有ります。

2022/11/10(木) 22:23:43.35

頭が良い人なら、馬鹿にも分かる説明も難なくこなすんだがなぁ
自称してるだけの馬鹿なら意味不明な話を相手の理解力のせいにするんだよなぁ

2022/11/10(木) 22:25:12.06

>>45
例えば、class定義の中身Xが同じでも、class A {X} と class B {X} では別の型です。
その意味で、型が決まってないのです。
繰り返しますが、あなたはC言語の基礎が理解出来てないか、または、IQが
この質問に対して足りてない可能性があります。

2022/11/10(木) 22:26:30.44

>>52
逆も有ります。
ちなみに、私は実世界で天才だと言われたことが何度も有ります。

2022/11/10(木) 22:29:41.43

>>53
[補足]
{"aaa",1234}は、>>28のEntryとよく似た方では有りますが、コンパイラ内部では
Entryとは認識されません。仮に、
struct EntryB { const char *name, int number; };
とすれば、{"aaa",1234}は、中身の型としてはEntryBと全く同じと言えますが、
EntryBではないのです。
これが理解できないならば、C言語の基礎が理解出来てないので、質問の
意味が理解できないでしょう。

2022/11/10(木) 22:34:40.81

なお、数学的な言葉に慣れてない人は私の質問が哲学的な抽象論の様に聞こえて
頭が悪い人が変なことをいっているように聞こえたかも知れません。

2022/11/10(木) 23:38:43.51

>>53
>例えば、class定義の中身Xが同じでも、class A {X} と class B {X} では別の型です。

nominal typing な世界ではたしかにAとBは別の型だが無名の{X}はAとBどちらにも一致する。

2022/11/10(木) 23:56:40.35

>>54
最近は体調どうよ

2022/11/11(金) 00:01:29.20

あー君が何を勘違いしてるのか分かってきた
「初期化子`{"aaa",1234}`の型」というものがあると勘違いしてるんだな
こいつは「const char*とintの要素が並んだ波括弧初期化子」であってこれ全体が型を持ってるわけじゃない
あくまで「Entryを初期化（暗黙変換）出来る初期化子」「EntryBを初期化出来る初期化子」でしかなくて、これ自体をEntryとかEntryBとかそのものだと思いこんでるのが君の根本的な間違いだ
（関数呼び出しfoo(1,2);の(1,2)だけ取り出してこの型は何だ？と聞いてるのと同じようなものでナンセンス）

初期化子の仕事はあくまで初期化なんだから、同じ文字列の初期化子でもその初期化対象の型（が許している初期化方法）によって意味は変わる
Entryのようにstringとintを持った構造体なら集成体初期化になるし、
(const char*, int)の引数を取るコンストラクタ(非explicit)の呼び出しにもなるし、
initializer_list<Foo>（Fooはconst char* とintの両方から暗黙変換できる型）にもなれる
なれるというか、初期化対象型のコンストラクタオーバーロードに対して一番適合するものを探し出す（無理ならエラーにする）のがコンパイラの仕事で、当然全部静的に決まるようになってる
こういう風に同じ波括弧にいろんな解釈方法を持たせることで初期化を柔軟に書けるようになってるわけだ（C++11で導入されたuniform initialization）

キチガイみたいだから優しく教えるのはこれで最後にする
すまんかったね

2022/11/11(金) 00:16:31.96

>>59
型を持ってるわけじゃないのは当然なのに、あなたが「動的型」というこっちが
言ってないことを勝手に妄想しだしたので、基礎から解説したまでです。
こっちの方が圧倒的に頭がいいので、食い違うのです。

2022/11/11(金) 00:17:28.31

馬鹿は自分が馬鹿だと気付かないんです。
質問の意味すら分かってないのに質問に答えようとしてくる。

2022/11/11(金) 00:22:09.88

>>59
このような場合にC++では型が静的に決まるのは当たり前。
あなたこそ、動的言語を前提にしているように思える。
そういうことではなくて、コンパイラが内部でどのような順序で「静的に」翻訳作業を
行なっているかを質問している。
コンパイラ内部では型を持って無くても、構文ツリーや色々な形でデータを
持っているが、仕様では、その順序までも決まってないとコンパイラで非互換性が
出てきてしまうし、何より、C++では演算子のオーバーロードなども出来る訳
だから、コンパイラの内部的な解釈の順序まで厳密に仕様化されてなければ、
一般プログラマも混乱が生じる。
その事を聞いている。

2022/11/11(金) 00:26:17.38

>>62
[補足]
JSなどの動的で初心者ならば、「大体」で理解していればそれで問題無い事が
多いだろうが、C++では、テンプレートもあればoperator+()演算子や型変換
演算子などをオーバーロードできるから、「大体」では駄目で、非常に細かな
コンパイルの順序や解釈の流れまでが言語の仕様書に厳密に書いてなければ
正しいアプリケーションコードを書くことが出来ないことがある。
「直感的に簡単に理解できるのに、何この馬鹿は聞いているんだ？」
などと思っているとすれば、大間違いだ。

2022/11/11(金) 00:28:53.35

質問はしたのだから、回答を待っていればいいだろうに
何でまた独り言を延々と書いてるのか、不思議だ
書くなら自分の日記帳に書けばいいのでは

2022/11/11(金) 00:32:42.01

>>63
[補足]
>>28で、phone_bookの初期化子について、「直感的に」理解できたら
それで十分、などと考えている人は、馬鹿なので質問には答えないで下さい。
C++コンパイラは、そのように大体で動作しているのではなく、パターン
に当てはめて順序を追ってコンパイルを進めていきますが、その順序や
解釈の仕方がC++03の時代とはかなり違っているように思えたから
質問したのです。
例えば、>>28は単なる例であって、これの応用として非常に複雑なコードを
書いた場合でも、コンパイラはなんたかの単純な法則に従って厳密に翻訳していきます。
その正確な規則が分からないから聞いているのです。

2022/11/11(金) 00:33:22.29

>>64
馬鹿な人が茶々入れしてきたので、排除する努力をしています。

2022/11/11(金) 00:40:51.17

>>59
>Entryのようにstringとintを持った構造体なら集成体初期化になるし、
今回の例では、vector<Entry>型の初期化ですので、そんな単純ではありません。
vector<T,A>テンプレートのコンストラクタが呼び出されるはずです。
しかも、コンストラクタの種類が沢山ありますから、それを選ばなくてはなりません。
Entry a = {"xxx",1234};
ならば集成体初期化ですから、コンストラクタを選ぶ工程は無いはずですから、
比較的単純です。
ところが、今回の場合は、コンストラクタの選択から始まります。
しかし、初期化子自体の型が中途半端な状態でコンストラクタを選ぶ必要が
ありそうなので質問しているのです。

C++03で、x+y書いた場合、xとyの型が決まった後で、operator+(U,T)演算子を探します。
ところが今回の場合、初期化子の部分の型が中途半端な状態なので、コンストラクタを探す
ための手がかりが中途半端にしかないのです。

2022/11/11(金) 00:45:48.11

>>67
[補足]
CPerson person{"Suzuki", 25};
と書いた場合、CPersonのコンストラクタはすぐ探せます。
ところが、>>28 のように
vector<Entry> phone_book = {
　{"David Hyme",123456},
　{"Karl Popper",234567},
　{"Bertrand Arthur William Russell",2345678}
};
の場合、テンプレート vector<T,A> の中のコンストラクタを選ぼうとしても、
初期化子の{"David Hyme",123456}には、ある意味では「型が存在してない」ので
通常のように探すことは出来ないのです。

2022/11/11(金) 00:48:44.75

>>65
正確な規則が知りたいのに規格に当たることすら思いつかないのか自称天才のボンクラ様ってのは
9.4 Initializers [dcl.init]（C++20公開ドラフトN4861、正規の規格がいいなら自分で買え）を見ればいいよ
誰でも読めば分かるように書いてある規格を天才様が理解できないなんてありえないから以降質問禁止な

2022/11/11(金) 00:55:21.61

>>68
[補足]
vectorは配列と似ていますが、コンパイラの内部的にはかなり違う扱いになっていて、
Entry a[3] = {
　{"David Hyme",123456},
　{"Karl Popper",234567},
　{"Bertrand Arthur William Russell",2345678}
};
と書いたならば、コンパイルの翻訳過程は全く異なってきます。
この場合はとても単純で、
T a[N] = {XXX};
の形式は、配列初期化として特別処理されています。
なので、コンストラクタを探す工程、というものが必要ありません。
そして、{"David Hyme",123456} の型を知る必要も無く、単純に、
Entryのメンバに代入していくような処理となります。
この場合の処理は、まず最初に配列型として処理が入り、次にEntryの構造体型
としての処理が入ります。
これが理解できない人は質問には答えないで下さい。混乱の元になります。

2022/11/11(金) 00:56:13.87

>>69
そんな言い方されれば質問サイトの意味が無いわけです。

2022/11/11(金) 00:59:02.50

>>68
あまりにも馬鹿すぎて哀れだからもう1回だけ助け舟出してやる
いいか？vector<Entry>がどんなコンストラクタ持ってるか（どうオーバーロードされてるか）は決まってんだよ
vectorテンプレートを実体化した時点で静的に全部決まってんだよ
馬鹿なお前だって<vector>ヘッダを隅々まで読めば列挙くらい出来るのは分かるだろ
vector<Entry>のコンストラクタは例えばvector<Entry>()とかvector<Entry>(size_type)とかvector<Entry>(vector<Entry>&&)とかvector<Entry>(initilaizer_list<Entry>)とか色々あるわけだな（全部は挙げんぞ）
コンパイラ様はまずそれを列挙するわけだ。そして
・vector<Entry>()かな？→空じゃないからダメ
・vector<Entry>(size_type)かな？→{...}はsize_typeに変換できるかな？→ダメ
・vector<Entry>(vector<Entry>&&)かな？→{...}はvector<Entry>&&に変換できるかな？→ダメ
・vector<Entry>(initilaizer_list<Entry>)かな？→{...}はinitilaizer_list<Entry>に変換できるかな？→OK!
・...
ってひたすら一つずつ試すわけだ。で、vector<Entry>(initilaizer_list<Entry>)しか当てはまるものがないので、じゃあこれだとオーバーロードを解決するわけだ
コンパイラのやってることなんて基本的にこれだけだ、実に単純な話だ
こんな単純なこともわからずグチグチグチグチとお前は本当に無能だな

2022/11/11(金) 01:02:30.49

>>72
その探し方は、普通の関数のオーバーロード解決とは異なっていますね。
しかも、あなたの言っているほど単純じゃない。
実際は、優先順位があり、先に優先順位の低いものが見つかって、後から
優先順位が高いものが見つかっても、後の方が優先される。

あなたが馬鹿なのは、単純に考えすぎていることだ。

2022/11/11(金) 01:03:31.20

>>71
なんで答えが書かれた文書が誰でも読めるように公開されてるのに、わざわざ自分より劣った人間に答えを求めるの？
お前天才なんだろ？ここの誰よりも賢いんだろ？
消えな

2022/11/11(金) 01:04:06.86

>>74
すまんがお前が消えてほしい
相手するからつけあがる

2022/11/11(金) 01:05:05.21

>>73
[補足]
なお、関数のオーバーロード解決でも、「変換できるかどうか」とかそんな単純な
ものじゃないです。
例えば、T a{x} のように{}が書いてあれば、中味が1個しか書いてなくても、
initializer_list が優先される、などと決まってます。

2022/11/11(金) 01:05:24.11

>>73
だから正確なのが知りたいなら規格読めやボケカス
お前のゴミ虫みたいな脳みそに合わせてわざわざ単純化してやったのに何だその物言いは無礼者の恥知らずが

2022/11/11(金) 01:06:38.58

>>74
俺よりC++を知っている人だってこの世にいるから質問してる。
それでは質問サイトの意味がない。
調べればわかることでも知ってる人に聞いたほうが早い。

2022/11/11(金) 01:07:31.06

>>76
T a{x}ってそれ関数じゃなくて変数定義ですよ
そんな区別もつかないレベルじゃ規格書なんて早かったかなごめんね
でもそれも規格書に書いてあるから読んで勉強しろ

2022/11/11(金) 01:07:50.72

>>77
あなたみたいなのが日本を衰退させている。
自分が頭がいいと思い込んでいるがかなり間違ってるし、レベルが低い。
そして、あなたの周りにはレベルの低い人しか回りに居ないから勘違いが
直らない。

2022/11/11(金) 01:08:28.22

>>79
アホですか。
コンストラクタを探す話をしている。

2022/11/11(金) 01:09:07.49

>>78
ここで俺や他の人が説明してあげてる内容すら理解できないなら、規格書を泣きながら読むか死んだほうが早いと思うよ

2022/11/11(金) 01:10:04.92

日本は分断化が激しい社会だ。
カシコが一部に集まり、アホがあほ同士集まっている。
だから自覚できない。
そういう社会にしてしまっていることが問題。

2022/11/11(金) 01:10:52.44

>>81
1行目のせいで関数のオーバーロード解決の話をしてるもんだと思ったよ
どうやらC++以前に日本語すら不自由なようだね

2022/11/11(金) 01:11:25.32

>>82
お前は理解できてないのに質問に答えようとしている。
いつもは質問のレベルが低いから答えられているんだろうが、今回は
お前の能力を超えている。
そしていつもの調子で質問者をレベルが低いと思い込んでいるから
馬鹿にした態度をとる。

2022/11/11(金) 01:11:57.99

>>84
お前に言われたくない。

2022/11/11(金) 01:14:33.80

>>82
「してあげている」
って、おまえの思ってる直感的理解と、俺の求めている理解とは次元が違う。
お前は、いっぱんぴーぽーとしてC++を使えてもそれ以上はできないだろう。

2022/11/11(金) 01:16:18.16

もう終わりにするけど、俺の説明が間違ってるって言うならそれは規格と主要コンパイラの実装が間違ってるってことだから
ISOとベンダーに報告しときなよ

>>75
ごめんなさいみなさん久しぶりに面白いおもちゃだったのでつい

2022/11/11(金) 02:19:52.16

キャラ剥がれてきてて草

2022/11/11(金) 05:29:55.03

std::array<T, N>って「N個の値xで埋める」コンストラクタありませんよね？
後でstd::fillするのが普通のやり方かもしれませんが、実際はstd::arrayのインスタンスができた時点でN個の何らかの初期値が入るんですよね？
この仕様に困ってます。
例えば、boost::multi_arrayは構築時にメモリの並び方 (Cライク or fortranライク) が決まって、後で変更する方法は提供されてないんですが、 std::array<boost::multiarray, N> を作ってしまうとメモリの並び方が勝手に決まってしまいます。
std::array の各要素のコンストラクタをこちらで呼ぶ方法があったら教えてください。
初期化リストで構築するやり方はNが大きいときは現実的でないので考えておりません。

**デフォルトの名無しさん** (US 0He2-r8ZE) · 2022/11/11(金) 07:32:36.01

>>54
逆はないと思いますよ

2022/11/11(金) 07:44:40.78

>>90
残念ながらarrayで初期化時にやるのは無理
arrayは組み込み配列と同じ初期化方法（集成体初期化）しか出来ないように意図的に設計されてて特別なコンストラクタを持たない
だからarray::fill()が用意されてるので普通はそれを使う
どうしてもその場で要素のコンストラクタを直接呼びたいなら一回構築してから要素ごとにデストラクタ→placement newを呼ぶしかない
最初のデフォルト構築も許せないならarray（と組み込み配列）を使うのは諦めよう

2022/11/11(金) 15:28:43.83

>>91
いくらアインシュタインが相対性理論を説明しても、一般人には理解できない。
どんなに天才でも、説明できない事柄がある。

2022/11/11(金) 19:19:22.94

天才ほど説明が下手だね
天賦の才に頼らず這い上がった苦労人タイプの
説明のほうが一般人には分かりやすい

2022/11/11(金) 20:11:09.74

わかった気になるだけってやつね
完全に理解する必要のない一般人ならそれもあり

2022/11/11(金) 20:47:56.26

誰かを見下していなきゃ自分を保てない小さいやつ

2022/11/11(金) 23:42:57.00

確かに右辺値参照あたりの仕組みはコピー減らそうという意図が感じられる割に徹底しようとするとstd::arrayとかのctorで足元すくわれがち

2022/11/12(土) 01:01:47.32

ワッチョイつけると炎上しなくて良いね

2022/11/12(土) 07:48:03.70

arrayは組み込み配列の糞さ緩和が目的なので糞が多少まろび出るのは仕方ないんよね

2022/11/12(土) 09:59:28.06

>>92
collectionで初期化も無理なんだ？
せめてvectorで初期化できるなら良かったのにね

2022/11/12(土) 11:30:02.52

1つでもコンストラクタを独自定義したら集成体になれないので仕方ない

2022/11/12(土) 14:25:39.92

>>90
要素のデフォルトコンストラクタは呼ばれるので要素のほうに適当なラッパーを被せるという方法はとれなくはない。
こういうラッパーならスタンダードレイアウトの要件は満たすのでバイト列レベルでも互換性は維持されるはず。

#include <array>
#include <iostream>

struct foo {
// このコンストラクタを呼んで欲しい
foo(int x){
std::cout << x << std::endl;
}
};

template <class T, auto N>
struct initializing_wrapper : public T {
initializing_wrapper(void) : T(N) {}
};

int main() {
std::array<initializing_wrapper<foo, 1> , 3> foo;
}

2022/11/12(土) 23:48:04.66

vscodeでeigen使ったコード書いてるんだけど、デバッグ時にeigenの変数見る方法ある？
visualstudioならあるっぽいんだけど、vscode上でしょりしたいんだよね

2022/11/13(日) 00:14:31.39

普通に変数ウォッチで見えんの？

2022/11/13(日) 04:06:31.61

ちょ、何これ？　聞いてないんだけど。。。

C:/msys64/mingw64/include/c++/12.2.0/bits/stl_pair.h:326:13: note: declared here
326 | pair& operator=(const pair&) = delete;

C:/msys64/mingw64/include/c++/12.2.0/bits/stl_pair.h:715:5: note: declared here
715 | swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete;

2022/11/13(日) 07:39:53.36

>>103
eigen一回も使ったことないしググってもないけど、行列の先頭要素のメモリにアクセスする方法が提供されてないわけないので、それを使う
普通はdata()とかget()なるメンバ関数がある

2022/11/13(日) 11:52:46.36

>>105
-std= で規格を指定するとか?

2022/11/13(日) 12:42:20.71

-std=c++20にしてる

2022/11/13(日) 14:31:41.33

>>105
本来使われるはずの定義はこっち。
https://github.com/gcc-mirror/gcc/blob/e24b430f1ea60205162fd9b327ac6a4dfc57f37c/libstdc%2B%2B-v3/include/bits/stl_pair.h#L371-L379

必要な性質 (要素の型が copy_assignable) が満たされていないときに最も優先度が低いやつが選択された上でそれが delete されているということになるんだと思う。
https://github.com/gcc-mirror/gcc/blob/e24b430f1ea60205162fd9b327ac6a4dfc57f37c/libstdc%2B%2B-v3/include/bits/stl_pair.h#L368

2022/11/13(日) 16:56:29.94

壮大なSFINAEってわけか・・・
元コードは晒せないんであとは自分で探すしかないな

ヒントありがと、餃子さん

2022/11/13(日) 18:18:04.90

どうせ使えないなら使おうとしたときに static_assert で問題点を出すようにしたらいいのにと思ったがよく考えるとそれは駄目なんだな。
適用できるものがないということを SFINAE のトリックに使うことがあるかもしれない。
(static_assert が展開されると他の候補があっても問答無用で終わりになってしまう。)

2022/11/13(日) 18:23:28.51

いつもサナエさんにはお世話になってる

2022/11/14(月) 12:10:20.06

>>94-95
天才とパンピーで理解レベルのバックグラウンド知識に差があるからだろ
その差を埋める説明を一瞬で出来る人はそれなりの才能があるとは思うが
天才同士ならそんな説明いちいちしなくても判り合えるんだ

2022/11/14(月) 19:05:49.95

天才はそもそも他人の説明なんかいらんからな

**デフォルトの名無しさん** (US 0Ha3-XgLS) · 2022/11/14(月) 22:27:38.95

自分が天才だ！とわざわざ自称しなくても、天才らしい雰囲気をかもし出せるレスはないものでしょうかね…
自称天才はもういいし

2022/11/14(月) 22:42:37.02

ギフテッドって凄すぎて訳わからんからな

2022/11/15(火) 12:36:06.45

プログラミング言語 C++ [第四版], 日本語訳の p.689 に、
template<typename T>
class Xref {
　・・・
};
template<typename TT, typename A>
unique_ptr<TT> make_unique(int i, A&& a)
{
　return unique_ptr<TT>{new TT{i,forward<A>(a)}};
}
auto p1 = make_unique<Xref<String>>(7,"Here");
「ここで、"Here"は右辺値なので、右辺値を引数にしてforward(string&&)
が呼び出される。」
とありますが、実引数の文字列リテラル "Here" が、make_unique()の
仮引数 A&& に渡そうとしたら、A = string と「演繹」されているようですが、
const char* 型が string に至るまでの仕組みか分かりません。
どなたが分かる人居ませんか？

実際の STL の sting は basic_string<U> テンプレートの U=charの
場合だと思われますが、意味を概念的に言えば、
class string {
public
// 変換コンストラクタ :
string(const char *) {・・・}
};
という「変換コンストラクタ」があるでしょうから、それが使われている
ことは推定は出来ます。
しかし、上記のテンプレートで T を演繹する際に、このような変換コンストラクタ
が呼び出されるメカニズムが分かりません(仕様書のどこに書いてあるのかが
分からない。)。

2022/11/15(火) 12:51:05.19

>>117
もっと詳しく書くと、直前から次のように書かれています:
# Xref<String>はXref<string>の写し間違いでした。
string x {"There and back again"};
template <typename T>
T&& std::forward(typename remove_reference<T>::type& t) noexcept;
template <typename T>
T&& std::forward(typename remove_reference<T>::type&& t) noexcept;
ここで望まれるのは、不純なコピーを一切作ることなく、
make_unique<T>(arg)がargからTを構築することである。
その実現には左辺値と右辺値の区別を管理することが重要だ。
次の例を考えてみよう:
template<typename TT, typename A>
unique_ptr<TT> make_unique(int i, A&& a) // make_sharedのちょっとした変種
{
　return unique_ptr<TT>{new TT{i,forward<A>(a)}};
}
auto p1 = make_unique<Xref<string>>(7,"Here");
ここで、"Here"は右辺値なので、右辺値を引数にしてforward(string&&)
が呼び出される。
そして、"Here"を格納しているstringのムーブを行なうために、
Xref(int,string&&)が呼び出されることになる。
# 個人の感想: これは、A=stringと考えられます。
もっと興味深い(しかも分かりにくい)のが、次のものだ:
auto p2 = make_unique<Xref<string>>(9,x);
ここで、xが左辺値なので、左辺値を引数にforward(string&)が呼び出される。
forward()のTは、string& と導出される。そのため、返却値は string & &&となる。
もちろんそれは string & を意味する(§7.7.3)。その結果、左辺のxに対して、
Xref(int,string&)が呼び出されて、xがコピーされる。
# 個人の感想: これは、A=string&と考えられます。

2022/11/15(火) 12:53:27.82

>>118
[参考]
p.724,
「文字列リテラルは、テンプレート引数には『渡せない』」
ただし、これがどう関係しているのかは不明です。
A&& a の部分に文字列リテラル"Here"を渡してはいますが。

2022/11/15(火) 12:56:01.43

ある型が来たらそれに応じた変換をするのが、何か問題なんでしょうか

2022/11/15(火) 12:57:17.27

make_uniqueの実体化の所でTT=Xref<String>、T=Stringって明示的に指定してるじゃん
「演繹」なんかするまでもないから規格に書いてるはずもない
天才のくせにそんな事も分からないの？

2022/11/15(火) 13:00:23.02

>>119
[ヒント]
前頁p.688の下段:
「左辺値と右辺値は、テンプレート引数の導出では区別される。
X型の左辺値はX&として導出されて、右辺値はXとして導出される。
これは、非テンプレート引数の右辺値参照への値のバインド
(§12.2.1)とは異なる。
しかし、引数転送(§35.5.1)においては、極めて有用だ。
Xrefを空き領域上に置いて、そのポインタをunique_ptrとして
返すファクトリ関数を記述する場合を考えてみよう:
」
の直後、ページが変わってページの最初に>>118の std::forward テンプレート
の定義が書いて有ります。

2022/11/15(火) 13:02:34.01

引用の範囲超えてるんで著作権侵害の疑いで削除依頼出しますね

2022/11/15(火) 13:03:00.86

>>121
TTは、Xref<string>と明示的に指定されてますが、AはTTとの関係は
書いて無いはずです。
なので、それだけでは、A=stringとは分からないはずでは。

2022/11/15(火) 14:16:43.16

new TT{i, forward<A>(a)}
既出だが、こう書いてあってもXrefのメンバの型がどうなるか分からんわけでしょ

先日の質問と合わせて、型パズルをスラスラ解けるような資質がない
資質がないんでXrefの『関係ない』としたところを「・・・」で埋めてる

2022/11/15(火) 15:01:57.79

>>117
どういう文脈で説明されてるのかよくわからんが
引数が文字列リテラルの "Here" なら A は const char (&)[5] に推論されるよ。

2022/11/15(火) 16:18:06.60

>>126
命題『A が const char (&)[5] に推論される』・・・☆
とし、背理法で考えます。
☆が正しいと仮定すると、
forward<A>(a)は、forward<const char (&)[5]>(a)となりますが、すると、
template <typename T>
T&& std::forward(typename remove_reference<T>::type& t) noexcept;
template <typename T>
T&& std::forward(typename remove_reference<T>::type&& t) noexcept;
に対して、forward<const char (&)[5]>(a)
が呼び出されることになります。
しかし、
>auto p1 = make_unique<Xref<string>>(7,"Here");
>ここで、"Here"は右辺値なので、右辺値を引数にしてforward(string&&)
>が呼び出される。
とBJ stroustrup氏が書いています。
ならば、T=const char (&)[5]の時に、
typename remove_reference<T>::type
がstringにならなければなりません。つまり、
typename remove_reference<const char (&)[5]>::type
がstringになってないと矛盾する事になります。
もし、矛盾するならば、背理法により、☆は否定されることになります。
(矛盾しそうです。)

2022/11/15(火) 16:42:50.09

>>127
これは背理法とは言わなかったわ。
スマソ

2022/11/15(火) 16:49:22.19

メロスはポリモーフィズムがわからない

2022/11/15(火) 17:18:50.72

Perfumeの楽曲だろ？

2022/11/15(火) 18:04:53.44

>>127
> ここで、"Here"は右辺値なので、右辺値を引数にしてforward(string&&)
> が呼び出される。

文字列リテラルは左辺値。右辺値だと書いてあるのならそれが間違っている。
配列がポインタに (暗黙的でも明示的でも) キャストされる文脈では
そのポインタは xvalue (おおよそ右辺値のような扱いになる分類) になるが、
今回は変換が入らずに参照で受けているのでそうはならない。

/// この場合は rvalue 扱い
#include <cstdio>
void foo(const char *&x) { std::printf("lvalue"); }
void foo(const char *&&x) { std::printf("rvalue"); }
int main(void) { foo("abc"); }

/// この場合は lvalue 扱い
#include <cstdio>
template <class T> void foo(const T &x) { std::printf("lvalue"); }
template <class T> void foo(const T &&x) { std::printf("rvalue"); }
int main(void) { foo("abc"); }

2022/11/15(火) 18:53:35.18

文字列リテラルが左辺値ってなんで？

2022/11/15(火) 20:56:02.85

文字列リテラルは実際は配列
⇒アドレスで区別できるメモリ上のオブジェクト
⇒つまりlvalue

2022/11/15(火) 20:56:58.78

文字列リテラルはメモリ上に永続的に保持されるんだから勝手に持ってっちゃダメでしょ

2022/11/15(火) 21:11:40.64

文字列リテラルは配列型のlvalue
文字列リテラルが左辺値変形されて生じたポインタはrvalue

2022/11/15(火) 23:54:26.84

配列 (文字列を含む) と関数は値として扱えない、勝手にポインタに型変換するという
C から引き継いだ変則的なルールに辻褄を合わせているので全体的に変則的で
分かりにくいんだよ……。

2022/11/16(水) 00:19:44.88

>>131
>auto p1 = make_unique<Xref<string>>(7,"Here");
>ここで、"Here"は右辺値なので、右辺値を引数にしてforward(string&&)
>が呼び出される。
と書かれています。
なので、"Here"がなんらかのメカニズムでstd::stringに変換されていると
解釈しました。
実験すれば白黒はっきりさせることが出来るかも知れません。

2022/11/16(水) 00:20:20.66

マジで間違った方向に引きずり回してんのか
やっぱりすげーな
こいつは上級者だ