X



結局C++とRustってどっちが良いの? 2traits
レス数が1000を超えています。これ以上書き込みはできません。
0001デフォルトの名無しさん
垢版 |
2023/04/02(日) 00:42:57.53ID:W9/nq+tL
「C++の色々配慮してめんどくさい感じは好きだけど、実務になったらメモリ安全性とか考えて今後Rustに変わっていくんかな」
「うだうだ言ってないで仕事で必要なのをやればいいんだよ、趣味なら好きなのやればいい」

っていうスレ。

前スレ: 結局C++とRustってどっちが良いの?
https://mevius.5ch.net/test/read.cgi/tech/1677286186/
0002デフォルトの名無しさん
垢版 |
2023/04/02(日) 00:51:09.64ID:LXNgvG55
世界的にインフラはRust製になりつつある

https://japan.zdnet.com/article/35183866/
Amazon Web Services(AWS)は、同社のエンジニアたちがプログラミング言語「Rust」を
使っている大きな理由として、エネルギー効率の高さを挙げる。
AWSは早くからRustを採用し、Rust Foundationの創設にも携わった。
現在もRustの普及に熱心に取り組んでいる。

AWSのソフトウェアエンジニアで、Rustの普及に取り組む
Shane Miller氏と主任エンジニアのCarl Lerche氏の投稿によれば、
Rustはメモリー安全性を高め、セキュリティ関連の不具合を減らす役に立つだけでなく、
PythonやJavaよりもはるかに「エネルギー効率に優れている」という。
Amazonは、2025年までにデータセンターの100%を再生エネルギーでまかなうという目標を掲げ、
データセンターの環境負荷の軽減に取り組んでいる。
Rustの採用はその一翼を担うという。

Rustで構築されたAWSサービスの例としては、
コンテナーアプリ用のサーバーレスプラットフォーム「Lamba」を支える「Firecracker」、
「Amazon Simple Storage Service(S3)」「Amazon Elastic Compute Cloud(EC2)」、
コンテンツ配信ネットワーク「Amazon CloudFront」、
LinuxベースのコンテナーOS「Bottlerocket」がある。

「CやRustが他の言語よりもエネルギー効率に優れていることに驚きはない。
衝撃的なのは、その違いの大きさだ。CとRustを広範に採用すれば、
控えめに見積もってもコンピュートに使用されるエネルギーの量を50%削減できる可能性がある」と
Miller氏は述べ、その根拠として、C、GoogleのGo、Lua、Python、Ruby、Fortranなどをはじめとする
複数の言語のエネルギー効率を相対的に示した研究結果を紹介している。
0003デフォルトの名無しさん
垢版 |
2023/04/02(日) 01:05:56.12ID:fga+vqS0
なぜ皆がC++を捨ててRustへ移行していくのか以前は不思議だったが
Rustも書くようになってようやく理由がわかった
色んな面で快適になっている
0004デフォルトの名無しさん
垢版 |
2023/04/02(日) 02:18:47.84ID:6FtsW5Qy
Rustは高機能に洗練されていて意外にコンパクトだね
C++では同じことを出来ないも多くて何とか出来ることもC++17やC++20の知識が必要で普及していなかったり
どちらにも新規な人ならRustの方が学習量が少なくて済むね
0005デフォルトの名無しさん
垢版 |
2023/04/02(日) 02:37:50.83ID:Xkdfgrgv
=== 複製おじさん(通称複おじ)について ===
Rustスレを中心に活動し、2023年4月現在で1年以上ム板に住み着くRustacean。無自覚な荒らし。

Rustスレでは、基本的に他住民の意見を聞いて糧とすることなく、自らのコードが最善であると、ID変更自演を交えいつまでも主張し続ける。
同スレで「所有権が複製される」という違和感のある表現を、「違和感がある」とする他住民の意見をすべて否定してしつこく擁護し続けたことから、「複製おじさん」というあだ名が付けられた。
それ以外のム板スレでは、基本的に他住民の意見を聞いて糧とすることなく、Rustこそが最善であると、ID変更自演を交えいつまでも主張し続ける。
その基本戦術は、「GC言語は遅い」の一声でC/C++/Rust以外の言語を否定し、残ったC/C++は安全ではないので、Rustが最善であるとするもの。

しかしながら、Rust以外の言語に関しては、正当な批判を展開するのに十分な知識を持っているとは言いがたい。
本スレPart1では、C++の問題点を指摘しようとして多数の誤り・知識不足を露呈することとなった。特にしつこく食い下がったのが「動的ディスパッチ」に関する誤解である。
https://mevius.5ch.net/test/read.cgi/tech/1677286186/786-799(ID:Evbafc70とID:RiLc+pIfが複製おじさんであると考えられている)
要約すると、通常「条件分岐」と呼ばれるものを「動的ディスパッチ」と呼ぶのが正しいと主張し続けたのである。
常識的にはあり得ない誤解だが、提示されたC++のコードが自らの主張(C++にはパターンマッチが無い)に不都合であると感じたためか、C++のコードを正しく読み解くことができないにもかかわらず脊髄反射的に否定してしまい、その根拠として誤った論理をこじつけてしまったものと思われる。

ちなみにこの後、同種の誤解を持って書き込むID:wHEiYRW7(これはID使用歴的に複製おじさんとは考えにくい)に対して、正しい理解に基づく指摘を行う単発IDが複数出現するが、この中にも複製おじさんが多数含まれていると考えられている。
このように自分の誤りを認識した場合、それを認める書き込みは決して行わず、別人の振りをして最初から正しく理解していた体を装うのも複製おじさんの特徴である。
0007デフォルトの名無しさん
垢版 |
2023/04/02(日) 02:43:43.18ID:zOLTjxu5
C++は確実に滅びる
各種安全性が保証されているRust製と穴を多発してきたC++製
企業や国自治体がどちらを選ぶか明らか
いずれ要件にも入るだろう
0008デフォルトの名無しさん
垢版 |
2023/04/02(日) 03:06:04.77ID:WdMf4Ye5
>>5
おいおい!処理を切り替えること一般をディスパッチ
その実装をディスパッチャと言うんだよ
ifやmatchなどの条件分岐はやっていることはディスパッチャだよ
実行時にやっているから動的ディスパッチ
仮想関数テーブルを介した関数の呼び出しの切り替えも動的ディスパッチ
一方で関数のオーバーロードによる切り替えは
コンパイル時に決まるので静的ディスパッチと言う
0009デフォルトの名無しさん
垢版 |
2023/04/02(日) 03:40:43.33ID:IfuIFZxt
GoogleとMicrosoftで脆弱性の70%がメモリー管理バグに起因のためRust採用
https://xtech.nikkei.com/atcl/nxt/column/18/00692/042700054/

Rustは、プログラムに必要なメモリーの確保や解放に関連するバグが生じない「メモリー安全」が保証されたプログラミング言語である。
それに対してこれまでのOS開発に使われてきたC/C++は「大規模な開発においてメモリー安全なコードを記述することがほぼ不可能」
(Microsoftのブログ「We need a safer systems programming language」出典)だという。

GoogleによればAndroidに存在した深刻なセキュリティー脆弱性の70%近くがメモリー安全に関するバグに起因するという。
同様にMicrosoftも、同社製品に存在したセキュリティー脆弱性の70%がメモリー安全に関するバグに起因すると述べている。
C/C++を使う限りセキュリティー脆弱性を根絶するのは不可能と考えて、Rustを採用するに至ったというわけだ。
0010デフォルトの名無しさん
垢版 |
2023/04/02(日) 06:32:11.07ID:kYGqyW3R
>「業界談義」、愚痴はプログラマー板へどうぞ。
板ルールが読めない池沼
そしてプログラム書けずにドヤ顔で役に立たない長文書くバカ
0011デフォルトの名無しさん
垢版 |
2023/04/02(日) 06:39:50.05ID:M90rTQGQ
大手IT企業は揃ってC++ではダメだと判断してRustへ移行しつつあるのに
底辺は真逆でRustはダメでC++に拘るのはなぜ?
0014デフォルトの名無しさん
垢版 |
2023/04/02(日) 08:05:56.68ID:O/tjJbYW
>>11
DQNだから言語的になんら優位性のないC++に固執している
過去の遺産だけはC++の優位性があるがそれすら時間とともに置き換わっていく
0015デフォルトの名無しさん
垢版 |
2023/04/02(日) 08:13:05.31ID:W9/nq+tL
Rustは難しくない。そうだろ?
大手が本格的に移行しはじめてからでも、全然遅かねえんだよ

ま、C++を捨てられないってのは、このスレだけの内緒だけどな!
0016デフォルトの名無しさん
垢版 |
2023/04/02(日) 08:16:48.61ID:W9/nq+tL
Rustに移行ってのは、採用された程度じゃ移行じゃない
APIに、Rustの所有権・マルチスレッド関係のシグネチャが付くようになって、ようやっとだ
その日はくる

そして、Rustの独占は揺らぐ
0017デフォルトの名無しさん
垢版 |
2023/04/02(日) 08:25:23.82ID:W9/nq+tL
C++を捨てたんなら、no_mangle とか、まさか、extern "C" とかいう呪詛を唱えてないよな?

移行っていう以上、そういうの要らないんだよ
C++が、こっちから適合してやっからよ
0018デフォルトの名無しさん
垢版 |
2023/04/02(日) 10:39:13.92ID:Xkdfgrgv
複おじはね、承認に飢えた構ってちゃんなのよ
この紛うことなきクソスレを隔離スレ化して構い続けてあげれば、他スレの被害を最小限にできるって寸法よ
こんなクソゴミスレを存続させる意義はここにある

君たちも>>5は知識として覚えておいて、そこらでそれっぽい書き込みを見ても一切反応しちゃいけないぞ
0019デフォルトの名無しさん
垢版 |
2023/04/02(日) 10:48:26.80ID:W9/nq+tL
ディスパッチはディスパッチだろ、くらいに思ってたのに、
Rustの優位性を説明するキーワードのひとつなのね
もうちょっと勉強してからそのへんはゆっくり読む罠 ついていけん

C++を捨てろって言われると猛然と怒るけど、
じゃRust使わないのかって聞かれると、いやじゃんじゃん使うよ必要ならって答える
それがC++er
0020デフォルトの名無しさん
垢版 |
2023/04/02(日) 11:14:49.29ID:3BWJUO+j
>>5
よくまとまってる
0021デフォルトの名無しさん
垢版 |
2023/04/02(日) 12:12:13.50ID:nLGbG+/r
>>19
>Rustの優位性を説明するキーワードのひとつなのね
静的ディスパッチ/動的ディスパッチの違いは
基本としておさえておくべきポイントというだけで
Rustに明確な優位性があるわけではないよ
vtableの持ち方の違いもトレードオフだから
何に重きを置くかによってRustがやや有利な場合もあればC++が有利な場合もある
0022デフォルトの名無しさん
垢版 |
2023/04/02(日) 12:30:32.66ID:hC5sLbbp
しゃぶれよ
0024デフォルトの名無しさん
垢版 |
2023/04/02(日) 14:12:33.01ID:W9/nq+tL
そりゃC++よりは安全だろうけど

少なくともメモリ管理において、Rustの安全性って、数学的に保証されるものなの?
0025デフォルトの名無しさん
垢版 |
2023/04/02(日) 14:28:31.37ID:PHqZc/RR
>>24
定義次第だと思うのでメモリ管理以外で「安全性が数学的に保証されてる」と思ってる例をいくつかあげてみて
0029デフォルトの名無しさん
垢版 |
2023/04/02(日) 16:26:16.23ID:7EJ8Bgwe
>>26
Rustに関係なく「安全かどうか」は定義次第だからね
0030デフォルトの名無しさん
垢版 |
2023/04/02(日) 16:48:24.56ID:W9/nq+tL
ていうか、こっちに定義を聞いてこられても困るんだよね
この定義において、Rustはここまで安全、って言ってもらえると、それを遵守するんだから
0031デフォルトの名無しさん
垢版 |
2023/04/02(日) 16:59:55.82ID:asGxfFqy
>>30
数学的に安全性が保証されてるかどうかを質問してるにも関わらず
「数学的に安全性が保証されてる」とはどういう定義なのか聞かれたら困るのか
それじゃどうしようもないな
0032デフォルトの名無しさん
垢版 |
2023/04/02(日) 17:13:06.13ID:W9/nq+tL
数学的に安全性が保証されてるっぽい何かがあるんだろ? ってなことだよ
根拠もなしに、安全か? そりゃC++よりマシだろうけどさw
0033デフォルトの名無しさん
垢版 |
2023/04/02(日) 21:00:51.01ID:WdMf4Ye5
そんな難しいことを考えなくても
Rustの所有権システムをC++で体験したければ
インスタンスを作るときに
必ず常にmake_uniqueかmake_sharedするようにすれば
だいたい同じ振る舞いになる
安全性は保証される
0035デフォルトの名無しさん
垢版 |
2023/04/03(月) 00:26:35.43ID:CRVbAO5a
コンパイラは怒らないから
静的解析ツールが必要だね
0036デフォルトの名無しさん
垢版 |
2023/04/03(月) 04:38:42.03ID:rltHNDRD
C++はコンパイルとは別に静的解析とデバッグ解析が不可欠だからな
Rustはコンパイラがメモリ安全からデータ競合安全まで保証してくれるのでかなり楽
0037デフォルトの名無しさん
垢版 |
2023/04/03(月) 09:30:27.97ID:sPhWZLZN
デバッグ解析てなんやねん

コンパイラがやる静的解析の範囲が広いというだけでRustでも静的解析・動的解析は基本不可欠
clippy, rustfix, rust-fmt, cargo-expand辺りは静的解析ツールの一種
0038デフォルトの名無しさん
垢版 |
2023/04/03(月) 09:40:57.30ID:GW2UDfFX
まともにrustかけるやつって例外なくc++もかけるけどな。
0043デフォルトの名無しさん
垢版 |
2023/04/03(月) 10:26:17.83ID:ni15ogEW
C++er あるあるシリーズ
#![allow(unused)]
... = hoge().unwrap;
... = hoge()?;
let p: *const [u8] = &fuga;
unsafe {}
0044デフォルトの名無しさん
垢版 |
2023/04/03(月) 10:27:57.18ID:L3onvvn+
>>37
C++のスマポの使い方をミスっても公式支援がない話でそれらは的外れかなあ

clippyはRust公式リント
rustfixはRustコンパイラのよる提案の適用
rust-fmtは清書
cargo-expandはマクロ展開
0045デフォルトの名無しさん
垢版 |
2023/04/03(月) 10:39:12.43ID:ux7WrBep
>>41
Rustはムダなコピーを発生させずに参照を使って安全にメモリ管理できる言語
もしRustで不可能なケースがあったらそれはC++でも不可能で元から無理筋
0047デフォルトの名無しさん
垢版 |
2023/04/03(月) 11:15:28.73ID:UoFPeH1S
>>44
それはRustの実装が一つしかないのを公式と言っているに過ぎない
C++でデバッガが用意されていない開発環境は無い?
もしくは使われていないのでは?
0048デフォルトの名無しさん
垢版 |
2023/04/03(月) 11:47:36.10ID:GWsnSys+
>>44
誰もが使ってるツールにわざわざ説明つけてるところ見ると基本の静的解析ツールも知らなかったんだな
複オジは所詮このレベルだから全く信用できない
0049デフォルトの名無しさん
垢版 |
2023/04/03(月) 11:50:42.61ID:UoFPeH1S
>>45
C++は選択ができる
値とポインタ(スマートポインタ)と参照(左辺値と右辺値)
冗長に書くも効率的に書くもプログラマ次第
素人にはオススメしない
0050デフォルトの名無しさん
垢版 |
2023/04/03(月) 12:08:48.70ID:NHUpObDP
>>49
それはどちらも同じ
所有権を持つ: C++のスマポ、Rustの変数
所有権を持たない: C++とRustの参照
ただしライフタイムが管理できるRustの参照の方が強力かつ安全
0051デフォルトの名無しさん
垢版 |
2023/04/03(月) 12:15:40.80ID:UoFPeH1S
>>50
「ライフタイムが管理できるRustの参照」って何?
単に参照先が死んでることをコンパイラで弾くことを「管理」って言ってるの?
0053デフォルトの名無しさん
垢版 |
2023/04/03(月) 12:24:08.54ID:GLvgK6Zq
Rustの宣伝文だけ読んで他言語を知った気になり
Rustの宣伝文を5chにコピペし続けるだけの人生
0056デフォルトの名無しさん
垢版 |
2023/04/03(月) 13:50:16.07ID:QA6IHCRk
「数学的」連呼してる割には名前に直交性が無いな

.iter
.indexed_iter
.iter_mut
.indexed_iter_mut

.outer_iter
.outer_iter_mut

not exist .indexed_iter_mut
not exist .enumerate_iter_mut

.enumerate_pixels_mut

いちいち覚えてられるか?
0058デフォルトの名無しさん
垢版 |
2023/04/03(月) 14:01:30.74ID:7c0W6U8J
あ。「数学的」連呼してたのは、C++側の俺
そして、あんまり、数学的な安全の論拠ってのはみつからない

ありゃあC++で真似するんだよ 手本にしない手はない
0059デフォルトの名無しさん
垢版 |
2023/04/03(月) 14:08:12.25ID:rB8gWfoY
>>56
各ライブラリで命名方針が異なるのは、プログラミング言語の比較の話と全く無関係じゃね?
あと、enumerate_pixels_mutをその提案のenumerate_iter_mutとしてしまったら、肝心なピクセルが消えて意味不明じゃん。
0060デフォルトの名無しさん
垢版 |
2023/04/03(月) 14:14:18.67ID:7c0W6U8J
雑談としては、そのへんも「きれい」になってくれるとありがたいね
これはC++も同様
0061デフォルトの名無しさん
垢版 |
2023/04/03(月) 14:28:24.56ID:gdFj9/S+
直交性の意味がよく分からなかった
index_of(先頭から検索)とlast_index_of(末尾から検索)は直交性がないことになるのかな
標準と非標準の関係で考えると自然な命名だと思うけど
0063デフォルトの名無しさん
垢版 |
2023/04/03(月) 15:09:57.20ID:dlyOKSPs
>>62
どの辺を指して数学的と言ってるのか謎
0064デフォルトの名無しさん
垢版 |
2023/04/03(月) 15:39:46.50ID:7c0W6U8J
Rust 安全 論文、で上手く引き当てられなかったんだよ
仕事サボって、ちょっと読んでみるw

>>63
いや、いいんだ。「それっぽいの」って俺も言った。
0065デフォルトの名無しさん
垢版 |
2023/04/03(月) 15:53:08.55ID:ZjD7pm8v
>>62
unsafeを使ってsafeなインタフェースを作っている部分、すなわち人間が安全性を保証しなければならなかった部分を、数学的に保証する試みがあるのか
0066デフォルトの名無しさん
垢版 |
2023/04/03(月) 15:56:35.02ID:7c0W6U8J
そこも気を付けて読んでみるけど、
unsafeを撲滅しようと思ったら、SoCのサポートが必要ってのが今のところの俺の考え
そう考えないと、C++も永遠にsafeに成れないことになってしまう

unsafe部分にバグが、っていう古い記事が出てきたりするんだけど、
どうせ、safeでいいものまでunsafeでいっぱい書いたんでしょ、と思ってる
これは個人の推測
0067デフォルトの名無しさん
垢版 |
2023/04/03(月) 16:08:23.20ID:sTax+JD2
>>65
数学的とは一言も書いてなくね?
0068デフォルトの名無しさん
垢版 |
2023/04/03(月) 16:11:48.88ID:7c0W6U8J
学術的とか、論理的とか、適当に読み替えてくれよ、俺がうまく言えなかったのがいけなかっただけ
0069デフォルトの名無しさん
垢版 |
2023/04/03(月) 17:01:07.96ID:dGJwzzow
>>61
last_index_ofはlast occurrenceのindexを示すだけで検索方向を示すものでは無いと思う
0071デフォルトの名無しさん
垢版 |
2023/04/03(月) 17:34:14.59ID:G+jJ6S+V
>>70
はあ?
indexed_iter_mutがあるのはndarray crateの話
enumerate_pixels_mutがあるのはimage crateの話
pixelのイテレータとrowのイテレータがあるためiterではなくpixelsおよびrowsと名付けている
>>56が無関係な両ライブラリをごっちやに取り上げてその意味も分からず批判しているだけにすぎない
0073デフォルトの名無しさん
垢版 |
2023/04/04(火) 09:57:45.04ID:WkDAaTBe
>>72
それ読み間違えてるぞ
0074デフォルトの名無しさん
垢版 |
2023/04/04(火) 10:05:22.65ID:wMBLnZ/K
複オジメソッド発動
0077デフォルトの名無しさん
垢版 |
2023/04/04(火) 12:04:39.20ID:4IMp+S71
何が間違ってるかは教えてあげない
0080デフォルトの名無しさん
垢版 |
2023/04/04(火) 14:47:11.16ID:NrMPyXSZ
日本人はtraitとtoiletの区別がつきにくい
0082デフォルトの名無しさん
垢版 |
2023/04/04(火) 20:58:36.08ID:N+qd6aMB
rustのcrateはdependenciesで入るのが多過ぎるし大き過ぎるわ
要らないものまで無理やり入れさせられてる気分になる
0083デフォルトの名無しさん
垢版 |
2023/04/04(火) 21:26:41.04ID:0Yk0tShF
依存crate問題が最大の弱点ではある
0086デフォルトの名無しさん
垢版 |
2023/04/05(水) 15:43:59.95ID:lwqbYnd2
dependenciesに5個程度指定するだけで
依存crateが100個近くになるのも珍しくない
nodeとは比べ物にならないくらいひどいよ
0087デフォルトの名無しさん
垢版 |
2023/04/05(水) 15:47:38.76ID:lwqbYnd2
しかもビルドすると500~1GB超の容量使うからノートの内蔵SSDを使ってると残す必要のないのは積極的にcleanしないときつい
0090デフォルトの名無しさん
垢版 |
2023/04/05(水) 17:07:48.56ID:rkWYEusf
容量使うのはインクリメンタルビルド用の中間生成物で配置するものとは違うよ
0091デフォルトの名無しさん
垢版 |
2023/04/05(水) 17:26:43.23ID:/Rqy2YcF
C++もPCHファイルを生成するとアホほどでかかったりするが…世の中うまくいかんな
0094デフォルトの名無しさん
垢版 |
2023/04/06(木) 15:52:41.86ID:gPnWA/2r
こう書いておけば、インスタンス化した関数に、こんな風に溶け込むだろうな、とか思って書いてたりはする
時間があれば、生成コードを汗で確認する
びっくりするほどスパゲッティな出力になってて、びっくりすることがある まあ実力不足を痛感する瞬間
0095デフォルトの名無しさん
垢版 |
2023/04/06(木) 18:12:44.37ID:un5AwFJZ
Cargo はゴミ
0101デフォルトの名無しさん
垢版 |
2023/04/07(金) 03:11:25.56ID:ZE3zxB0C
>>100
こう書いてあるね

提案された有効期間注釈に基づく静的分析では、C++ コード内のすべてのメモリ安全性の問題をキャッチすることはできません。
具体的には、すべての時間メモリの安全性のバグ (反復子の無効化によって引き起こされるバグなど) をキャッチすることはできず、
もちろん、有効期間注釈は空間メモリの安全性 (たとえば、C スタイルの配列の範囲外のインデックス作成) には役立ちません。
詳細な議論については、以下のRustとの比較を参照してください。
0102デフォルトの名無しさん
垢版 |
2023/04/07(金) 03:22:57.43ID:ZE3zxB0C
>>99
Rustを使えるならばRustを使ったほうが良いと明記されているね

ソース
Carbon公式FAQ
https://github.com/carbon-language/carbon-lang/blob/trunk/docs/project/faq.md#why-not-rust

Why not Rust?
If you can use Rust, ignore Carbon.
If you want to use Rust, and it is technically and economically viable for your project, you should use Rust.
In fact, if you can use Rust or any other established programming language, you should.
Carbon is for organizations and projects that heavily depend on C++
0103デフォルトの名無しさん
垢版 |
2023/04/07(金) 03:34:46.32ID:D4MDBVlu
>>101
-Wlifetime とかと組み合わせろってことじゃないん
スマポだけでは解けない課題にこれが要るんだろ
(勉強中なので)知らんけど
0104デフォルトの名無しさん
垢版 |
2023/04/07(金) 15:30:28.71ID:xzLK1vX9
動きました。ほんとうにありがとうございました。

use std::ffi::c_void;

#[link(name = "user32")]
#[no_mangle]
extern "stdcall" {
fn MessageBoxA(hWnd: *const c_void, lpMsg: *const u8, lpTitle: *const u8, flg: u64) -> u64;
}

fn main() {
let msg: &[u8] = &vec![65u8, 66u8, 67u8, 0u8];
let lpmsg: *const u8 = &msg[0];
let ttl: &[u8] = &vec![97u8, 98u8, 99u8, 0u8];
let lpttl: *const u8 = &ttl[0];

println!("{}", unsafe { MessageBoxA(0 as *const c_void, lpmsg, lpttl, 3) });
}
0107デフォルトの名無しさん
垢版 |
2023/04/07(金) 16:51:51.07ID:e9qg1mi5
さらに*constにするならこれだけでいい
let msg: &[u8] = &vec![65u8, 66u8, 67u8, 0u8];
let lpmsg: *const u8 = &msg[0];

let lpmsg = b"ABC\0" as *const _;
0110デフォルトの名無しさん
垢版 |
2023/04/09(日) 10:11:37.53ID:kqAFhzUx
Haskellでrustみたいに
型引数だけじゃなく型引数を引数に取るデータ型に対しても型制約書けたりできるんですか?
0112デフォルトの名無しさん
垢版 |
2023/04/09(日) 14:32:11.00ID:pIxjloTA
>>110
もちろんできる
HaskellはRustにできないHKTもサポートしてる
0119デフォルトの名無しさん
垢版 |
2023/04/14(金) 11:40:41.31ID:UzCXU8/1
無能の内輪ノリで人口への膾炙が遅れただろその本の名前
キモいこと分かってないんだからそういうヤツラが使ってると思われる
日本でコケたのは本の題名のせいだ
0121デフォルトの名無しさん
垢版 |
2023/04/15(土) 09:46:37.00ID:PycfapTP
気が付くと unsafe {} 描きまくってるんだよなぁ orz
0124デフォルトの名無しさん
垢版 |
2023/04/15(土) 12:33:08.40ID:nVVXe4ml
mut 付け過ぎもあるかな
let hoge: &mut Vec<u8> = &mut vec![0u8; 256];
for i in 0..hoge.len() { hoge[i] = 255u8; }
の場合と
let mut hoge: Vec<u8> = vec![0u8; 256];
for i in 0..hoge.len() { hoge[i] = 255u8; }
の場合とか
0125デフォルトの名無しさん
垢版 |
2023/04/15(土) 14:12:22.83ID:YfadAR61
>>121
通常のプログラムの中にunsafeが出てくることはない
unsafeは本質的に新たな構造や仕組みをその原理部分のみ小さくライブラリ化して閉じ込めるときに用いられる
その場合も多くは再発明なので既存のライブラリを使えばよい
0126デフォルトの名無しさん
垢版 |
2023/04/15(土) 19:28:04.14ID:yvTdL9wg
現段階でRustを推している人は、「イノベーター」と呼ばれる人で、
『常に最新の情報をチェックしていて、新しい商品やサービスに対する興味を持ちやすいユーザーです。
「新しさ」に価値を感じているのが特徴で、商品の細かい性能や価格はそれほど気にしません。
「最先端」「革新的」などが感じられる商品を積極的に選ぶ傾向があります。』
ということで、「メリット」は余り考えなくて、最先端や革新的であれば
試す人達らしい。牽引役として重要だが、すぐ飽きると言われている。
0127デフォルトの名無しさん
垢版 |
2023/04/15(土) 19:33:25.66ID:yvTdL9wg
普及するには、その次に新し物好きなアーリーアダプターが重要らしい。
こちらは新しさだけでなくメリットも考慮して判断すると言われていて、
なおかつ影響力も大きいらしい。
イノベーターは恐らく説得力に乏しいから人を呼ぶ込む力が弱いかも。
0128デフォルトの名無しさん
垢版 |
2023/04/15(土) 19:33:29.98ID:8QIF2BQP
こんなとこ(スレ)に溜まる奴らだろ、ライブラリ内製でもしてんじゃねーの

あるいはガチ学習者。学生なら、車輪の一つや二つ、自分で磨いてみるもんだ
青春やり直してる大人も含む
0129デフォルトの名無しさん
垢版 |
2023/04/15(土) 19:36:01.37ID:yvTdL9wg
経験から言うと、余りよくない品物、本当は競合と比べてメリットが余りないもの
でも、一定の人は買ってくれる。そして、なぜかその人達は商品を高く評価する。
しかし、実際にはそれ以上進まない。
実は商品の競争力が本当は余り無くてもそういう人達は高く評価するから。
0131デフォルトの名無しさん
垢版 |
2023/04/15(土) 19:38:31.04ID:yvTdL9wg
過去の例からすると、Rustは非常に限られた分野で普及が進むのかも知れない。
ただ、言語の場合は、プロには無料である事もそんなにメリットにはならないので
どこまでいくかは見通せない。
0132デフォルトの名無しさん
垢版 |
2023/04/15(土) 19:40:01.02ID:yvTdL9wg
マニアは、それ自体を楽しんでいるだけで、実用的な仕事に使うことは想定して
なかったりすることが多い。
Rustもそうなのではないか。
0133デフォルトの名無しさん
垢版 |
2023/04/15(土) 19:42:50.40ID:yvTdL9wg
>>128
そういう人は、ライブラリ作りも、作ること自体を楽しんだり、自慢や就職に
利用するためにやってるのではないか。また、そういう人には
「沢山の人に使ってもらえれば満足」
などという人も多い傾向がある。
0134デフォルトの名無しさん
垢版 |
2023/04/15(土) 19:51:35.04ID:yvTdL9wg
>>125
Rustのunsafeは効率を落とさない限りはライブラリ内部に閉じ込めることが出来
無い事があることが分かってる。
数学的な才能が無い人は、想像力が無いのでそれが分からない。
反論は不要。結論は出ているので。
0135デフォルトの名無しさん
垢版 |
2023/04/15(土) 20:02:07.05ID:yvTdL9wg
>>134
もしかしたら、マシン語を理解できないからそのことが分からないのかも知れないな。
「効率を落とさずに」
の意味がマシン語を知らないから分かって無い。
どういうことかと言えば、C言語では1クロックで書けるところが、
Rustだとunsafeをライブラリの中だけに閉じ込めるだけでは、
どうしても1クロックでは書けないことが有る。
0136デフォルトの名無しさん
垢版 |
2023/04/15(土) 20:24:11.46ID:fX0vt5Cu
Rustもご多分に漏れず
新しいC/C++チャレンジャーが現れて
忘れ去られるんだと思うよ
0137デフォルトの名無しさん
垢版 |
2023/04/15(土) 20:42:03.21ID:8QIF2BQP
Cは、広義の安全であることが実装者の責任と権限だけど、
そのために余計なステートメントを書かなくちゃいけなくて、
結局Rustのほうが全体ではステップ数がすくなくなる余地はあるぞ

なので、C/C++は、追いつき、追い越さなければならない
0138デフォルトの名無しさん
垢版 |
2023/04/15(土) 21:49:44.60ID:stEGFLky
クラウド世界トップシェアのAWSもRustで構築されているらしい

https://japan.zdnet.com/article/35183866/
AWD (Amazon Web Services)は、「Rust」を使っている大きな理由として、エネルギー効率の高さを挙げる。
AWSは早くからRustを採用し、Rust Foundationの創設にも携わった。
現在もRustの普及に熱心に取り組んでいる。

AWSのソフトウェアエンジニアで、Rustの普及に取り組む
Shane Miller氏と主任エンジニアのCarl Lerche氏の投稿によれば、
Rustはメモリー安全性を高め、セキュリティ関連の不具合を減らす役に立つだけでなく「エネルギー効率に優れている」。
Amazonは、2025年までにデータセンターの100%を再生エネルギーでまかなうという目標を掲げ、
データセンターの環境負荷の軽減に取り組んでいる。
Rustの採用はその一翼を担うという。

Rustで構築されたAWSサービスの例としては、
コンテナーアプリ用のサーバーレスプラットフォーム「Lamba」を支える「Firecracker」、
「Amazon Simple Storage Service(S3)」、
「Amazon Elastic Compute Cloud(EC2)」、
コンテンツ配信ネットワーク「Amazon CloudFront」、
LinuxベースのコンテナーOS「Bottlerocket」などがある。
0139デフォルトの名無しさん
垢版 |
2023/04/15(土) 22:30:48.74ID:8QIF2BQP
大いに主観が入るけど、もっと高級言語から来てる人も多いんじゃないかな
C++に巻き取りたいねえ、負けていられない
0140デフォルトの名無しさん
垢版 |
2023/04/16(日) 00:07:26.65ID:UgglHakI
イノベーターは後先考えずに新しいものを試す。しかし、ものがよくなければ、
アーリーアダプターには届かず、失速する。それがブーム。
0141デフォルトの名無しさん
垢版 |
2023/04/16(日) 00:17:13.72ID:UgglHakI
>>140
厳密に言うと、イノベーターは、知識が豊富で、物の「能書き」や「SPEC」をよく
見て自分に合うものを選んでいると言われている。
但し、能書きどおりのものかどうか誰にも分からないような段階で「人柱」状態
で使い始めるから、後から言われた通りになってないことに気付くこともある。
なお、他の階層の人は失敗をしたくないからその時点では試さない。
0142デフォルトの名無しさん
垢版 |
2023/04/16(日) 00:20:31.86ID:2uUp8lA9
8年前のRustはそんな感じだった
まだ先があるのかわからなかった

しかしMicrosoftやGoogleやAmazonなど各社でアーリーアダプターたちが実績を示していった
RustはC++より優れていて実用的だと各社が数年かけて認識を確実なものとした
そしてライバル競合IT大手各社が共同でRust Foundationを設立
安定して信頼できる今後のプログラミング言語の地位を確立した
0143デフォルトの名無しさん
垢版 |
2023/04/16(日) 00:30:44.93ID:UgglHakI
>>142
そんな風には思わないけどな。
そもそもRustやってる人は、現代段階でも人数からいってイノベーターの域を出て
ないし。
そんな風に語らなくても、本当に優れたものであれば噂がたって人気が出てくるはず。
0144デフォルトの名無しさん
垢版 |
2023/04/16(日) 01:29:25.91ID:ZR3Gmnwe
見えてる世界が違いすぎて話にならんよなw
5年前ならまだしも今はもうキャズムを超えてるかどうかなんて議論の余地無いよ
0147デフォルトの名無しさん
垢版 |
2023/04/16(日) 06:41:40.93ID:t40wRhbK
cmakeとかわりといい仕事してるし、いいだろ

Rustが本格的に採用されれば、C++にもやっとsafeの波が訪れるだろう
福音だね
0148デフォルトの名無しさん
垢版 |
2023/04/16(日) 08:00:51.32ID:t40wRhbK
>>134
サンクがゼロコストになりえないみたいなこと?
safe/unsafe間に行き来があるとしても、うまく書ければ最適化でサンクは消失するんじゃないん
基盤がclangだし、そのうちできるようになるか、とっくにできるようになってるか
0149デフォルトの名無しさん
垢版 |
2023/04/16(日) 08:59:48.91ID:66qnCtAq
>>145
C++はCを包含するってのが方針なんで
そこはバッサリ互換性を切り捨てるRustとは違うのだよ
0150デフォルトの名無しさん
垢版 |
2023/04/16(日) 09:20:17.30ID:UySlLSqv
>>148
そいつ>>134はデタラメな主張を繰り返している基地外
数学的に自明と主張しつつその証明を示せなかったホラ吹き
0152デフォルトの名無しさん
垢版 |
2023/04/16(日) 10:28:54.24ID:9jM292fW
>>148
そうじゃない。
Rustの安全機構をライブラリ外のアプリレベルまで維持したままでは速度が
上げられないケースが存在することが分かっている。
つまり、ライブラリの中だけにunsafeを書いて、アプリコードの中ではunsafe
を使わなかった場合、安全機構と相性が悪くて必ずオーバーヘッドが生じる
場合がある事が分かっている。
0153デフォルトの名無しさん
垢版 |
2023/04/16(日) 10:31:26.95ID:J01hksTa
バカ同士仲良くやっとけよ
100点オジと複製オジ
0154デフォルトの名無しさん
垢版 |
2023/04/16(日) 10:34:06.66ID:9jM292fW
馬鹿が多すぎて学級崩壊状態。
この板は、特に数学的理解力が乏しい人が多すぎる。
0155デフォルトの名無しさん
垢版 |
2023/04/16(日) 10:41:45.49ID:FS/wFdTV
この板で「数学的」という言葉を使うやつは例外なく馬鹿だから
0156デフォルトの名無しさん
垢版 |
2023/04/16(日) 10:44:16.92ID:66qnCtAq
安全性が効率を犠牲にしているなんて
Rustに限らず分かりそうなもんだけどね
0158デフォルトの名無しさん
垢版 |
2023/04/16(日) 10:56:10.86ID:v1QbiGiU
数学的と言うざっくりとした使い方をしてるのは文系だろうなと言う感想です
0159デフォルトの名無しさん
垢版 |
2023/04/16(日) 11:04:50.54ID:YvJBOxcy
もしかして「おまえらバカにはわからないだろうが、数学的に自明。自明だから解説はしない。」という詐欺師?
0160デフォルトの名無しさん
垢版 |
2023/04/16(日) 11:08:16.87ID:v1QbiGiU
そうじゃないと思うよ
自分では賢いと思ってるけど実際はなにも表現出来てないし伝わってないタイプ
例え伝わっても中身自体は大したことがない
検証や考察無しにただ直観をそのまま書いてる人

自分の意見を書籍や論文にするけどその道の出来る人が見れば一瞬で捨てられる
0161デフォルトの名無しさん
垢版 |
2023/04/16(日) 11:15:03.16ID:YvJBOxcy
詐欺師でないなら数学的に示せばいいんじゃないかな
できなければ詐欺師確定ってことで
0163デフォルトの名無しさん
垢版 |
2023/04/16(日) 11:19:00.37ID:olscUowK
>>155
数学的って言い出したのは俺だけど、>>68 でちゃんと謝っただろww

俺は理系だけど、バイオ系に行った人間で、情報工学とか修めてないんだ
超基礎はwebに出てるから、少しずつ勉強してるけどね

そんな人間でも使える、使ってるのがC/C++だ
だから、型安全に続いて、所有権安全がC/C++に来るのは大歓迎だぜ
0165デフォルトの名無しさん
垢版 |
2023/04/16(日) 11:35:56.39ID:vDeFqoK0
Rustはコンパイル時点で安全性が担保出来るってのが強みなんだよ
GCみたいにパフォーマンスに影響与えないし、C++ほど安全に使うための予備知識が多く必要ない
0166デフォルトの名無しさん
垢版 |
2023/04/16(日) 11:51:39.68ID:66qnCtAq
>>165
>C++ほど安全に使うための予備知識が多く必要ない
その予備知識を覚えるコストが
所有権システムの振る舞いを覚えるコストに
吐き出されたというだけでは?
0167デフォルトの名無しさん
垢版 |
2023/04/16(日) 12:03:50.68ID:olscUowK
C++は安全な利用の統一的な技法が普及してない、まさにこれから
言語によっておおむね統一されてるRustはそのへんを学ぶにあたって効率はいい模様
0168デフォルトの名無しさん
垢版 |
2023/04/16(日) 12:13:57.81ID:66qnCtAq
>>167
>C++は安全な利用の統一的な技法が普及してない、まさにこれから
は?
(Rustの言語に含めるってアイデアはありだと思うよ)
0169デフォルトの名無しさん
垢版 |
2023/04/16(日) 12:14:25.91ID:vDeFqoK0
>>166
言語の標準機能で実現されてるってのが大きい
C++は調べようと思ってもレガシーな情報にぶち当たる可能性が非常に高い
0170デフォルトの名無しさん
垢版 |
2023/04/16(日) 12:20:48.95ID:66qnCtAq
>>169
そこは独特な所有権システムを受け入れることととのトレードオフだけども
そのぶち当たるC++のレガシーな部分って
要するにCなので難しくもないと思うのだが? そんなので挫折するかい?
俺はC++の規格のうち最近に拡張された機能を覚える方が大変だよ
0172デフォルトの名無しさん
垢版 |
2023/04/16(日) 12:30:40.09ID:Xi5zVo2w
>>158
ところが「数学的」という言葉を使うのは理系が多いんだなこれが
まあちょっと考えればわかることだけど
0173デフォルトの名無しさん
垢版 |
2023/04/16(日) 12:33:47.71ID:vDeFqoK0
>>170
結局C++は言語としての基礎がまともじゃないから、拡張繰り返してキメラみたいになってんだよ
今更新規で薦められる言語ではない
0174デフォルトの名無しさん
垢版 |
2023/04/16(日) 12:42:30.71ID:olscUowK
まともな文系は、数学も勉強してるから、数学っていうだろうな
まともじゃない文系…って、こんな板来んやろ(w
0175デフォルトの名無しさん
垢版 |
2023/04/16(日) 12:43:09.89ID:66qnCtAq
>>173
スタンダードであったCを呑み込むことが当初からのC++の戦略だからね
後方互換性ってのは大多数の人間にとっては魅力なんだよ
後方互換性を犠牲にしてディファクトスタンダードに食い込んでいくのは懐疑的だよ
PCのOSしかり携帯しかり
0176デフォルトの名無しさん
垢版 |
2023/04/16(日) 12:54:37.30ID:vDeFqoK0
> PCのOSしかり携帯しかり
LinusもRust導入に舵切ってるし、MSもRust採用始めてるんですがそれは
0179デフォルトの名無しさん
垢版 |
2023/04/16(日) 13:13:32.51ID:olscUowK
そこで止まっちゃってないかってことじゃねえの、しらんけど

Windowsには、これが出てるけど…
https://github.com/microsoft/windows-rs

そこにあるサンプルからして、unsafe{ } じゃ、説得力ないよな
>>16-17 に書いた通りだよ Win32 APIに所有権情報が付いてなかったらなんにもならない
MS Rustチームもっと仕事しろ
0181デフォルトの名無しさん
垢版 |
2023/04/16(日) 13:33:14.21ID:FzlfbndA
Rust for Linuxは現状ドライバをRustで書けるようにしましたってだけ
Rustで置き換えて安全化!なんてわかりやすい成果は現状出ていない
何回言わせんねん
0182デフォルトの名無しさん
垢版 |
2023/04/16(日) 14:40:27.93ID:E0OdAeYg
Rustと違ってC++にはEditionがないからね
safe/unsafeを導入するの10年経っても無理
Clang-Tidyのような外部ツールで頑張るしかない
0184デフォルトの名無しさん
垢版 |
2023/04/16(日) 14:56:50.63ID:MEMXejP0
>>183
Editionが何かも知らんのかw
そんなんでよく書き込みするなぁ
0186デフォルトの名無しさん
垢版 |
2023/04/16(日) 15:04:13.74ID:ztY5oQ1H
>>159
これまでの会話からして、この板の人は、証明しても誰一人として理解できない
から時間の無駄であることが分かった。
恐らく、10年後くらいにやっと理解できるかも知れない。
そういうものだ。
0189デフォルトの名無しさん
垢版 |
2023/04/16(日) 16:23:46.35ID:3uC0HhdE
C++はEditionがどうとか以前に、方言だらけなわけだが

なので、所有権関係が取り込まれるのも早いとこは早いかもね
0190デフォルトの名無しさん
垢版 |
2023/04/16(日) 18:22:08.94ID:Odg0MqUb
C,C++は1995~2000年ごろGCブームが来てて
大学の課題もGC使ってた
当たり前に使ってた
取り込まれるのかと思ったら取り込まれなかった

今は潤沢なメモリがあるからメモリリーク放置violation放置みたいだけどそもそもがc++じゃなくてpython使ってるみたい
0192デフォルトの名無しさん
垢版 |
2023/04/16(日) 19:35:35.63ID:YK5TrmOw
>>166
学習コストは確実にRustの方が低くて覚えやすい
所有権関係はunique_ptrすらなくシンプルなRustがわかりやすいのは言うまでもないが
あらゆる分野で整理されて高機能になるとともにわかりやすくなっている
例えばイテレータにしてもC++はC++20でようやく機能強化と大整理が行われたが普及には程遠い
0193デフォルトの名無しさん
垢版 |
2023/04/16(日) 20:16:07.19ID:66qnCtAq
>>192
初めて覚えるのがRustってんなら否定はしないが
所有権システムは他の全ての言語と勝手が違うからね
C++ユーザならある程度は分かるけども

>例えばイテレータにしてもC++はC++20でようやく機能強化と大整理が行われたが普及には程遠い
これなーに? ついて行けてないんだけども便利なのあるかな?
0194デフォルトの名無しさん
垢版 |
2023/04/16(日) 21:24:14.05ID:2esMCHbQ
言語仕様でごちゃごちゃ議論したがるのはコードまともに組めない奴
これ豆な
0195デフォルトの名無しさん
垢版 |
2023/04/16(日) 21:38:23.17ID:iwQlkKnY
単純な話だよな
所有権の概念の学習コストはC++もRustも同じ
所有権の実際の使い方の学習コストはunique_ptrすらないRustが易しい
学習コストでC++に勝ち目はない
0196デフォルトの名無しさん
垢版 |
2023/04/16(日) 21:53:57.59ID:66qnCtAq
>>195
差分としているunique_ptrの学習コストってなんやw
問題にしてるのは他の言語との変数の振る舞いにRustのみ乖離があるということ
プログラミングをRustで始めるんなら
プログラミング言語の変数ってそういうもんだと覚えるから
たぶん問題にはならん
0197デフォルトの名無しさん
垢版 |
2023/04/16(日) 22:01:26.81ID:oa9zAGJK
C++でも所有権くらい知らないと話にならないので、所有権があるからRustは学習コストが高いとの主張は無理があるんじゃないかな
それにプログラミングができる人にとって所有権なんて大した難しい話じゃないし、誤差でしょ
0199デフォルトの名無しさん
垢版 |
2023/04/16(日) 22:07:10.90ID:3uC0HhdE
まあ、「C++書けます」とか、そうそう口にできないよな
「Rust書けます」…も似たようなもんな気も
0200デフォルトの名無しさん
垢版 |
2023/04/16(日) 22:09:18.55ID:bqya4Wdu
総じて学習コストの高いC++が不利というかさ
拡張が建て増しになってるため無駄に覚えなければいけないことが多すぎなんだよね
学習コストはRustが少なく楽
0201デフォルトの名無しさん
垢版 |
2023/04/16(日) 22:47:00.00ID:vDeFqoK0
>>197
そういう知らないと話にならない、という物のを纏めた
公式のドキュメントが存在しないってのが致命的なんよ
0202デフォルトの名無しさん
垢版 |
2023/04/16(日) 23:07:41.26ID:66qnCtAq
>>201
C++の所有権の話ってunique_ptrの使い方だけだよ
これ以上ないくらい簡単なクラスだよ
公式ドキュメントにこだわるなら
Rustにはまだ無かろうがC++には規格書があるので
それを読むと良いよ
0203デフォルトの名無しさん
垢版 |
2023/04/16(日) 23:12:25.31ID:vDeFqoK0
>>202
規格書はドキュメントにならないんだけど、そんな事も理解できないん?
C++学習する人に、規格書だけ渡すの?
0204デフォルトの名無しさん
垢版 |
2023/04/16(日) 23:17:23.76ID:oa9zAGJK
>>202
unique_ptrは使い方を間違えると終わるので簡単な話ではないよね
コンパイルエラーにしてくれるRustの方が学習も早そう
0206デフォルトの名無しさん
垢版 |
2023/04/16(日) 23:35:44.68ID:66qnCtAq
>>204
>unique_ptrは使い方を間違えると終わるので簡単な話ではないよね
どういう間違え方ですか? コードで書いてみて
0207デフォルトの名無しさん
垢版 |
2023/04/16(日) 23:47:43.39ID:vDeFqoK0
C++衰退してる原因が良くわかるな
そもそも使ってる連中も普及しなくていいと思ってそうな雰囲気
0208デフォルトの名無しさん
垢版 |
2023/04/16(日) 23:50:43.08ID:bqya4Wdu
>>202
規格書があるから学習コストが低いという主張はバカげてるよね
公式の各種ドキュメントが学習用もリファレンス用も整備されてるRustも十分すぎることになるね

>>204
コンパイルでエラーにしてくれるだけでなくエラー指摘方法と解説の丁寧さはプログラミング言語全体で比較してもRustが最も秀逸だね
0209デフォルトの名無しさん
垢版 |
2023/04/17(月) 00:02:25.14ID:jycfg89f
>>208
>規格書があるから学習コストが低いという主張はバカげてるよね
誰がそんな主張をしたのかな?
勝手に自分で作成した主張にバカげてるって一体どういうことだよw

>公式の各種ドキュメントが学習用もリファレンス用も整備されてるRustも十分すぎることになるね
Rustのドキュメントは別に否定はしていないよ
ただしC++の方が歴史が長い分だけ当然のことながら多い

>>204
>unique_ptrは使い方を間違えると終わるので簡単な話ではないよね
どういう間違え方ですか? コードで書いてみて
0211デフォルトの名無しさん
垢版 |
2023/04/17(月) 05:11:00.37ID:L5GaKQYU
・所有権の概念の理解はどちらでも必須
・言語仕様としての使い勝手はスマポ後付けのC++が不利
・使い方の過ちでコンパイルエラーとならず実害を出してきたC++が不利
0212デフォルトの名無しさん
垢版 |
2023/04/17(月) 06:25:51.67ID:aMavO0YU
耳の痛い話なんだが、「所有権の概念とかブッチでも書けちゃう」まであるからね
いいや動けば、みたいなコードが、思わず生き残ってしまうみたいなやつがまずい
自分だって、所有権なにそれおいしいの、みたいな(初学者の)時期は当然あった
気を付けるのが当たり前、みたいな時代だったんだ

なによりC++に欠いているのは、安全を担保・強制する枠組みの決定打
つまり、unsafe{ } の存在 (unsafeがあるということは、逆説的? にsafeが当然にあるという意味)
0213デフォルトの名無しさん
垢版 |
2023/04/17(月) 08:12:32.44ID:jycfg89f
>>211
オイオイ
C++では別に所有権の理解は必須ではないよ
make_uniqueなどせずに(普通に?)インスタンス作ることの方が圧倒的に多い
unique_ptrを使うならそれがRustでいう所有権ってだけ(Rustの拝借元?)
0214デフォルトの名無しさん
垢版 |
2023/04/17(月) 10:08:26.63ID:HKDHATFA
それを言うなら、スマポに頼らずとも、いや、スマポに頼るような複雑な構造をいたずらに作るなかれ、ってほうが近い
でも、めちゃくちゃ書く人とか、めちゃくちゃ書いちゃうときとか、うっかり書いちゃうときとか、あるんだよね
コンパイラにチェック任せられるのはたしかにうれしい
0215デフォルトの名無しさん
垢版 |
2023/04/17(月) 10:08:58.01ID:kmcXsww3
Rust の macro_rules! で
macro_rules! hoge<T> {
(略)
}
って描くと怒られるので
Trait を使って <T> 出来ないかと思ったら
Trait の中に macro_rules! ってどう描けば良いの?
0217デフォルトの名無しさん
垢版 |
2023/04/17(月) 10:24:16.64ID:kmcXsww3
>>159
ラマヌジャンは凄いわ
0219デフォルトの名無しさん
垢版 |
2023/04/17(月) 10:42:37.51ID:kmcXsww3
>>208
>エラー指摘方法と解説の丁寧さは

言いたいことは判るが
提示された修正案がぴったり嵌った時はナイスと思えるが
逆のパターンもあるよね?
0220デフォルトの名無しさん
垢版 |
2023/04/17(月) 10:46:09.44ID:L5GaKQYU
>>213
それもC++でメモリ安全バグそしてセキュリティホールを産んできた一因
C++でも所有権の理解とスマポ利用は避けることができない

https://xtech.nikkei.com/atcl/nxt/column/18/00692/042700054/
> (途中略)
> グーグルによればAndroidに存在した深刻なセキュリティー脆弱性の70%近くがメモリー安全に関するバグに起因するという。
> 同様にマイクロソフトも、同社製品に存在したセキュリティー脆弱性の70%がメモリー安全に関するバグに起因すると述べている。
> C/C++を使う限りセキュリティー脆弱性を根絶するのは不可能と考えて、Rustを採用するに至ったというわけだ。
0221デフォルトの名無しさん
垢版 |
2023/04/17(月) 11:13:07.86ID:vkHU804p
>>215
それどうやって呼び出すつもり?
マクロが展開されるタイミングを考えなよ
0222デフォルトの名無しさん
垢版 |
2023/04/17(月) 11:17:37.21ID:IM/7VFpy
ほんと低次元
小学校低学年のけんか
0224デフォルトの名無しさん
垢版 |
2023/04/17(月) 12:02:11.37ID:Dh5lk+HW
いつまでたっても安定化しないBtrfsを先にRustで完全実装してみせるくらいの実績を出してみやがれってんだ
0225デフォルトの名無しさん
垢版 |
2023/04/17(月) 15:31:33.55ID:GdiItcWS
質問です
例えば画像データの上下反転をしたい場合
let ppix: *mut std::ffi::c_void = im.pixels;
const W: usize = 640;
const H: usize = 480;
const D: usize = 24;
let q = ppix as *mut [[u8; W * D / 8]; H];
for j in 0..h/2 {
let t: [u8; W * D / 8] = (*q)[(h - 1 - j) as usize];
(*q)[(h - 1 - j) as usize] = (*q)[j as usize];
(*q)[j as usize] = t;
}
で実際に可能だったのですが W, H, D を固定にしたくなくて(続く)
0227デフォルトの名無しさん
垢版 |
2023/04/17(月) 15:36:19.73ID:GdiItcWS
let ppix: *mut std::ffi::c_void = im.pixels;
let pitch: usize = im.pitch as usize; // im.pitch: std::ffi::c_int (値はほぼ3)
for j in 0..h/2 {
let a: usize = j as usize * pitch;
let p: *mut u8 = (ppix as usize + a) as *mut u8;
let b: usize = (h - 1 - j) as usize * pitch;
let q: *mut u8 = (ppix as usize + b) as *mut u8;
let mut btm = std::slice::from_raw_parts_mut(p, pitch);
let mut top = std::slice::from_raw_parts_mut(q, pitch);
let mut t: Vec<u8> = vec![0u8; pitch];
t.copy_from_slice(top);
top.copy_from_slice(btm);
btm.copy_from_slice(&t);
}
の様に書き換えて h は可変 w と d は pitch に置き換えで
こちらも動作はするのですがコードが冗長になってしまっています
後者をもう少しすっきりさせたいのですがどんなやり方が考えられますか?
0229デフォルトの名無しさん
垢版 |
2023/04/17(月) 15:56:57.46ID:jycfg89f
>>220
お前がC++の知識が全く無いことが分かった
批判をするなら勉強しなさい
0230デフォルトの名無しさん
垢版 |
2023/04/17(月) 16:18:46.99ID:Q4jLO7Eu
>>225
ちゃんと動くかは分からん

chunks_exact_mut, rchunks_exact_mutの仕様だとhが奇数でも問題ないはず

fn main() {
let mut ppix = vec![0u8; 640 * 480 * 24];
let pitch = 640 * 24;
let h = 480;
// ↓この辺から参考に
let (top, bottom) = ppix.split_at_mut(pitch * h / 2);
for (top_chunk, bottom_chunk) in top
.chunks_exact_mut(pitch)
.zip(bottom.rchunks_exact_mut(pitch))
{
top_chunk.swap_with_slice(bottom_chunk);
}
}
0231デフォルトの名無しさん
垢版 |
2023/04/17(月) 16:23:53.42ID:HKDHATFA
>>228
レスバはレスバしたい奴に任せてほっとこうぜ
結局Rustも使うC++erが参考になる質問なら見学しとくから
でも質問スレとかないんかな
0232デフォルトの名無しさん
垢版 |
2023/04/17(月) 16:28:57.08ID:ToGc2WrC
>>229
安全にするために「C++でも所有権の理解とスマポ利用は避けることができない」で合っとるやろ
まさか自分で管理してdeleteすればいいから不要と言い出すんじゃないだろうな
0233デフォルトの名無しさん
垢版 |
2023/04/17(月) 16:45:26.70ID:lV//RKk9
let ppix: *mut std::ffi::c_void = im.pixels;
let pitch: usize = im.pitch as usize;

for j in 0..h/2 {
let a = j * pitch;
let p: *mut u8 = (ppix as usize + a) as *mut u8;
let b = (h - 1 - j) * pitch;
let q: *mut u8 = (ppix as usize + b) as *mut u8;

let btm = std::slice::from_raw_parts_mut(p, pitch);
let top = std::slice::from_raw_parts_mut(q, pitch);

for k in 0..pitch {
std::mem::swap(&mut btm[k], &mut top[k]);
}
}
0234デフォルトの名無しさん
垢版 |
2023/04/17(月) 17:12:38.63ID:KX4+3zuW
>>230
let len: usize = h as usize * pitch;
let (top, bottom) = std::slice::from_raw_parts_mut(ppix, len).split_at_mut(len / 2);
で動作しましたありがとう
0235デフォルトの名無しさん
垢版 |
2023/04/17(月) 18:39:30.36ID:PUaqCjxF
数学とは
実験データに基づかない証明ばかりしているくせになぜか正しい
現実の影響を受けにくい

前例がなければ何もしなかったのに
実例を見るとついつい行動してしまう模倣犯みたいな感じになりにくい
0236デフォルトの名無しさん
垢版 |
2023/04/17(月) 19:11:10.94ID:RKcegE7f
>>208
Rustc の指示通りに修正すると余計にエラーが増えて
状況が悪化して散々振り回されて時間を無駄にする
結局指示と違う修正ですっきり治ることも多い
0238デフォルトの名無しさん
垢版 |
2023/04/17(月) 19:19:30.04ID:rguxj2m5
最初に&mut [u8]スライスを作るところだけffiサイドに分離しておくのがよいね

>>236
どういう不備があるかの本質をエラーメッセージはまず示してくれている
その補助としてコンパイラが一案を示してくれているから自分の望む案でなくてもエラーの理解に助かる
時間の節約にこそなれど無駄にすることはない
もし時間を無駄にしているなら本質を無視しているバカさを自白してるようなもの
0240デフォルトの名無しさん
垢版 |
2023/04/17(月) 21:07:11.98ID:jycfg89f
>>232
もし>>213>>220とレスを返すのを肯定するとしたら
お前もC++の知識が文字通り皆無なのだと分かる

class Hoge {
public:
void *operator new (size_t p) = delete;
};
0241デフォルトの名無しさん
垢版 |
2023/04/18(火) 04:15:46.41ID:iA5+Rtnt
>>212 >>216
unsafe で隠蔽してるだけで
Java の Exception みたいに上位にも伝播する訳でもないのに
全体としては安全が確保されてるとか
夢観過ぎ自己満でしかない

問題先送りどころか隠蔽体質
0242デフォルトの名無しさん
垢版 |
2023/04/18(火) 04:46:00.70ID:hIfvNlZE
握り潰しの握りっ屁でも臭わないのがRustの美学
0243デフォルトの名無しさん
垢版 |
2023/04/18(火) 06:13:08.68ID:MLRxBRH/
>>241
全くの逆
むしろ例えば生ポインタによる読み書きアクセスがunsafeなように一番下はunsafeに行き着く
しかし例えばある条件を伴ってそのメモリ領域が確保された安全なアクセスであると保証できる状況を満たす場合は
そのアクセス関数をsafeなインタフェースとして提供できる
大雑把な違いは以下

【C++の場合】
プログラム全体にunsafeが散らばっていてプログラム全体がunsafe
つまり人間がプログラム全体に対してその安全性を保証しなければならない

【Rustの場合】
safeなインタフェースの中にunsafeが閉じ込められている
その閉じ込める部分に対してのみ人間が安全性を保証しなけれはならない
プログラム全体の安全性はコンパイラが保証できる仕組み

例えばC++の場合は生ポインタでなく参照を使っている場合でもダングリング発生の危険があるのに対して
Rustの参照はライフタイムが管理されてダングリングが発生しないとともにデータ競合防止アクセスも保証される
さらに他のスレッドと共有できるか否かも含めて型付けと静的型チェックによりコンパイル時に安全性を保証できる言語仕様となっている
0244デフォルトの名無しさん
垢版 |
2023/04/18(火) 07:00:27.77ID:DviFuO26
OOP的な隠蔽だろ?

まあ俺のは素人が書いてるコードだし、自己満と言われようと構わんがなw
そして、そういう用途・運用もあるんだ
ガチプロばっかりが、PC・マイコン使ってない
0245デフォルトの名無しさん
垢版 |
2023/04/18(火) 08:26:30.53ID:Dh7Xhf9O
気軽に聞かせて
unsafeが残っていながら なにが安全じゃ! っていう反駁をちょくちょく見るけど、
unsafeが要らないようなプロセッサってほんとに作れないもんかな

絵空事じゃないぞ、FPGAにオレオレ プロセッサって起こせるようになったらしいし
RustBeltに載ってるのかな(読破はできてない
0247デフォルトの名無しさん
垢版 |
2023/04/18(火) 09:50:26.33ID:tfRpsuLy
相関関係ではなく因果関係を立証できる者だけが
safeでも原因になれることを立証できる
0248デフォルトの名無しさん
垢版 |
2023/04/18(火) 10:16:01.43ID:sxhvE7iU
>FPGAにオレオレ プロセッサって起こせる
何十年も前から可能だったよ
っていうか原理的に出来て当たり前だし
「実用的な」って意味ならまあ色んな考え方もあるだろうが
0249デフォルトの名無しさん
垢版 |
2023/04/18(火) 10:27:05.42ID:PTyVVN9Y
限りある脳のリソースをどこに使うかという極々当たり前のことだろ
それすらわからないようなやつがまともにプログラミングできる訳がないんだから何を言っても時間の無駄だよ
0250デフォルトの名無しさん
垢版 |
2023/04/18(火) 10:31:04.41ID:Dh7Xhf9O
まともじゃないヤツをプログラミングから排除するのがsafeか
こりゃこまったなww
0251デフォルトの名無しさん
垢版 |
2023/04/18(火) 10:43:23.90ID:tfRpsuLy
人を説き伏せる目的で言うのは時間の無駄だけど自分が言いたいことを言うのはいいんだよ
0252デフォルトの名無しさん
垢版 |
2023/04/18(火) 11:43:26.04ID:rPAFEI4Z
なるほど
言いたいことを言う場がない人たちだから
こんなところで承認欲求剥き出しの長文書くのか
0253デフォルトの名無しさん
垢版 |
2023/04/18(火) 12:02:59.09ID:Dh7Xhf9O
試金石と思ってるところはあるな 大間違いならツッコミがあるし
自分も、まあそうかな、くらいなら、いちいち「そうだそうだ」って書かないしね
0254デフォルトの名無しさん
垢版 |
2023/04/18(火) 12:20:54.75ID:NALS/zAj
>>236
経験的にだけど、ライフタイム関連のヒントは真に受けない方がいい気がするな

多分、構造体や関数の定義側のライフタイムが意図通りにできていない場合に、そっちを直せというヒントを出せないのだと思う
定義を正としてそこから導出されるライフタイムや境界をひたすら書けと言うだけ
そんなヒントにハイハイと従ってるとそこら中ライフタイムパラメータまみれにされた挙げ句、最終的にlifetime conflictで二進も三進もいかなくなったことがある
結局その件はある関数の引数に2個ある参照のライフタイムパラメータの省略をやめて'a,'bに分けるだけでよかった記憶

あと'aで受け取りたいのに「'staticにすることを検討してください」とかもよく見る役立たずヒント
0255デフォルトの名無しさん
垢版 |
2023/04/18(火) 13:25:41.34ID:tfRpsuLy
グローバル変数をやめろと指示された → ヒープを使った → メモリが壊れた
という長期的な流れもあるので
'staticを検討することは指示を信じているとも言えるし、最初の指示を全力で疑っているとも言える
0257デフォルトの名無しさん
垢版 |
2023/04/18(火) 20:52:44.33ID:qWAcGwU9
コンパイラのエラーメッセージを見ずにヒントだけを見るようなバカは
他のことでも重要部分を見ずに枝葉だけを見て失敗してきているんだろうな
0258デフォルトの名無しさん
垢版 |
2023/04/18(火) 22:19:21.28ID:NALS/zAj
いやーすんませんねバカで
実際ライフタイム系エラーメッセージって他のエラーに比してかなり分かりづらいと思うんだけど、読み方のコツとかあったら教えてくれませんかね?
0259デフォルトの名無しさん
垢版 |
2023/04/18(火) 22:56:45.81ID:1GQDyAx6
OOP言語のクラスと同じ感覚で構造体のフィールド組むとライフタイムのトラブルに嵌る気がする
Rustの構造体は一緒に使うデータというより一緒に捨てるデータのイメージだから
ライフタイム無しの構造体:データベースのテーブルのレコード
ライフタイム有りの構造体:↑を参照するビューのレコード
みたいな設計を意識するといいかも(RDBほど正規化を気にする必要はない)
こうするとビューが参照するテーブルごとにライフタイムパラメータが存在する形になる
あくまで個人の考え方というか経験論だから参考程度に
0260デフォルトの名無しさん
垢版 |
2023/04/19(水) 00:20:32.62ID:s8p2Q+oA
教師ありでも教師なしでも遅かれ早かれ同じ道を通りそうな方向に行く
教師ありの場合にしか通らない所で過学習しない
0261デフォルトの名無しさん
垢版 |
2023/04/19(水) 00:45:23.08ID:d1nAuXLd
>>259
スクリプト言語から来たんだけど
これまでなんでも連想配列に突っ込んでいたのが
実はアクセス毎にハッシュ値を計算して、ハッシュテーブルの衝突比較をして、ようやくたどり着くのを実感しちゃった
基本的にVecで持っていて、テーブルを引かなければならない時だけ使うHashMapを持つのがいいのかな
0262デフォルトの名無しさん
垢版 |
2023/04/19(水) 09:43:31.13ID:4c9fSoSa
>>246
狙ってできるということは、ぼーっとしてると踏むかもしれないってことだよな?

ライフタイムは銀の弾丸だ! みたいに、お題目のように言ってくるコピペへの反論として、
ちゃんと書かなきゃいけない、の主戦場がライフタイムの記述に移っただけじゃんってことでおっけー?

うんでも、template<> に近い感覚を覚えた、親しみを覚えたかな
はやくC++にも来ればいいのに
0263デフォルトの名無しさん
垢版 |
2023/04/19(水) 10:00:52.83ID:oanEffOH
普通に使われない書き方を恣意的に作らないと起きないため
実害なしとして放置となっている
0264デフォルトの名無しさん
垢版 |
2023/04/19(水) 10:08:03.97ID:4c9fSoSa
別にいいよ、放置で
でもそれを、(コピペ勢がいうような)安全っては言わない

俺は正確に、どう安全か知って使いたいんだ

C++だって、「そんな書き方すんなよ」ってのを踏むヤツが後を絶たない
だから、「書きようが悪いだけ」なんて反論が出るわけだ
0265デフォルトの名無しさん
垢版 |
2023/04/19(水) 10:31:19.03ID:vWGdqQhB
C++は初心者が自然に間違えて踏んでしまう
慣れているプロですら複雑化したときには間違えて陥ってしまう
そして現実に何度も何度も何度もプロたちがミスってきたからMicrosoftやGoogleなどIT大手も匙を投げ始めた

そのRustの件は初心者が間違えて踏んでしまうことは決してなく
慣れているプロが複雑化したときもそんな状況に陥ることはない
強引に恣意的にそれを目指して作り出さないと生じない
0266デフォルトの名無しさん
垢版 |
2023/04/19(水) 10:35:26.97ID:4c9fSoSa
> 初心者が間違えて踏んでしまうことは決してなく

ここだねえ 穴があったら、落ちるもんなんだよ

そこんとこは、コピペ勢に証明してもらうとするわ
俺が気に入らないのはコピペ勢だ、あいつら俺の母語を侮辱するからね
0268デフォルトの名無しさん
垢版 |
2023/04/19(水) 11:04:59.07ID:mEvWDtbQ
ソースコードで示してって言うと
理解しないままの受け売りなのですぐにボロが出る
ChatGPTの流行をマジで危惧してるよ
0270デフォルトの名無しさん
垢版 |
2023/04/19(水) 12:07:36.70ID:4c9fSoSa
そうじゃないけど、それもあるな
ちゃんと規制しないと、unsafe 使いまくられたら一緒じゃんwwって反論もできるな
0271デフォルトの名無しさん
垢版 |
2023/04/19(水) 14:59:19.03ID:4c9fSoSa
思わぬところに反論しときたいんだが

>>265
> 何度も何度も何度もプロたちがミスってきた

ここはちょっと要検証じゃね たとえば、Chromium/Chromeは精鋭だけで書かれたのか
ガチプロはそんなミスしないんだよ、ガチプロはスマポを使いこなすし、静的解析に通るように綺麗に書く
だから、「馬鹿にするな、C++が悪いんじゃない、悪い奴が悪いんだ」って反論も出る

C++はプロじゃない人間も使う、例えば俺 だから、C++にもunsafe{ } が必要なんだ

些細なようだが、ちゃんとしてるプロをバカにすることはない
敬意を払うのは人の為ならず(自分のため)
0272デフォルトの名無しさん
垢版 |
2023/04/19(水) 16:01:07.64ID:mEvWDtbQ
>>271
>ガチプロはそんなミスしないんだよ、ガチプロはスマポを使いこなすし、
使いこなすって表現するほどスマートポインタは御大層なものではない
そもそもmake_uniquやmake_sharedするのは
俺の場合は全インスタンスの1割弱だよ(newは一切無い)
operator newを呼ばずにインスタンスを作るのが9割超
0273デフォルトの名無しさん
垢版 |
2023/04/19(水) 16:53:43.84ID:ZJsXKDj1
>>264
>C++だって、「そんな書き方すんなよ」ってのを踏むヤツが後を絶たない

これな
前にも誰か言ってたが vector にぶっこんだデータを参照するときに
再配置が起きると参照先が無くなって困るとか
そりゃ再配置が起きるような書き方してる方が悪いんだよ
0274デフォルトの名無しさん
垢版 |
2023/04/19(水) 18:49:07.48ID:s8p2Q+oA
よくわからんが、プログラマーはlifetimeのパラメーターを明示的に実体化できないんだよね
人間の代わりにコンパイラが暗黙に自動的に実体化する
なんで人間が何か踏んだとか人間が穴に落ちたみたいに言われてるんだ?
0275デフォルトの名無しさん
垢版 |
2023/04/19(水) 19:51:56.67ID:ckDmN3Ij
コンパイラが調整する余白部分はあるけど包含関係を明示する程度にはプログラマが指定できる

ライフタイムは
「関数内のローカル変数の参照を関数の外にreturnしても受け取った側では使えなくなってる」
みたいなC++でも一般的なルールを概念的に表してるだけだよ
関数じゃなくブロック単位でスタックを伸縮させるコード生成があるかは知らないけど
ライフタイムはスタックのどの辺にそのデータ(の根拠)が置かれているかにおよそ対応してて
スタックの先端の方ほどライフタイムは短くなるし根元に近いほどライフタイムは長くなる

参照値の場所より根元の方を参照する分にはとりあえず安全だけど参照値より先端の方を参照してると
知らないうちに処理が進んでスタックが短縮されて参照先が無効になるかもしれない
そういう参照エラーをコンパイラで排除するためにライフタイムが使われてる
参照先は参照元より根元に近い(長生きする)ことが保証されてる範囲でしか認めない感じかな

実際は参照値もデータもスタック上で引っ越したりするし
被参照中はそのデータが動かせなくなるみたいな別のルールもあるからややこしいけど
0276デフォルトの名無しさん
垢版 |
2023/04/20(木) 00:49:58.65ID:9yNISOE6
Rustについて教えてちょ
以下はsizeが実行時に与えられるので
vについてアクセス違反を起こしていないかコンパイル時には
チェックできないと思うのだけどRustで書くとどうなるのかな?
#include <iostream>
#include <vector>
using namespace std;
int main () {
vector <int> v {1, 2, 3};
size_t size;
cin >> size;
if (v.size () < size)
{
cerr << "The specified number must be less than or equal to " << v.size () << ".\n";
return -1;
}
for (size_t i {0}; i < size; ++ i)
cout << v [i] << '\n';
return 0;
}
0278デフォルトの名無しさん
垢版 |
2023/04/20(木) 01:16:01.15ID:GPVFd3S9
>>276
Rustは基本bound checkがされるからそれっぽいコードだと実行時にパニックで落ちる

bound checkも避けて落ちないようにするならイテレータをtake(size)する
0279デフォルトの名無しさん
垢版 |
2023/04/20(木) 01:19:28.98ID:GPVFd3S9
他言語なら0..min(v.len(), size)とかもあるだろうけどRustではあんまりやらないと思う
0281デフォルトの名無しさん
垢版 |
2023/04/20(木) 01:24:33.22ID:9yNISOE6
>>278
>Rustは基本bound checkがされるからそれっぽいコードだと実行時にパニックで落ちる
あれ!? ということはコンパイルは通るの?
0282デフォルトの名無しさん
垢版 |
2023/04/20(木) 01:42:12.31ID:px2D1mrK
Rustでは普通こう書く
for n in v.iter().take(input_size) {
println!("{n}");
}

どうしてもインデックスでアクセスしたいなら
他の言語と同じく小さい方まで回す
let ok_size = min(v.len(), input_size);
for i in 0..ok_size {
let n = v[i];
println!("{n}");
}
0283デフォルトの名無しさん
垢版 |
2023/04/20(木) 01:54:59.31ID:px2D1mrK
あとはインデックスを使いminを使わないならばこうかな
for i in (0..v.len()).take_while(|&i| i < input_size) {
let n = v[i];
println!("n={n}");
}

3つとも同じ動作となるけど
簡潔かつインデックス不要な最初の方法がRustでは普通
0286デフォルトの名無しさん
垢版 |
2023/04/20(木) 02:22:14.41ID:px2D1mrK
>>284
イテレータのtake(n)は最大n個になる
その前のv.iter()からv.len()個の参照が来る
だからnがv.len()より多くてもそれ以上ポインタは進まず安全

>>285
unsafeは必要ない
自分ですぐ試せるからここで何でもやってみればいい
https://play.rust-lang.org/
Rustで普通に使っていてunsafeは出て来ない

unsafeが出てくるのは例えば
FFIでC言語など別言語からの変換とか
既存ライブラリにない新たな仕組みの型を作り出すときに
unsafeを使わざるを得なくてunsafeを閉じ込めて安全なインタフェースを提供する場合
0287デフォルトの名無しさん
垢版 |
2023/04/20(木) 02:38:45.55ID:9yNISOE6
>>283
(0..v.len())でインデックスを作ってると思うのだけど
コンパイラはfor節の中でアクセスされるvのサイズと
インデックスの最大値の比較まで行ってるってことかぁ
0288デフォルトの名無しさん
垢版 |
2023/04/20(木) 02:54:57.60ID:px2D1mrK
>>287
例えば 0..10 は0から10未満つまり0から9までの数値を返すイテレータ
インデックスかどうかは関係ないし配列やVecとも無関係
非負数値だからたまたまインデックスとしても使えるというだけ

いずれにせよ配列やVecのシーケンシャルアクセスにインデックスを使うのは無駄なので
インデックスは使わずに>>282の前者を使おう
0289デフォルトの名無しさん
垢版 |
2023/04/20(木) 03:11:11.34ID:9yNISOE6
ボローチェッカの挙動を知りたいのだよ
以下だとコンパイルは通らないんだよね?

for i in (0..100).take_while(|&i| i < input_size) {
let n = v[i];
println!("n={n}");
}
0290デフォルトの名無しさん
垢版 |
2023/04/20(木) 05:14:11.17ID:px2D1mrK
コンパイルも通る
そこには借用(ボロー)つまり参照がないからボローチェッカーは無関係
厳密にはtake_whieは参照を取るが対象が整数値なのでコピーして比較していて無関係
let n = v[i]; も整数値のコピーなので無関係

ちなみにC以外ほとんどの言語と同様に v[i] は安全にインデックス範囲チェックが行われる
範囲チェックの結果を受け取りたいならばget()によりOptionを得ることもできる
例えばこれで安全にアクセスできる
if let Some(n) = v.get(i) {
println!("n={n}");
}

シーケンシャルアクセスならインデックスによるアクセスの必要性がないので
v.iter()を使い安全に各要素の参照を得ることができる
したがって>>282の前者が簡潔で可読性もよく安全で高速なRustでの普通の書き方
0291デフォルトの名無しさん
垢版 |
2023/04/20(木) 09:48:13.23ID:9yNISOE6
>>290
なるほど

>ちなみにC以外ほとんどの言語と同様に v[i] は安全にインデックス範囲チェックが行われる
C++でいうと以下のような感じなのかな?

for (size_t i {0}; i < input_size; ++ i)
cout << v.at (i) << '\n';

Rustはメモリアクセス違反を何でもかんでもコンパイルで弾けるわけじゃないのね
0292デフォルトの名無しさん
垢版 |
2023/04/20(木) 11:20:58.88ID:ViRjvm8y
アクセス違反が発生しても何となく動き続けることがなければとりあえずセーフの精神
unsafe内でuncheckにするオプションも用意されてることが多いけど
0293デフォルトの名無しさん
垢版 |
2023/04/20(木) 11:29:56.72ID:vzrku2iH
DoSにつながるから、落ちるのはよくないみたいに言われたりするんだけど、
変に無理に動き続けるより、異常を見つけたら落としたほうがいいときってあると思うんだよな
落ちるバグはコールスタック残ってればいち早く潰すだろうし
0294デフォルトの名無しさん
垢版 |
2023/04/20(木) 11:44:16.22ID:GPVFd3S9
バッファオーバーフローみたいな脆弱性につながるから落とすほうが安全なんだよ
0295デフォルトの名無しさん
垢版 |
2023/04/20(木) 11:48:21.96ID:SYxH5KMK
C/C++とは異なり、Rustは範囲外メモリアクセスを絶対に起こさないことが保証される点が決定的な違い
シーケンシャルアクセスでは、Rustではv.iter()とイテレータを使い、結果的に終端アドレスに達するまでポインタが進むのと同じ生成コードになるので、最高速かつ安全に範囲内のみのコードになる
そのうえで、v.iter().take(input_size)など様々な条件や加工などをするイテレータメソッドを複数組み合わせて、メソッドチェーンにより簡潔な記述をするのがRustでの書き方
0296デフォルトの名無しさん
垢版 |
2023/04/20(木) 13:05:49.56ID:9yNISOE6
>>295
ディフェンスラインが後退したな
STLのコンテナもatでアクセスすれば範囲外アクセスで例外を投げるので同じ
オーバーヘッドが気になるならoperator[]によるアクセスも
イテレータによるアクセスも選択できる
0297デフォルトの名無しさん
垢版 |
2023/04/20(木) 13:34:13.29ID:w/28tNmU
C/C++はポインタと配列の区別があやふやだ

まず配列という概念がない言語でポインタの問題だけを解決し
それから配列をたんなるライブラリとして追加するほうが無駄なトラブルが少ない
配列すらない状態に一旦後退するのは正しい

その意味では、ジェネリクスがない状態に後退できるC/C++を見習うべきだったとも言える
0298デフォルトの名無しさん
垢版 |
2023/04/20(木) 18:25:05.04ID:zqUq/1wh
>>296
違いはここ
・安全な言語: 範囲外アクセスをすることが絶対にない
・安全でない言語: 範囲外アクセスをしてしまう
CとC++は不合格
0299デフォルトの名無しさん
垢版 |
2023/04/20(木) 19:53:34.14ID:9yNISOE6
>>298
範囲外かどうかチェックのオーバーヘッドがあるのではないのかな?
C++はチェックありもなしも選択できるんだよ
0300デフォルトの名無しさん
垢版 |
2023/04/20(木) 20:48:09.87ID:D1KovJeq
Rustもインデックス範囲内チェックの有り無しを選べる
基本的にはインデックスは使われず、安全な範囲内に動くポインタのみを、自在に各種イテレータメソッドで扱うため、オーバーヘッドはゼロ
唯一の例外が真のランダムアクセスで、範囲内のインデックス値か不明なものを扱うため、インデックス毎に範囲内チェックは絶対に不可避なためコストがかかる
その場合でも、範囲内のインデックス値しか来ない構造ならば、新たな型をunsafeなget_unchecked()を用いてそれを閉じ込めて、安全なインターフェースとして提供できるため、オーバーヘッドはゼロ
0302デフォルトの名無しさん
垢版 |
2023/04/20(木) 21:17:13.53ID:B6QJskar
チェックを忘れて脆弱性を埋め込むリスクが桁違い
0303デフォルトの名無しさん
垢版 |
2023/04/20(木) 21:33:10.92ID:9yNISOE6
>>302
すまんが何が違うかを書いてくれないかな?
あるいは>>300が何を言わんとしているか
他の人の解説でもいいんだけど
0304デフォルトの名無しさん
垢版 |
2023/04/20(木) 21:38:15.36ID:iAIcEMT7
>その場合でも、範囲内のインデックス値しか来ない構造ならば
この判断を誤ると結局脆弱性が埋め込まれそうだけど、
チェックを忘れることに比べれば起こりにくいのかもね
0305デフォルトの名無しさん
垢版 |
2023/04/20(木) 21:40:24.96ID:SYxH5KMK
>>301
オーバーヘッドに関してはC++もRustも最小限にすることができて同じ
安全性に関しては範囲外アクセスが生じうるC++のみ安全でない
0307デフォルトの名無しさん
垢版 |
2023/04/20(木) 21:44:22.16ID:9yNISOE6
>>305
>安全性に関しては範囲外アクセスが生じうるC++のみ安全でない
範囲外チェックなしでインデックスでアクセスしたら
Rustも危険なのでは?
0308デフォルトの名無しさん
垢版 |
2023/04/20(木) 21:51:17.50ID:D1KovJeq
>>304 >>307
その場合は、一般的にunsafeを閉じ込めてsafeなインタフェースを提供する新たな型をモジュールとして提供する
そのモジュール部分のみを人間が安全性を保証する形になり、その利用者側はRustコンパイラが安全性を保証する
したがってそれを利用する側のプログラマーのミスで範囲外アクセスなどが起きることはない
0309デフォルトの名無しさん
垢版 |
2023/04/20(木) 21:56:16.00ID:9yNISOE6
>>308
今はそのunsafeに閉じ込める部分に
C++とRustで差があるのか無いのかを議論している
お分かりかな?
0310デフォルトの名無しさん
垢版 |
2023/04/20(木) 22:01:05.35ID:9yNISOE6
>>307
私はせっかちなので自分で議論を進めると(と言っても私はRustは分からんのだが)
範囲外チェックなしでインデックスでアクセスできる -> Rustも同様に危険
範囲外チェックなしでインデックスでアクセスできない -> Rustはオーバヘッドがある
ということになる
0311デフォルトの名無しさん
垢版 |
2023/04/20(木) 22:03:11.36ID:cejxbewD
複オジの説明がクソだから伝わらなくても仕方ない
0312デフォルトの名無しさん
垢版 |
2023/04/20(木) 22:06:37.25ID:9yNISOE6
>>295
>C/C++とは異なり、Rustは範囲外メモリアクセスを絶対に起こさないことが保証される点が決定的な違い
によると後者ってことになるが

>>300
>Rustもインデックス範囲内チェックの有り無しを選べる
によると前者ってことになる

矛盾しとる
どっちや?
0313デフォルトの名無しさん
垢版 |
2023/04/20(木) 22:18:01.10ID:FIsyFWOj
C++に勝ってると主張するために普段はunsafeのことを脇に置いてメリットばっかり語ってるのに
性能で負けてるって言われて悔しいからって急にget_uncheckedの話持ち出すからややこしいことになるんじゃな
0315デフォルトの名無しさん
垢版 |
2023/04/20(木) 22:36:42.26ID:98y/hYCF
話は簡単
RustはVecもそこで使われるスライスのイテレータも
unsafeなコードを閉じ込めてsafeなメソッドを提供している
だからその部分の作成は人間がミスるとおしまい
逆に言えばその狭い範囲のみ人間が頑張って安全性を保証すればよい

一方でそれらVecやイテレータなどを利用する一般のプログラマーは
そのsafeなメソッドを使っている限り絶対に安全なことが保証される
もし問題があればコンパイラがエラーを出すので常に安全となる

結論
RustもC++も最小限のオーバーヘッドが可能で同じ
しかしその安全性は全く異なる
C++は常にミスったらおしまい
C++はプログラム全体に対して人間が安全性を保証しなければならない
Rustはsafe利用者がミスることは絶対になくコンパイラがエラーを出してくれる
Rustはunsafe利用部分のみ人間が安全性を保証しなければならない
0316デフォルトの名無しさん
垢版 |
2023/04/20(木) 22:42:39.55ID:9yNISOE6
>>315
一生懸命書いているところを申し訳ないが
>>276の話で始めたように今は
コンパイル時にチェックできない状況の話をしているんだ
0317デフォルトの名無しさん
垢版 |
2023/04/20(木) 22:43:11.74ID:98y/hYCF
>>313
そのunsafeなget_uncheckedの件も同じ
unsafeを利用してsafeを提供する人だけがその安全性の保証できるコードを書けばよい
一方でそこで作られたsafeなものを利用する一般プログラマーはミスってもコンパイラがエラーとして止めてくれる
0321デフォルトの名無しさん
垢版 |
2023/04/20(木) 22:49:34.33ID:98y/hYCF
>>318
どちらも正しい
効率的なunsafeを使いそれを閉じ込めることで効率的なsafeを提供することがRustの基本
一般プログラマーはそのsafeのみ使えば書いたコードの安全性が保証される
0322デフォルトの名無しさん
垢版 |
2023/04/20(木) 22:55:08.59ID:98y/hYCF
>>320
最初に出ているこのコードのことだろ
for n in v.iter().take(input_size) {
println!("{n}");
}
もちろんinput_sizeの値に関わらず静的に安全なコードだ
そしてインデックスは用いないのでインデックス範囲外チェックは無い
Cでポインタで書いたときと同じ速度になる
0323デフォルトの名無しさん
垢版 |
2023/04/20(木) 22:56:41.18ID:9yNISOE6
議論にならんのでスルーして
彼の主張は(正しいのかは分からんが)
要するに範囲外チェックなしでインデックスでアクセスできるということだから
Rustも同様にこの点は危険ということになる
0324デフォルトの名無しさん
垢版 |
2023/04/20(木) 23:00:30.54ID:9yNISOE6
>>322
今はRustでも危険に書けるでしょ?って話をしている
イテレータを使えば安全なのでこう書くべしっていうのなら
それはC++となんら変わらない
0325デフォルトの名無しさん
垢版 |
2023/04/20(木) 23:23:11.63ID:SYxH5KMK
>>323
Rustはチェックしないけど安全な型を作れるよ
例は何でもいいんだけど例えば将棋盤を表す型を9✕9=81のインデックスを考えてみよう
その将棋盤の型に対するインデックスの型を新たに作ってメソッドとその操作を限定することでusize化した時に常に0~80の値しか取らない型を作る
あとは unsafeを使ってsafeかつ効率的な実装
impl std::ops::Index<将棋盤インデックス型> for 将棋盤 {
type Output = 将棋駒;
fn index(&self, index: 将棋盤インデックス型) {
unsafe { self.0. get_unchecked(index.to_usize()) }
}
}
これで将棋盤型のアクセス時にインデックスの範囲内チェックは行われずに効率的かつ安全
(将棋盤インデックス型の定義によりindex.to_usize()は常に0~80の値のみをとるため)

将棋の実装を実際にしたことはないが
似たようなデータ型は実際に何度か書いたことがある
0326デフォルトの名無しさん
垢版 |
2023/04/20(木) 23:29:13.60ID:vzrku2iH
C/C++にも、-fsanitize=address ってのが後追いながらちゃんと入ってきてる
その価値は認めていいし、しかし、差は縮まりつつある
0327デフォルトの名無しさん
垢版 |
2023/04/20(木) 23:32:10.47ID:vzrku2iH
Rustでも、unsafe が抜け穴になるよね、って反論はつまり、
コピペ勢に対して、「いやみんなばんばんunsafe使っちゃうからダウト」って返してるってことw

ここにたまるようなヤツは、必要に応じてモジュール毎にON/OFFくらいできるヤツ
熱心に張り合うまでもなく、有意義に使うよ
0328デフォルトの名無しさん
垢版 |
2023/04/20(木) 23:56:26.81ID:98y/hYCF
わずかなunsafe封じ込め部分だけに注力することで、効率的なsafeを作ってしまえば、safe利用者はコンパイラに安全性の保証を任せられることがRustの最大のメリット
0330デフォルトの名無しさん
垢版 |
2023/04/21(金) 00:13:14.15ID:4oRlgId+
>>325
安全にも書けるのは分かる(それはC++も同じこと)
9yNISOE6の主張が正しいと仮定して
Vecのアクセス範囲に関して危険にも書けるけど
Rustコンパイラは何もできないよねって話
0331デフォルトの名無しさん
垢版 |
2023/04/21(金) 00:14:20.12ID:4oRlgId+
まちごうた
-9yNISOE6の主張が正しいと仮定して
+98y/hYCFの主張が正しいと仮定して
0332デフォルトの名無しさん
垢版 |
2023/04/21(金) 00:14:28.54ID:7fROJFuD
最適化はunsafeというのはRustではほぼ客観的事実に近い

C++で似たような意見を言えば、最適化の足を引っ張る陰謀と見分けがつかない者もいるだろう
0333デフォルトの名無しさん
垢版 |
2023/04/21(金) 00:19:35.15ID:9IEMPFWw
範囲がconst/constexprであれば、チェックコストはゼロにしうるのでは
そこにコストをかけてでもsafeにしましょうというのがモダン(含Rust)
そこにコストがかからないように書いてナンボなのがC++(失敗時は: 安全だがコストが生じる)
0334デフォルトの名無しさん
垢版 |
2023/04/21(金) 00:58:19.29ID:9IEMPFWw
関係あると思うのできかせて

いまさら人に聞けないんだが、Intel MPXってのが早々にディスコンになったのは、
・MPXでも抜けがあることがわかった
・いまやパイプライン? が優秀すぎて、MPXでもソフトウェア サニタイザでもそんな変わらなかった
っていう理解をしてるけど合ってる?
0336デフォルトの名無しさん
垢版 |
2023/04/21(金) 02:33:15.05ID:9IEMPFWw
かのIntel(当時)が頑張ってもこんなもん(こんなことになる)か
難しいもんなんだな。。

俺にできないだけで、本気出せば難しくないもんかと思ってたのに
0338デフォルトの名無しさん
垢版 |
2023/04/21(金) 09:34:15.68ID:Jt0l0JSP
>>330
>安全にも書けるのは分かる(それはC++も同じこと)
C++でもRustと同じレベルで安全に書けるというのはさすがにウソでしょ
複オジの説明がショボいからと言ってウソはダメだよ
0339デフォルトの名無しさん
垢版 |
2023/04/21(金) 10:24:01.60ID:YWjwap1N
play.rust-lang.org で
use rstk::*; とか
use wx; とか
もちろん出来ない訳だが
use したときに一瞬一覧で選べるものが出て来るので
これの一覧をテキストファイルで欲しいんだが
どこで観れますか?
0340デフォルトの名無しさん
垢版 |
2023/04/21(金) 10:33:13.77ID:YWjwap1N
>C++に勝ってると主張するために普段はunsafeのことを脇に置いてメリットばっかり語ってるのに
>性能で負けてるって言われて悔しいからって急にget_uncheckedの話持ち出す

ほんそれ
0341デフォルトの名無しさん
垢版 |
2023/04/21(金) 11:32:23.34ID:obBiE3Vg
>>339
crates.ioのダウンロードTop100とその依存クレート
入れ替えとかどう対処してるのかは知らん
playgroundのヘルプにリスト(Cargo.toml)へのリンクがある
0343デフォルトの名無しさん
垢版 |
2023/04/21(金) 16:08:14.43ID:e/N20Lgf
>>342
それは自分の環境でどうぞ
0344デフォルトの名無しさん
垢版 |
2023/04/21(金) 21:37:21.45ID:AfLtEamq
控えめに言って Rust は超マゾ言語
0345デフォルトの名無しさん
垢版 |
2023/04/21(金) 23:59:16.40ID:LZBHeARm
C++もRustも基本的には変わらん
C++で常に安全に書ける人にとってライフタイムなんてすぐ理解できて困らん普通のことだった
Rustでいいと思ったのはイテレータメソッドチェーンのシンプルさとか
あらゆる部分でパターンマッチングできる点とか
0346デフォルトの名無しさん
垢版 |
2023/04/22(土) 00:04:17.51ID:L3G+XloM
GC言語は良いと思うし使いけど可視化する気にならない
GC言語が多過ぎるから
Python並みの人気でも過半数に支持されるとは思えない
0347デフォルトの名無しさん
垢版 |
2023/04/22(土) 01:08:10.55ID:6MRD/fZf
ライフタイム付き再帰構造体を再帰関数で回してlifetimeのvarianceで苦しむまでがボローチェッカチュートリアルです
0349デフォルトの名無しさん
垢版 |
2023/04/22(土) 07:15:46.36ID:iD47eBZH
言語(Rust含む)がせっかく親切にしてくれてるのに、その虚を突く

…っていうか、虚を天然で踏み抜いちゃうのが、シロウトなんだよなあ 俺含む(自戒
0350デフォルトの名無しさん
垢版 |
2023/04/22(土) 07:19:16.96ID:UYc1nlSd
PythonのAI系のライブラリを
rustで作り直したら爆速になるのかな?
0352デフォルトの名無しさん
垢版 |
2023/04/22(土) 09:44:15.55ID:UBHQks3G
C++のライフタイムが本当に簡単ならライフタイム系のバグを100%検知できるツールなんて簡単に作れるはずだよね?
0353デフォルトの名無しさん
垢版 |
2023/04/22(土) 09:50:17.61ID:OMpDwvP8
>>352
そういう意味ではなく逆だろ
C++でもともなコードを書けているプログラマーはRustでライフタイムをすぐ習得してしまう話だろう
逆にライフタイムを難しいと言ってるプログラマーはC++で込み入ってくると正しいコードを書けない
0354デフォルトの名無しさん
垢版 |
2023/04/22(土) 10:40:59.94ID:iD47eBZH
>>352
いくらか指針・実装はあったんだけど、決定打に欠いた
いろいろと自由すぎたんだよ

Rustのやり方が業界標準になったら、C++がそれを取り込むのは早いと思う
0355デフォルトの名無しさん
垢版 |
2023/04/22(土) 10:48:04.53ID:/en2DlgL
varianceをOOPにたとえると
変数の型を宣言できないが基底クラスなら宣言できる
という理解でいいんでしょ
変数の型を宣言するツールを簡単に作れるかが問題なのでは
0356デフォルトの名無しさん
垢版 |
2023/04/22(土) 10:54:03.92ID:8hXabeY8
ポインタと同じでライフタイムも概念を理解するのは何も難しいことはない
バグなしで使いこなすのが難しいだけ
それだからRustは厳しめのルールにしてコンパイラでチェックする
C++が脆弱性を量産してきた負の遺産を継承しないためにね
0357デフォルトの名無しさん
垢版 |
2023/04/22(土) 11:23:28.94ID:XW9UuYWq
>>356
所有権システムは単純に使いづらい
インスタンス作るときのデフォルトにされるのはちょっと...
0358デフォルトの名無しさん
垢版 |
2023/04/22(土) 12:09:24.25ID:SKSgk+MB
少し前にvectorの再配置の例が出てたけど
他で参照してる間にデータを操作して参照がおかしくなる事故が後を絶たないから仕方ない
普通のイテレータで走査してる最中に要素を削除したりとか
0359デフォルトの名無しさん
垢版 |
2023/04/22(土) 12:57:45.65ID:/en2DlgL
>>358
参照カウントが2以上ならエラーでいい
実行時エラーなら難しくない
コンパイル時が難しいだけ
0363デフォルトの名無しさん
垢版 |
2023/04/22(土) 15:57:35.73ID:nX3yaBf6
>>357
所有権システムはC++もRustも基本的に同じで難しいところはない
表記方法は両者で異なるがRustの方がシンプルに整理されていてわかりやすいだろう

そのインスタンスの挙動についてもRustは新たな型宣言時に特に指定しなければムーブ型になるが
コピー型にしたいならばこう宣言すれば挙動がムーブではなくコピーとなる
#[derive(Copy, Clone)]
struct Foo(i32, i32);
let mut p = Foo(123, 456);
let q = p;
p.0 = 789;
assert!(p.0 != q.0);
assert!(p.1 == q.1);
0364デフォルトの名無しさん
垢版 |
2023/04/22(土) 17:41:44.05ID:+yUQZ3bR
>>359
実行時に参照カウントが2以上ならエラーとなる型もRustでは作れるよ
でももっと便利な仕様「実行時に(可変でない)参照カウントはいくつ増えてもOKだけど、可変参照を得る時だけは独占的つまり参照カウントが0でないとエラー」がもっと便利
標準ライブラリRefCell<T>がその仕様そのままで
RefCell<T>自体の可変参照を持っていなくて(非可変)参照を持ってるだけでもTを書き換えることができちゃう
Rustの厳しい可変参照ルールを無視できるから便利だね
いわゆる内部可変性と呼ばれる型の一つ
0366デフォルトの名無しさん
垢版 |
2023/04/22(土) 18:42:18.67ID:+yUQZ3bR
>>365
Rcはジャンルも機能も動作も利用方法も全く異なりその話は誰もしていないよ
あなたが>>359で言った、
> 参照カウントが2以上ならエラーでいい
> 実行時エラーなら難しくない
> コンパイル時が難しいだけ
は、Rcとは全く異なる挙動でありRcとは無関係

あなたが言っている挙動「参照カウントが2以上ならエラー」は「sIngle reader or single writer」
そしてRefCellはその上位の「multiple readers or single writer」
つまりRefCellはもっと便利であり利用面での上位互換
0367デフォルトの名無しさん
垢版 |
2023/04/22(土) 18:45:43.59ID:pFB+K5t4
話が専門的になってきているけれども、「メモリー関連バグ」はバグの一部に
過ぎず、それが完全に防げたとしてもバグが入り込む余地はたくさんある。
例えば、JSやJava、C#、BASIC、Pythonなどの言語はメモリー関連バグは
入り込まないが、バグはいくらでも入り込む。
0368デフォルトの名無しさん
垢版 |
2023/04/22(土) 18:51:49.24ID:iD47eBZH
Javaはぬるぽぬるぽいってたけどねえ いまさらだけど、あれなんだったんだろう (nullptrは使ってます
0369デフォルトの名無しさん
垢版 |
2023/04/22(土) 19:01:05.60ID:pFB+K5t4
>>367
追加として、Ruby、PHP、Perl なども同様。
メモリー関連バグは入らないが、論理バグはいくらでも入り込む。
だから、ネットショッピングサイトをこれらの言語で作っても、
データ漏洩や、データ消失(顧客情報の間違った削除など)、
インターフェースのバグ、買いたいものが買えない、別人のアカウントで
買った事になってしまう、あるいは、セキュリティーホールなどは、
入り込む余地はいくらでもある。
15 番の人が購入しているのに、16番の人を購入したことにしてしまったりとか。
または、ボタンを一回押したのに、2回購入したことになってしまったとか。
キャンセルボタンを押しても動作しないとか。
または、キャンセルすると、14番の人の購入がキャンセルしてしまったりとか。
そういうのは基本的に論理バグであり、メモリー関連バグとは別に発生しうる。
0370デフォルトの名無しさん
垢版 |
2023/04/22(土) 19:24:40.58ID:2MwGVm8+
>>367
GC言語を含めた多くの言語で発生する普遍的なバグがデータ競合
データ競合は様々なものがあってマルチスレッドでは当然発生するだけでなく
スレッドを利用しなくても部分参照が可能な言語ではデータ競合が容易に発生してしまう

後者の例はこのスレ既出でベクター型においてその何番目かの要素の参照を持っているときに
要素追加が行われると再配置によりダングリングを引き起こしたり
要素挿入が行われると再配置がなくてもズレて意図せず異なる要素を指してしまうデータ競合が起きる

>>369の例の別の人の購入データになってしまったりするバグも様々なデータ競合により引き起こされることが多い

このように色々なデータ競合がプログラミングで発生するが
Rustではデータ競合が発生せずコンパイルエラーとなる
これは非常に大きな強み
0371デフォルトの名無しさん
垢版 |
2023/04/22(土) 19:37:17.80ID:pFB+K5t4
>>370
> 369の例の別の人の購入データになってしまったりするバグも様々なデータ競合により引き起こされることが多い
データ競合が発生しなくても、単なる論理ミスでも発生するから、Rustでも
ちゃんと正しい論理を書かなければ発生する。
0372デフォルトの名無しさん
垢版 |
2023/04/22(土) 19:40:54.01ID:iD47eBZH
ポインタは究極の共有オブジェクトだから、同様に管理する習慣が付けば、データ競合のミスは減りそうだよね
0373デフォルトの名無しさん
垢版 |
2023/04/22(土) 19:50:59.03ID:2MwGVm8+
>>371
それはビジネスロジックの論理バグ
プログラミング言語が何であろうと関係なく生じるのでこのスレの目的である言語の比較に無関係

そしてプログラミングのデータの取り扱いで発生する論理バグがデータ競合
データ競合はバグを引き起こしうるためプログラマーが回避しなければならない
Rustはコンパイルが通ればデータ競合がないことが保証される
任意のプログラミング言語に対してRustが有利
0374デフォルトの名無しさん
垢版 |
2023/04/22(土) 20:01:02.96ID:pFB+K5t4
メモリやデータ競合に関係したバグの送りにくさRustは有利ではある。
ただ、言語に求められるのはそれだけではない。
0375デフォルトの名無しさん
垢版 |
2023/04/22(土) 20:07:00.96ID:2MwGVm8+
>>374
他の言語では起きないまたは起こりにくいバグが
Rustだと起きるまたは起きやすい例ってある?
その例を示せないとRustが最強になってしまうよ
0376デフォルトの名無しさん
垢版 |
2023/04/22(土) 20:10:28.97ID:YMOkCFj1
Visual Studio でC++のMFCや C#のWPFのようにGUI開発がサポートされたら新規ソフトはRustになっていきそう
逆に現状のままなら開発元のMozilla以外はLinuxカーネルみたいなマニアックな用途だけで終わりそう
0377デフォルトの名無しさん
垢版 |
2023/04/22(土) 20:13:15.69ID:pFB+K5t4
>>375
あるけど言わない。それは自分で気付かないと。
なぜ言わないかと言えば、その情報を元に論文書いたり、
国から研究費貰ったりする人がいるから。
0378デフォルトの名無しさん
垢版 |
2023/04/22(土) 20:17:17.43ID:ZakZodsv
let mut hoge: Vec<Vec<String>> = vec![Vec::with_capacity(3); 4];
のとき
hoge.len() は 4
hoge[0].len() は 0
hoge[0].capacity() は 3 を期待していたのですが何故か常に 0 になってしまいます

Why?
0379デフォルトの名無しさん
垢版 |
2023/04/22(土) 20:58:04.53ID:SKSgk+MB
vec![expr; n]は内部でclone使うんだけど、Vecのcloneはcapacityまでは複製しないみたい
複製はできるだけ余剰メモリをカットしたい気がするから仕様だろうな

fn main() {
let a: Vec<String> = Vec::with_capacity(10);
let b = a.clone();

println!("{}, {}", a.capacity(), b.capacity()); // 10, 0
}
0380デフォルトの名無しさん
垢版 |
2023/04/22(土) 20:58:54.89ID:+yUQZ3bR
データ競合を防ぐのは簡単で「multiple readers or single writer」を守れば防げる
どの言語でもそのような形になるようにプログラマーが解決する
ただしRust以外の言語はデータ競合があっても検出できずに競合を起こしたまま動いてしまいバグとなる

>>377
存在しない

>>378
vec!は回数分のcloneするだけ
そしてcloneはcapacityを保持しない
だからその0となる挙動は仕様通りで正しい
その3となる挙動にしたいなら例えば
Vec::from_iter((0..4).map(|_| Vec::with_capacity(3)));
あるいはrepeat_withでtake(4)
0381デフォルトの名無しさん
垢版 |
2023/04/22(土) 21:09:18.75ID:iios9sCz
やっぱりC++のstd::variant欲しいっすな
Refに対応したCow作ったけどなかなかだるい(というか標準で対応してくれの感が激しかった)し
こんどはRc<RefCell<T>>と&Tのenumが欲しい
わざわざ作るのもだるい
0382デフォルトの名無しさん
垢版 |
2023/04/22(土) 21:09:58.95ID:XW9UuYWq
制約は安全性を高めるためなんだろうけど率直に言ってウザいからな
他人に書かせるならRustを選ぶかもしれんがw
自分で書くものにはRustは不要かな
0383デフォルトの名無しさん
垢版 |
2023/04/22(土) 21:26:41.96ID:suBXXmuN
マルチスレッドの主な用途は数値計算なんだけど、数値計算だと
データ競合が起きるような場合はシミュレーション結果がおかしくなるので
テスト段階で分かることが多い。また、脆弱性とも関係無い。
脆弱性が問題になるのは、主にブラウザ。
自分のマシンのセキュリティーホールに悪さをするアホはいない。
つまり、脆弱性とはネットと関係する場合にのみおきると言っても過言ではない。
だから、シミュレーションとかは脆弱性とは関係が無いので、
データ競合が起きたら、結果がおかしくなるだけ。
0385デフォルトの名無しさん
垢版 |
2023/04/22(土) 21:29:51.72ID:2MwGVm8+
>>382
Rustでウザい制約って何かある?
必要な制約は当然あるけど不要な制約はないんじゃないか
0387デフォルトの名無しさん
垢版 |
2023/04/22(土) 21:36:25.12ID:suBXXmuN
ここの人達は、自分と意見が合わない人を馬鹿だと思ってる気がするけど、
それは違うぞ。
俺は貴重な意見を言っている。
まあ、日本全国探しても貴重だろう。
だけど、全部は大事なところは言わん。
0388デフォルトの名無しさん
垢版 |
2023/04/22(土) 21:38:49.06ID:2MwGVm8+
>>383
データ競合はタイミングなどで稀にしか発生しないものも多い
テストで何度か実行すれば必ず判明するわけではない
そして特定の分野でのみ発生するものではない

>>386
もし>>375の例があると主張するなら例を出しなよ
0389デフォルトの名無しさん
垢版 |
2023/04/22(土) 21:39:07.62ID:OFX5zT+6
無能である上に突っ込まれるのが怖くて意見表明すらできない
負け犬極まれりだな
0390デフォルトの名無しさん
垢版 |
2023/04/22(土) 21:41:53.93ID:suBXXmuN
>>388
>データ競合はタイミングなどで稀にしか発生しないものも多い
数学的に考えているから、細かいミスが取れた後は大丈夫。
脳内で証明済みのアルゴリズムを使うから。
才能の無い人は誰かが考えたアルゴリズムを真似て使うのだろう。
俺はそんなことはしてない。
0391デフォルトの名無しさん
垢版 |
2023/04/22(土) 21:42:53.35ID:suBXXmuN
>>389
自分の周りと同じにしないほうがいいぞ。
付きぬけている人をみたことがないみたいだな。
0394デフォルトの名無しさん
垢版 |
2023/04/22(土) 21:50:20.64ID:+yUQZ3bR
>>390
データ競合を引き起こしてきたプログラマーたちは皆そのように言っている
「自分はデータ競合を引き起こさないように(アルゴリズムを考えて)コードを書いた」
しかし実際にはデータ競合が起きた
データ競合はRustのようにプログラミング言語で防いだほうが好ましい
0396デフォルトの名無しさん
垢版 |
2023/04/22(土) 21:54:28.66ID:suBXXmuN
Mozillaは、凡庸な技術者しかいないからRustが必要になった。
それだけの話。
もっとも、普通の企業はそんなもんだろうが。
0397デフォルトの名無しさん
垢版 |
2023/04/22(土) 21:55:58.32ID:XW9UuYWq
データ競合起きたら意図と異なりデタラメな結果になるので
すぐ分かると思うよ
0399デフォルトの名無しさん
垢版 |
2023/04/22(土) 22:00:29.73ID:SKSgk+MB
>>385
文字列全体(String)とその一部の参照(&str)を同じ構造体に詰めないとか
オブジェクト指向言語に慣れた人だと辛いと思う
厳密にはC++でも難しい(&strの初期値で悩む)けどこっちはまだごまかせるし

上の方でもちょっと書いたけど行ロックを意識したDBのテーブル設計に近い印象
とりあえず全項目を1つのテーブルに突っ込むみたいな方法だと途中で引っ掛かるから
大雑把な人には面倒な言語かもしれない
0400デフォルトの名無しさん
垢版 |
2023/04/22(土) 22:03:16.47ID:suBXXmuN
>>397
俺の経験から言ってもそう思う。
テスト時に働かないような「if 文」を入れたりしない限りは。
バグが取れない人は、変なところに if 文を入れている。
数学的な理想世界では基本的には if は存在しないことがおおい。最小と最大の
付近以外では。
だから、数学的に考えられる人は if 文は最低限しか入れないで済む。
このルールを守っていれば、滅多なことで妙なバグは入らない。
0401デフォルトの名無しさん
垢版 |
2023/04/22(土) 22:11:27.43ID:+yUQZ3bR
>>396
つまりRust採用を進めているGoogleやMicrosoftやAWSなどIT各社は凡庸な技術者しかいないからRustが必要になったとの主張??
キチガイじみてるね
0403デフォルトの名無しさん
垢版 |
2023/04/22(土) 22:19:29.86ID:2MwGVm8+
>>399
それはString内容が変わったり空になったら意味のないデータになったり無効メモリを指すから、非GC言語でその設計はよくないね
Rust本スレで話題があったようにもう少し詳細な用途毎にstring_cacheやtyped_arenaを使ったりそういう自作設計をして安全と効率を両立させるべきかと
0405デフォルトの名無しさん
垢版 |
2023/04/22(土) 22:41:58.79ID:DWNDga3I
>>383
>マルチスレッドの主な用途は数値計算なんだけど
へぇーw
0406デフォルトの名無しさん
垢版 |
2023/04/22(土) 22:42:49.07ID:Bx6uBAXU
「数学的」な人だったかww
0407デフォルトの名無しさん
垢版 |
2023/04/22(土) 22:42:53.24ID:/en2DlgL
rustcがソースコードを採点してくれるのに
なぜ採点結果ではなく書いた文字の量を競っているんだ
0408デフォルトの名無しさん
垢版 |
2023/04/23(日) 00:09:49.30ID:XReMgABv
>>399
>文字列全体(String)とその一部の参照(&str)を同じ構造体に詰めないとか
JavaやC#でそういうことする??
0409デフォルトの名無しさん
垢版 |
2023/04/23(日) 00:35:50.04ID:s119dOFU
>>408
例えばURL全体を受け取ってパースした結果の部分文字列を保持する場合とか

JavaとC#は全部Stringにするから関係ないけどRustで同じことをしようとしたときに
本体のStringと一緒に部分文字列の&strを持ちたいと考えるかもしれない

あと?を2つ重ねるとなんか頭悪そうに感じるからやめたほうが…
0411デフォルトの名無しさん
垢版 |
2023/04/23(日) 00:52:26.01ID:hjyESha+
オブジェクト指向全く関係ないな
0412デフォルトの名無しさん
垢版 |
2023/04/23(日) 03:53:33.10ID:a38AwUhr
>>397
データ競合は実行タイミングや入力データなどによって発生したりしなかったりすることもある
だから実行してみて不具合が無ければ大丈夫というものではない

>>400
そういうお子様プログラミングしかしたことがないやつに複雑な状況でのコードは理解できないだろう
0413デフォルトの名無しさん
垢版 |
2023/04/23(日) 08:58:13.51ID:XDoVkNXv
>>380
>ただしRust以外の言語はデータ競合があっても検出できずに競合を起こしたまま動いてしまいバグとなる

Rustで実行時にデッドロックを回避する方法を教えてくれ
0414デフォルトの名無しさん
垢版 |
2023/04/23(日) 09:05:15.73ID:mbhtlP00
デッドロックはデータ競合ではなく無関係
デッドロックはロック順序を守ることで防ぐ
0416デフォルトの名無しさん
垢版 |
2023/04/23(日) 10:01:44.66ID:bH2G2Xj3
Rust初心者だけど、シングルスレッドでしか動かさない場合にも、
マルチスレッドで起きるデータ競合を気にしてるってことよね
それはめんどくさくない?
0418デフォルトの名無しさん
垢版 |
2023/04/23(日) 10:21:19.31ID:mWycOQ2H
>>416
シングルスレッドでも起こる
データ競合が防げるというのはメモリ安全性の副産物
0419デフォルトの名無しさん
垢版 |
2023/04/23(日) 10:47:08.19ID:SLeXOLnV
ライブラリがマルチスレッドかもしれんだろ、そういうとこ油断しちゃだめだw
0422デフォルトの名無しさん
垢版 |
2023/04/23(日) 11:26:29.64ID:L76w/S48
フリーソフトで遊んでる場合にも、お金に関する問題を気にしてる奴が一番めんどくさいぞ
0423デフォルトの名無しさん
垢版 |
2023/04/23(日) 11:41:38.27ID:SLeXOLnV
各社だいたい優秀なんだろうけど、飲酒コーディングするような香具師も混じってるってことだよ
デバフだデバフw
0424デフォルトの名無しさん
垢版 |
2023/04/23(日) 11:45:11.86ID:s119dOFU
参照のread-writeロックもどきは↓みたいなコードを防いでる

fn main() {
let mut a = vec![42];
let r = &a[0];
println!("{r}"); // 42
a.clear();
println!("{r}"); // もういないよ
}
0425デフォルトの名無しさん
垢版 |
2023/04/23(日) 13:20:52.91ID:L76w/S48
a[0]をコピーまたはcloneできる場合にも&a[0]を使うのはめんどくさい
Tをコピーまたはcloneできる場合にもRefCell<T>を使うのはめんどくさい
0428デフォルトの名無しさん
垢版 |
2023/04/23(日) 18:41:22.14ID:y593Lq73
C/C++ で安全なコードを描ける人からすれば Rust なんてホント苦行でしかない
全然生産性上がらないぞω
0430デフォルトの名無しさん
垢版 |
2023/04/23(日) 20:15:54.20ID:njNVQguc
C/C++で安全なコードを描けると思ってるやつはもはやレガシープログラマー
0431デフォルトの名無しさん
垢版 |
2023/04/23(日) 20:20:12.47ID:Rh211EN3
つまり結局のところRustは苦しいと
そう思わないやつはC++で安全なコードを書けると思い込んでいる人であると
それか大したプログラムを書いたことがないか
0432デフォルトの名無しさん
垢版 |
2023/04/23(日) 20:38:12.61ID:SLeXOLnV
酷い目に遭ったことがないんだろう
慣れるまでに、自分が踏み抜いたり、他人が踏み抜いたとばっちりを食ったりするんだけどね

ごりごり汗が書けるやつは、たしかにレガシ コーダだな
ちゃんと書けるなら、レガシにしてレジェンド
0433デフォルトの名無しさん
垢版 |
2023/04/23(日) 20:42:24.61ID:L76w/S48
Cは複雑なGUIを作らず、スクリプトのインタプリタを作るから結構安全だ
外見重視でインタプリタ言語嫌いなOOPが危ない
0434デフォルトの名無しさん
垢版 |
2023/04/23(日) 22:43:02.30ID:9nArI2JN
>>425
コピーできる型でコピーが望ましいならそうすればいいだけだぞ
シーケンシャルにポインタを進めていく方が望ましい時はコピー可能か否かに関係なく参照のイテレータを使えばいい
コピーできる型で内部可変性が欲しいならばRefCellではなくCellを使え
0435デフォルトの名無しさん
垢版 |
2023/04/23(日) 22:48:39.88ID:9nArI2JN
>>428
コンパイル時点でメモリ問題やデータ競合の無いことが保証されるRustはもちろん開発効率がよい
時間と手間の大きな節約になる
0436デフォルトの名無しさん
垢版 |
2023/04/23(日) 23:07:42.53ID:yqsq+eY1
「C/C++ で安全なコードを描ける」=「メモリ問題やデータ競合の無」く書ける
なのでは?
経験を積むと書けるようになるよ
0437デフォルトの名無しさん
垢版 |
2023/04/23(日) 23:31:52.59ID:/tirlZFd
>>436
その根拠のない自信とミスが多くのバグとセキュリティホールを生んできた
一方で経験を積んだ者ならばC++でもRustでもどちらのコードも書けることも事実その通りだ
ならば客観的に各種問題のないことが保証されているRustのコードの方が選ばれる
0438デフォルトの名無しさん
垢版 |
2023/04/23(日) 23:38:05.13ID:s119dOFU
経験を積むと安全なコードを書けると言ってる人は過去に書かれたコードのメンテとかも経験してるんだろうか
当然前後のコードを全て確認したうえで安全なコードを書いてきたんだろうけど
確認作業の範囲を少しでも減らしたいとか考えたことないのかな
0439デフォルトの名無しさん
垢版 |
2023/04/23(日) 23:54:04.28ID:FpD4OybJ
俺がRustへ移った理由もそれ
開発でも保守や更新でも言語システムが自動的に確認作業をやってくれる
こちらはビジネスロジックのテストだけに専念できて非常に効率がいい
0443デフォルトの名無しさん
垢版 |
2023/04/24(月) 00:16:29.06ID:TbIWWoB3
経験深いC++プログラマーにとって、Rustは難しいものでもなく特にウザいものでもないよなあ。
部分的に各片方が書きやすい面もあるが、フィフティフィフティでどちらにも分はある。
結局Rustコンパイラが色々と保証してくれる信頼性と効率性だけが決定的な差異で、Rustへ進む流れだろな。
0444デフォルトの名無しさん
垢版 |
2023/04/24(月) 00:17:39.52ID:5FvgLQUn
完璧なC++のコードを書けるやつならまぁそうすればいいけど、同僚も完璧に書けるかな?って話だよな
同僚も完璧なのが書ける? でも同僚もお前のことを「完璧に書ける奴」と認識してるとは限らない

そんで慢心の発生は自分自身を完璧と信じてるかと関係なく起こるわけで
0445デフォルトの名無しさん
垢版 |
2023/04/24(月) 00:25:06.29ID:6UK4+7Cd
普通にGC付きの言語を使えばそんなウジウジしなくていいのに
システムプログラマ以外にはrustもC++も縁遠い
0446デフォルトの名無しさん
垢版 |
2023/04/24(月) 00:29:33.47ID:6UK4+7Cd
速度を抜きにしてc++の利点は生ポインタを使って直感的にコードを書けたりするところにもあったと思う
それが今は捨てられたのでまあ他の言語でもいいじゃんと思う
0447デフォルトの名無しさん
垢版 |
2023/04/24(月) 00:40:24.53ID:/2/+f4dj
>>445
従来の非GC言語と比べて
Rustは以下の点でGC言語に近くなっていて書きやすいわー
・メモリや競合など色んなことをRustは安全だと保証してくれる
・メモリ解放も常に何もしなくてよくてRustは完全に自動でやってくれる
・各GC言語のモダンな機能がRustも取り入れていて便利に使える
という感じ
対象言語やコードによっては数倍Rustが速くて
エコでリソースコストも少なくて金銭的コストも数分の1になるのが魅力的
0448デフォルトの名無しさん
垢版 |
2023/04/24(月) 00:40:47.69ID:47nwKPG1
C++にあってRustにない特徴はCを包含していること
Rust派は欠点と考えているだろうが
この特徴がなければ普及しなかっただろうね
ハゲの慧眼だよ
0449デフォルトの名無しさん
垢版 |
2023/04/24(月) 01:05:01.61ID:GFnVwc83
>>445
そのへんC++はGC言語と比べて余分なコードレビューコストやメモリ関連のデバッグコストなどもかかっていたけど
Rustはコンパイラがやってくれるから困っていない
0450デフォルトの名無しさん
垢版 |
2023/04/24(月) 04:53:42.06ID:7IjMEuJY
個人的には、Rustは、メモリ安全であると言う以外に魅力は無いと思ってる。
しかも、Java、C#、JS、Ruby、PHP、Perl、Python、Kotlin、Go
は全てメモリー安全。
0451デフォルトの名無しさん
垢版 |
2023/04/24(月) 04:56:59.60ID:7IjMEuJY
それに、C++やCでずっとプログラミングしているが、メモリー関連バグが
生じる頻度は非常に低い。大部分はロジックのバグで、少しずつテストを
するのでその段階で取れることが多い。
メモリー関連バグが起きる場合でも、VisualStudioでは容易に原因箇所が
発見できることが多い。
特にC++では、デストラクタの中に ポインタ型のメンバ変数の delete 文を
書いておけば、メモリー関連バグはまず起きない。
その意味では、C++は、それで賄えない特殊な場合を除いては、メモリー解放が
自動化されていると言える。
0452デフォルトの名無しさん
垢版 |
2023/04/24(月) 05:04:26.63ID:7IjMEuJY
メモリー関連バグは、VisualStudioではコンパイル段階での静的な発見は一般的
には出来ないが、動的には、デバッガを使うことでかなり高い確率でメモリー
関連バグの原因箇所が分かる様になっている。
昔、C言語を使っていて、メモリー関連バグで困るのは、全く原因が分からないような
ことがありえることであったが、C++では、classのデストラクタの中にdelete文を
閉じ込めることによって、メモリー解放が自動化される。
だから、メモリー関連バグが起きるのは、それでまかなえない場合に限る。
同じ関数の上の方とnew文と下の方でdelete文を単純に対応させて書けば
「どう見ても安全」のような書き方ができる。
また、それで書けない場合でも、delete文を、EndXxx()のような「終了関数」
の中だけに書く様にすれば、滅多なことでメモリー関連バグは入らない。

これでも原因不明なメモリー関連バグが起きた場合でも、VisualStudioの
場合はあの手この手で、メモリー関連バグの原因を動的検査で特定し易くなっている。
0453デフォルトの名無しさん
垢版 |
2023/04/24(月) 05:06:00.35ID:7IjMEuJY
CやC++でメモリー関連バグに悩まされている人は、gccなどのフリーのコンパイラ
を使っている人ではないかと思う。
Visual StudioのIDEとデバッガを使えば、メモリー関連バグで悩むことは滅多に
なくなる。
それと、C++の場合は、正しい流儀で書けば、そもそもメモリー関連バグが
入り込む可能性が劇的に減る。
0454デフォルトの名無しさん
垢版 |
2023/04/24(月) 05:12:08.93ID:7IjMEuJY
gccとVisual Studioのメモリー安全性に関する違いは、ヒープメモリに対しての
さまざまな工夫に有る。プログラマが明示的に初期化して無い部分には 0xcccccccc
のようなデータで初期化するコードをコンパイラが書きこむ。
それに、ヒープメモリーのリンクチェーンにも何らかの工夫がされている。
「デバッグビルド」では、そういった構造を、適切なタイミングでチェックする
コードが自動的に付加されるので、「おかしなことをやった直後に近いタイミングで」
IDEが「異常」を報告してくれる。
また、MFCの場合は、さまざまな場所にASSERT() 文で検査コードを入れてあるので、
メモリー関連バグも気付き易い。なんらかの異常は、早い段階で発覚するので、
原因がどこにあるかが特定し易くなっている。
このおかげで、多くの場合は、異常が発見された直前の処理を疑えばよくなっている。
0455デフォルトの名無しさん
垢版 |
2023/04/24(月) 05:45:34.11ID:7IjMEuJY
SNSで、「オブジェクト指向は意味が無く、むしろ駄目」というような話題が
出ることがあるが、C++のclassのデストラクタは、メモリー安全性に大きく
寄与しており、Cよりもメモリー安全になっている。
逆にclassがなければ、メモリー管理にバグが入りやすかったことであろう。
それだけでも、「オブジェクト指向」の意味がある。
0456デフォルトの名無しさん
垢版 |
2023/04/24(月) 07:52:58.48ID:HpPlDS3N
気をつければ大丈夫というのはプログラマーの考え方ではない
少なくとも向いてない
0457デフォルトの名無しさん
垢版 |
2023/04/24(月) 08:08:18.28ID:y0BYTv6v
c++erにとってRustはウザいけど、他人にライフタイム管理を強制できるというメリットが大きい。
基本的にRustは他人にやらせるための言語。
0458デフォルトの名無しさん
垢版 |
2023/04/24(月) 08:23:30.04ID:5e4ZDdTw
ツールやコンパイラがいろいろやってくれる優位性を語っておいて
Rustの利点に目をむけないって意味わからんなあ
0459デフォルトの名無しさん
垢版 |
2023/04/24(月) 08:50:49.89ID:r05pWbWI
セキュアコーディングについて、誰かがキメてくれるというのがデカい
Rustはそれをやったんだ

欲しいのはunsafeのやり方であって、それができるんならC++でもいいんだよ
そうと決まれば、処理系も実装者もどんどん追従する

だから、採用すると言い切ったんだから、APIもとっととRust化してほしい
そうしたら速攻で、unsafeがC++にも来る
0460デフォルトの名無しさん
垢版 |
2023/04/24(月) 09:49:02.72ID:47nwKPG1
>>459
>セキュアコーディングについて、誰かがキメてくれるというのがデカい
>Rustはそれをやったんだ
まぁある方がマシだけどもrustcが検出してくれるのは一部で
>>451に指摘されてるように頻度が少ないので有用性は俺も疑問に思ってる
(率直に言ってあんまり嬉しくない)
0461デフォルトの名無しさん
垢版 |
2023/04/24(月) 10:03:11.22ID:Tyw8xG0A
Rustを難しいとかウザいとか言ってる人は単にまだ慣れていなかったり知識が足りていないだけだ
C++できちんとコーディングできていた人にとってRustは難しくなく慣れと知識を獲得した後はC++よりも全体効率がアップする
したがってRustを難しいとかウザいとか言ってる人の発言は全て無視してよい
0462デフォルトの名無しさん
垢版 |
2023/04/24(月) 10:18:34.43ID:47nwKPG1
>>461
覚えるの面倒くさいねん
将来性もまだちょっと...
だけど面白いので取り入れられるところはC++に取り入れてるよ
Arcパクらせて頂いた
0463デフォルトの名無しさん
垢版 |
2023/04/24(月) 10:33:40.77ID:r05pWbWI
>>1 のとおり、職務とかでやれといわれたらやるんだけど、
Rust勢がいうとおり、デファクトスタンダードになりそうなら、C++にもほぼ間違いなく「来る」だろうしねえ
それなら、安全になったC++でいいや、Rustに限らず、新言語とかたりぃな、とかは思う
新言語覚えるかわりに、安全になったC++勉強しなきゃだし、と言ってもいい
0464デフォルトの名無しさん
垢版 |
2023/04/24(月) 10:39:05.54ID:6eJhjjay
C++とRustの比較は簡単

両方使いこなせるプログラマーはどちらを選んでいるか?
・多くのことをコンパイラに任せられて開発保守効率の良いRust
・その逆でそれらの開発保守効率に劣るC++

企業はどちらを選んでいくか?
・客観的に各種の安全性が保証されるRustで書かれたコード
・その逆で各プログラマーの腕により保証されるC++で書かれたコード

プログラマーと企業どちらの視点に立っても
RustもC++も選べる環境状況にあるならば
新規のプロジェクト(案件)でC++を採用する動機は完全に無くなった
0465デフォルトの名無しさん
垢版 |
2023/04/24(月) 10:47:20.17ID:47nwKPG1
>>464
企業の視点に立つとRustはプログラマが確保できんだろw
0467デフォルトの名無しさん
垢版 |
2023/04/24(月) 11:02:11.39ID:STeINRL5
急速に解決していってるからあとわずかな時間の問題かな
C++しかできない人が既存C++コード保守に群がる構図になっていくんだろうね
0468デフォルトの名無しさん
垢版 |
2023/04/24(月) 11:19:03.31ID:r05pWbWI
あと、C++一本でだいたいなんでも回してる俺のようなアマ
(安全になってくれたら)C++でいいやもう的な
0469デフォルトの名無しさん
垢版 |
2023/04/24(月) 11:28:23.43ID:FCtgfage
>>466
Dropboxの中核部分の分散同期ファイルシステムがRustで書かれていて
表層部分は別部門でTypeScriptとGoを使っている話だろ
GoはC/C++/Rustの代替になれない
0470デフォルトの名無しさん
垢版 |
2023/04/24(月) 11:32:07.93ID:aN7Wz4JN
VSでメモリ安全性に関わるバグを見つけるのが簡単なら
毎月毎月クリティカルなパッチが出る訳がないわな

MSスタックで満足してるうちは井の中の蛙なんだよね
初級者でもビジュアルに分かりやすくデバッグできるように作ってるのがVSなんだから
0471デフォルトの名無しさん
垢版 |
2023/04/24(月) 11:35:12.19ID:47nwKPG1
>>469
Dropboxの分散同期ファイルシステムってGoで書けないの? 何で?
カーネルモードで動かしてる?
0472デフォルトの名無しさん
垢版 |
2023/04/24(月) 11:38:34.52ID:6AbaMjz7
流行り廃りの激しい表層部分がUXの中核だからな

2,3年前のRust分散同期ファイルシステム
→若気の至り、もう弄らない、保守だけ

これから10年
>How Dropbox re-wrote its core web serving stack for the next decade
→Rustは不採用、Goで決定
0473デフォルトの名無しさん
垢版 |
2023/04/24(月) 12:02:37.33ID:r/rb76Fw
>>472
その表層部分はPythonで書かれていたものをGo+TypeScriptに移行しただけでRustはもともと関係ない
サービスを支えている基盤部分がRust製に移行した
0474デフォルトの名無しさん
垢版 |
2023/04/24(月) 12:10:50.29ID:BH9ZYQVS
GoのWebフレームワークのコミュニティは標準ライブラリでかけ勢がおおくて、こいつらについて行くの不安になったからRust勉強する
Rustは頑張ってフレームワーク作る気がありそう
無能に優しくしない言語は伸びないよ
0475デフォルトの名無しさん
垢版 |
2023/04/24(月) 12:14:12.33ID:EfxyAoTl
Rust信者の期待に反して、現実はこんな感じでしょう

2,3年前、インフラのごく一部でRustでも問題ない適用事例があった→今は技術的負債
当然、他の分野(webで言えばfront/back両方)ではRustは不採用
wasmとか勘違いしてごめんなさい
Pythonの置き換えはRustには無理
0476デフォルトの名無しさん
垢版 |
2023/04/24(月) 12:26:21.82ID:e/3EEseX
C++とRustの比較スレで
新インフラ(分散同期ファイルシステ厶)構築にC++ではなくRustが採用されたDropboxの話をRustアンチが持ち出してる時点で
C++とRustの勝敗はついてしまってるなw
0477デフォルトの名無しさん
垢版 |
2023/04/24(月) 12:28:56.90ID:sBa8SLwy
ディフェンスラインが後退したな
0478デフォルトの名無しさん
垢版 |
2023/04/24(月) 12:41:41.74ID:pPYkUROK
このスレ眺めていてもC++のメリットが一つも出てこないもんね
『他の言語を覚えるのは面倒、C++を使ってきたからC++だ』という理由ばかり
0480デフォルトの名無しさん
垢版 |
2023/04/24(月) 12:48:27.02ID:47nwKPG1
C++はCを包含している
C++を習得すればCを別に習得する必要はない
Rustを取得してもCを別に習得する必要がある
0482デフォルトの名無しさん
垢版 |
2023/04/24(月) 13:28:00.07ID:7/BbosrR
>>479
C製とC++製の既存ライブラリはRustでも当然使える
そして既存の枯れた安全なものを中心に実際に使われている
機能追加や更新をきっかけにライブラリの設計が変わる機会にライブラリもRust製にするエコ方式も多い

>>480
もはやCで新たに何かを書き始めることはないから枝葉は不要だがCの基幹部分は基礎知識として重要
とはいえ生ポインタとヒープ確保解放を学ぶだけで十分だから学習はすくに終わる
C++は今さら覚えても意味のあるメリットはないからこれからの人は学ぶ必要ない

>>481
RustもインラインアセンブリをRust変数を使ってRustコードの中に書ける
0483デフォルトの名無しさん
垢版 |
2023/04/24(月) 13:29:40.61ID:efl+P1hN
gccのimplicit-constexpr凄すぎ
>no leaks, no UB
https://www.reddit.com/r/cpp/comments/12hdj3x/c20safety_static_assert_is_all_you_need_no_leaks/
https://godbolt.org/z/Ydc886bjq
最初のバージョンの実装ミスもコンパイルエラー
>didn't compile with 3 push_backs

3年ごとの進化が半端ない
>>459
逆にsafeexpr/safefuncが出来て、しかもimplicit-(un)safeでコンパイル時に自動推論してくれそう
0485デフォルトの名無しさん
垢版 |
2023/04/24(月) 13:34:04.01ID:TWsTM1y7
>>446
unsafe 大好き💛
0487デフォルトの名無しさん
垢版 |
2023/04/24(月) 13:38:41.99ID:Ny7AY3un
>>482 C++製の既存ライブラリはRustでも当然使える
こんな嘘つく時点でry

>>486
今はC側がC++に寄せてきてる
0488デフォルトの名無しさん
垢版 |
2023/04/24(月) 13:39:21.83ID:47nwKPG1
>>486
そんなことは分かってるよ
C++を習得すればCを別に習得する必要がないことを述べるのが主旨
些末な差異は問題ない
0489デフォルトの名無しさん
垢版 |
2023/04/24(月) 13:41:37.19ID:47nwKPG1
ちょっと聞いてみるか
Rustではある程度書けるけどC言語では書けない人っている?
0493デフォルトの名無しさん
垢版 |
2023/04/24(月) 13:46:10.70ID:fzC19LDc
>>483
C++版geigerが出来てsafeに修正していく未来案件が見えて来たw
0494デフォルトの名無しさん
垢版 |
2023/04/24(月) 14:08:38.59ID:fomPRld0
>>487
FFIラッパーの半自動化によりCライブラリとC++ライブラリはRustで使えるし多数使われているよ

>>484
例外を出すライブラリだけはC++側ラッパーでcatchする形で変換
各言語で例外やエラーハンドリングの仕方が異なるからこれはどの言語でも避けられない
0497デフォルトの名無しさん
垢版 |
2023/04/24(月) 14:20:27.48ID:r05pWbWI
>>478
C++を踏まえてできたのがRustなんだろ、優位性を争う気はあんまりないな
C++で十分だって言ってる 改良されればだけどね
0498デフォルトの名無しさん
垢版 |
2023/04/24(月) 14:34:55.91ID:F/4o+lBw
>>494
Rustは例外処理がネックだよな(Rustに限らないけど)
現実には xor rax,rax ですら例外が発生し得るから
async exception handlerをSEHでzero overheadで
実行ファイルに記述する仕組みを(64bit-)OSが提供しているのに
0502デフォルトの名無しさん
垢版 |
2023/04/24(月) 15:09:12.38ID:OTXlubpx
おいおい馬鹿はお前w

レイヤが異なろうがどんなに泥臭かろうがシステム言語の宿命
Rustはシステムプログラミングの何たるかを言語設計の初期段階で考慮していない
CPU例外(≒非同期例外)を構造的にキャッチ出来ない出来損ないシステム言語w
0503デフォルトの名無しさん
垢版 |
2023/04/24(月) 15:28:07.95ID:N3ScgGCG
>>502
RustはCPU例外も割り込みも扱えます
Rustは組み込み用途やOS作成などシステムプログラミングにも使えるように設計されています
Rust(やGoなどの言語)がエラーハンドリングの例外機構を非効率なものとして排除していることとは全く無関係です
0504デフォルトの名無しさん
垢版 |
2023/04/24(月) 15:31:17.42ID:RVkZAaib
Rustは設計段階ではシステム言語のつもりじゃなかったのでは?
言語構文で非同期例外を扱えないのは野暮ったいし
0505デフォルトの名無しさん
垢版 |
2023/04/24(月) 15:40:24.08ID:YPGUiUuq
>>503 RustはCPU例外も割り込みも扱えます... エラーハンドリングの例外機構を非効率なもの
まあPythonですら扱えます、と言うだろうし、非効率ってw?
なんか色々と498が意味するところの理解が追いつかないようだね
講釈するつもりはないから自分で調べてね
0506デフォルトの名無しさん
垢版 |
2023/04/24(月) 16:01:06.96ID:aocmIDBf
C++の例外は実は途中の関数の各スタックフレームを全て処理してから実行されるため非常に遅い
なぜそうしているかというと途中の各関数で全てデストラクタ処理をしないと正しい継続動作ができないため
結果的に例外といっても各関数で早期リターンするのと同じだけの各処理を行なっている
そして各関数で例外が下からやってくることに備えて対処するコードが余分に必要となっている
そのため例外で返すと速く処理されそうなイメージとは真逆で現実のC++の例外は遅く非効率なものとなっている
0507デフォルトの名無しさん
垢版 |
2023/04/24(月) 16:08:44.38ID:niAvm3Dy
まあ初めはシステム言語のつもりはなかっただろうな。
ガベコレのパフォーマンスへの影響が気に入らないけどC++のメモリ管理におけるエラーはきつい
てのがRustの動機だろうし。
0508デフォルトの名無しさん
垢版 |
2023/04/24(月) 16:09:33.04ID:r05pWbWI
そこんとこは、たまに、吐き出されてるバイナリを確認する習慣がほしいとこだね
0509デフォルトの名無しさん
垢版 |
2023/04/24(月) 16:17:07.56ID:JV1rcBb8
途中(503,506)から手抜きしてChatGPT的な文が続いているからディフェンスラインは諦めてると思う
0510デフォルトの名無しさん
垢版 |
2023/04/24(月) 16:27:16.35ID:Mf9PqUPU
>>506
GC言語ならデストラクタを呼ばなくていいから速い例外を作れるけど、
C++は飛ばす部分で必要なデストラクタを漏れなく呼び出す必要があるのか。
C++の例外重すぎだろ。
0511デフォルトの名無しさん
垢版 |
2023/04/24(月) 16:31:03.25ID:+5mPbccJ
>>506
設計思想的には、C++の例外機構は、エラーなどの
「例外的に起きる(=滅多に起きない、レアケース)」
の場合のためのものなので、「例外が起きた時」の速度はほとんど考慮
されていない。ただし、誤解無きように捕捉しておくと
「例外が起きなかった時」のコストは配慮されている。
0513デフォルトの名無しさん
垢版 |
2023/04/24(月) 16:32:44.46ID:+5mPbccJ
設計思想としては、C++の例外機構は関数からの戻り値を返す目的には設計されてない。
なので、その目的でも使おうと思えば使えるが、速度面の配慮がされてない。
0514デフォルトの名無しさん
垢版 |
2023/04/24(月) 16:44:40.41ID:KMWnUB2g
あまり詳しくないけどバイナリ出力はLLVMの守備範囲だと思うから
LLVMが対応しないシステムはRustも対象外ってことでいいんだよね

>>510
GC言語でも必要な時はちゃんとfinallyでdisposeすることをお勧めします
0515デフォルトの名無しさん
垢版 |
2023/04/24(月) 16:45:19.17ID:+5mPbccJ
>>513
簡潔に言えば、C++の例外機構は、エラー発生時のためのもので
アプリの正常走行時には一度も利用されない設計思想になっている。
0516デフォルトの名無しさん
垢版 |
2023/04/24(月) 16:50:59.79ID:7/BbosrR
>>512
Rustにtry throw catchの例外はないのでその話はRustに無関係
代わりにResult返しと?オペレータになって普通にdrop処理もされる
C++のような例外対処コードの付加は必要ない
途中関数で必要に応じて自動エラー型変換も可能だからC++より便利
0517デフォルトの名無しさん
垢版 |
2023/04/24(月) 16:59:10.31ID:qWiU4JKE
>>516
Rustは非同期例外が発生しない謎保証をしてるの?
まさかdrop漏らしちゃうの?システム言語失格だよ?
0518デフォルトの名無しさん
垢版 |
2023/04/24(月) 17:05:38.54ID:D9KAIGag
>>515
その正常走行時の意味合いがプログラミング言語によっても変わるし分野によっても変わる
つまりエラー時の意味合いがバラバラで役立たない

例えば指定ファイル複数が一つも存在してなかったら作成して見つかれば内容を返すとしよう
あるファイルが一つ存在しなくても正常走行だが存在しないと例外を出す文化もある
指定ファイル複数全て見つからなくても作成する正常走行だが例外を出す設計する人もいる
エラーとか異常とかの意味するところが色んな人で違ってる

結果としてC++でも例外を使いまくる関数やライブラリがあったり
全てをエラー値として返すライブラリもあったりする
そしてC++の例外は負荷コストがかかる
Googleのように例外使用禁止ルールを設けているところも多い
0519デフォルトの名無しさん
垢版 |
2023/04/24(月) 17:16:16.97ID:7/BbosrR
>>517
Rustならばasync関数からの返り値もResultとなり異常時も受け取れる
Rustは付加コストのかかるtry例外機構を必要としない
0520デフォルトの名無しさん
垢版 |
2023/04/24(月) 17:25:55.51ID:Qcn/lsDd
0点、ChatGPT?

そりゃRustはシステムプログラミング言語って標榜するしかこの先生きのこることが
出来ないと考えてるのなら必死ですよね
0521デフォルトの名無しさん
垢版 |
2023/04/24(月) 17:28:30.42ID:r05pWbWI
C++は例外対応をオプションでOFFにできる おなじように、safe/unsafeもできるようにはやくなってくれ
0522デフォルトの名無しさん
垢版 |
2023/04/24(月) 18:06:06.65ID:LQT8UQ2a
>>506
ローカル変数のデストラクタを呼び出すこと自体はC++で例外投げてもRustでErr返しても同じなので
そこは別にRustのアドバンテージではない

その調子でC++の勘違い名言集の量産お願いしますよ
0523デフォルトの名無しさん
垢版 |
2023/04/24(月) 18:08:15.36ID:p+d7XoeA
>>519
C++は非同期呼び出しでも例外を投げたり受けたりできるけど、
ライブラリが一旦catchして、値として渡して、再びthrowするからコストは非常に高いな。
0524デフォルトの名無しさん
垢版 |
2023/04/24(月) 18:13:22.35ID:p+d7XoeA
>>522
C++の例外がコスト高いと言われているのは、デストラクターを呼び出すこと自体ではなくて、
例外が関数を通過するときに適切にデストラクターを呼び出せるように、そのテーブルやコードを用意することだと記憶してるが。
0525デフォルトの名無しさん
垢版 |
2023/04/24(月) 18:14:58.99ID:3hT7+QpV
>>524
そりゃそうだろう。
デストラクタ自体は、Rustでも意味的に似たようなものを呼び出す必要があるわけだから。
0526デフォルトの名無しさん
垢版 |
2023/04/24(月) 18:15:34.58ID:LQT8UQ2a
>>502以降の流れの非同期例外ってたぶんasync/awaitじゃなくて割り込みやシグナルのことだと思うんですけども……
0527デフォルトの名無しさん
垢版 |
2023/04/24(月) 18:19:00.14ID:3hT7+QpV
あと、勘違いしてる人がいるかもしれないので念のため言っておくと、
C++のデストラクタは関数の一種に過ぎないので、デストラクタの呼び出しは、
本質的に関数 call と同じものである。そして、C/C++ の関数 call は
比較的高速であり、簡単な場合であれば数クロックで呼び出せる。
なので、本質的にデストラクタの呼び出しコストは、ほとんど 0 に近くて、
本質的にはデストラクタの中身で処理時間が決まる。
0528デフォルトの名無しさん
垢版 |
2023/04/24(月) 18:31:14.27ID:7KRWLK/0
>>523
もちろん非同期で例外を使ったら大きく負け
同期でも自分で例外を投げたら負け
余分な見えないコードなどのコストがかかるだけでなく
例外自体の有無が把握しづらくドキュメントとコードのレビューコストがかかる
下から例外が来るのかどうか把握
それら例外を上へもらしてないか把握
必ずエラー値で返すコード規約にして見える化してるところは賢い
0529デフォルトの名無しさん
垢版 |
2023/04/24(月) 18:33:19.55ID:3hT7+QpV
ところで、
Rust で Vec に要素を追加した場合にメモリー不足になったかどうかを検出
するのはどうしたらよいんでしたっけ?
0531デフォルトの名無しさん
垢版 |
2023/04/24(月) 18:45:07.77ID:md6HjKWe
すげーのびてるけど中身のあるレスが一つとしてなかった
さすが隔離スレ
0532デフォルトの名無しさん
垢版 |
2023/04/24(月) 18:57:04.81ID:mMe0a6TH
>>526
割り込みやシグナルは例外とは別物

割り込みハンドラやシグナルハンドラが発生したその場で小さい処理でデータを得るか何もせずにフラグを立てる
プログラム本体には影響を与えない
そしてそのフラグなどのチェックはハンドラとは別にプログラム本体のどこかで任意の形で任意のタイミングで自由にチェックする
そこで例外を投げるか否かも自由であり直接関係はない

例外はプログラム本体やライブラリやOSなどが投げる
するとキャッチとの間の関数すべてが飛んでプログラム本体は影響を受ける
0534デフォルトの名無しさん
垢版 |
2023/04/24(月) 19:36:13.19ID:HpPlDS3N
言語の機能だけが重要ではない
エコシステムとコミュニティが同じくらい大事なんだよ
0535デフォルトの名無しさん
垢版 |
2023/04/24(月) 22:48:09.25ID:7GuNUS74
>>526
そのRust叩きをしている彼がデタラメを言ってる
C++の例外は同期例外なので仮に彼の主張が正しいならばC++もアウトになる

C++の例外は呼び出した関数の中でthrowが投げられてその呼び出し側でのみcatchできる同期例外
関数呼び出しが深くなっても全て同期となる時のみC++は例外をサポートしている
スレッド間など非同期となるときはC++は例外を投げられないのでcatchしてデータとして渡して再びthrowするしかない
0536デフォルトの名無しさん
垢版 |
2023/04/24(月) 22:51:49.29ID:7GuNUS74
つづき
そしてC++のような同期例外は例外を廃止することも可能
例外を値として関数からのリターン値の一つにすることで例外を無くせる
これを実際に行なっている言語がGoやRustであって例外を廃止してエラー値の一つとして返している
C++でも自主的に同じことが可能であってコーディング規則により例外を返すことを禁じているところもある
例外を使うべきでない理由が複数あるためだ
0538デフォルトの名無しさん
垢版 |
2023/04/25(火) 07:01:02.99ID:EHeneqRq
C++で例外を使うデメリット
・値返しの時よりもコードサイズが増える
・値返しの時よりも実行速度が遅くなる
・どちらもRAIIに基づく自動デストラクタは通過関数で呼ばれるが、それ以外で何かしてると例外時にメモリリークする
・各通過関数で例外が通過するのかどうかがわからず、関連する全てのコードを追う必要があり保守性が悪い
・例外を誰もcatchしない処理忘れが起きやすい
など多数
0540デフォルトの名無しさん
垢版 |
2023/04/25(火) 08:52:43.77ID:MJkz9zZx
C++の例外の利用を禁止しているプロジェクトも多いし
C++の例外は要らない子
0541デフォルトの名無しさん
垢版 |
2023/04/25(火) 09:25:09.15ID:jEavB9HA
Nim 派の漏れだが
おまいらが執拗に Rust 薦めるから
使っても居ないのに批判はするべきでないと思って
Rust 使って観たがやはり君らの言う通り面倒な言語だ
C/C++ に対するメリットが面倒さを上回っていない
Nim に戻るわ
0542デフォルトの名無しさん
垢版 |
2023/04/25(火) 09:35:36.87ID:ORuH1n7Y
面倒と言ってるのは使いこなせていないダメな連中ばかりな点が面白い
どの言語でも使いこなせるようになった時点同士で比較しないと意味がない
Rustは少なくともC++よりは開発効率も保守性も良く手間も時間も節約になる
0544デフォルトの名無しさん
垢版 |
2023/04/25(火) 09:49:25.88ID:jEavB9HA
>>542
うん
だから C/C++ を批判して Rust 推してる連中も
C/C++ を使いこなせてないんだということも同時に悟った
ホントありがとう
0546デフォルトの名無しさん
垢版 |
2023/04/25(火) 09:59:52.69ID:kFjsyCNQ
C++はコンパイル時点でエラーを出してくれない事項が多くて、言語仕様により静的解析ツールでも限界があるため、コードレビューを増やして、さらに実行して動的解析やデバッグツールと、手間暇かかってたことが、Rustでコンパイル通すだけで済むようになったのがうれしいです
0547デフォルトの名無しさん
垢版 |
2023/04/25(火) 10:08:12.19ID:tuLJpxi/
良くも悪くもRustはそれなりに受け入れられるだろうね。
ここ数年の流れはJavaの出だしの頃に非常に似ている。
Rust認定試験全盛になり、Rust採用枠が雨後のタケノコの如く大量に出来て、
Rustリプレースの経済的嵐が来るね。

そしてやがてはJavaやPHPやVBみたいにドカタ言語だと罵られる。
最期は銀行のシステムにも使われて不祥事起こすニュースまで見える。
0548デフォルトの名無しさん
垢版 |
2023/04/25(火) 10:25:56.34ID:JrTTHQQr
5年先をいってるアメリカの状況を見てくるといいよ
0549デフォルトの名無しさん
垢版 |
2023/04/25(火) 10:57:04.79ID:2yJ/wM2b
俺もRustに手を出したばかりの頃は
難しい、面倒だ、ウザい、と思っていた時期もあったよ
しかしそれは単にまだ無知で慣れていなくて色んなやり方を知らない超初心者なだけだったな
だから、難しい、面倒だ、ウザい、と書き込みしてる人のアドバイスは全く役に立たないよ
0550デフォルトの名無しさん
垢版 |
2023/04/25(火) 11:00:14.12ID:SLebcTTI
なんか
・良い物は自分らで書く
・クソどうでもいい物は他人に書かせる
という前提で話を進めている人がいる気がする

標準ライブラリで書け勢というのも他人に書かせた物を利用しない勢だよな
0551デフォルトの名無しさん
垢版 |
2023/04/25(火) 11:10:21.23ID:TXoqgMbP
標準ライブラリで書けってのはあれかい、やたらunsafeで書くなってやつかい(ひっかきまわし
0552デフォルトの名無しさん
垢版 |
2023/04/25(火) 11:16:45.20ID:S/F8mIrU
真面目にRust使ってる人はrustcにマウント取られるので忙しいのです
ここでrustcの真似っこしてC++erにマウント取ってる人は、rustcにマウント取られたまま逃げて停滞している人なのです
0553デフォルトの名無しさん
垢版 |
2023/04/25(火) 12:09:33.28ID:2Q7bhLWK
>>549
お前は超初心者なのでは?
0554デフォルトの名無しさん
垢版 |
2023/04/25(火) 12:28:20.73ID:o3HFo3jF
Rustのshared XOR mutableがウザくないというのは信じられん。
厳密性の観点から重要というのは理解できるが。
0555デフォルトの名無しさん
垢版 |
2023/04/25(火) 12:29:59.91ID:F5kqvgZa
>>550
どゆこと?
0556デフォルトの名無しさん
垢版 |
2023/04/25(火) 13:56:36.59ID:ydyNsZFf
>>554
安全に書くのってこんなにウザかったんだと実感する
0558デフォルトの名無しさん
垢版 |
2023/04/25(火) 17:27:39.88ID:TXoqgMbP
めんどくさい感が楽しいのは、C++で十分なんだよなあ (といいつつ、この点は互角
0559デフォルトの名無しさん
垢版 |
2023/04/25(火) 17:40:59.19ID:92EMGOvn
lifetimeや所有権はうざいくらい
しつこく警告してコンパイル通さないのに
unsafeはなんぼ書いてもお咎め無しなのも面白い仕様な
0560デフォルトの名無しさん
垢版 |
2023/04/25(火) 17:58:10.72ID:SLebcTTI
>>555
他人を信じない人がいる、というか他人のソースコードを読まない人がいるのかもね
読まないのも自由だからいいけど
他人が何を書いても自由だから、読む価値がありえないとは言えない
0561デフォルトの名無しさん
垢版 |
2023/04/25(火) 18:06:32.83ID://U1oA7y
>>547
>ここ数年の流れはJavaの出だしの頃に非常に似ている。
よく分からない。当時は本屋にJavaが並んだなと思ったら、既に大人気
状態だった気がする。人気と本のどちらが先に出たかの前後関係は良く知らない。
0562デフォルトの名無しさん
垢版 |
2023/04/25(火) 18:23:59.84ID:sY5ul2B3
>>559
lifetimeや所有権がうざいって、
あなたC++でも正しいコードを書けていないでしょ
所有権はC++もRustも同じ
lifetimeはC++で明記されないけど満たすように書かないとダングリング
0564デフォルトの名無しさん
垢版 |
2023/04/25(火) 19:38:05.27ID:aqZr5Pum
lnked listなんてアクセス遅すぎて
ほとんどの用途はベクターの方が結局速い
残りの用途はバイナリーツリーなどになるが車輪の再発明してもよいことはなくライブラリを使うべき
0566デフォルトの名無しさん
垢版 |
2023/04/25(火) 19:57:48.42ID:Dk+hkiE7
リンクリストはマジ遅い
値の読み書きも挿入も削除もまずその場所を見つけたどるのにO(n)かかってしまう
0567デフォルトの名無しさん
垢版 |
2023/04/25(火) 20:54:35.52ID:XIw07JKL
>>563
そのエラーを起こしているバグは所有権もライフタイムも関係ない
ロックをつかんだまま更にそのロックをつかもうとしている一般的なバグ
ブロックを分ければロックが解放されて解決する
初心者が一度は通る道だが二度目以降は一瞬で対応できるようになるだろう

ちなみにそのコードに限れば最初からmutロックを得る方法でも解決できる
0568デフォルトの名無しさん
垢版 |
2023/04/25(火) 21:03:25.18ID:XIw07JKL
>>563
あと&nextの&は冗長で不要
その前の行もSomeで受けるときに右辺に&を付けるよりも左辺にrefを付けたほうが今後に一般的に対応できる
0570デフォルトの名無しさん
垢版 |
2023/04/25(火) 22:09:05.21ID:FSwGLA9a
563がRcとRefCell使ってるのはgitのバージョン管理ツリーみたいなデータ構造を作りたかったのかな
set_lastで要素を追加するlistの参照に敢えてmutを付けないあたりに強いこだわりを感じる力作
0571デフォルトの名無しさん
垢版 |
2023/04/25(火) 22:59:52.83ID:ith9obtO
力作でもなんでもなくRcとRefCellの基本にすぎないな
もちろんRcとRefCellを使わずにmutの普通のリンクリストも作れる
一長一短あるので用途に合わせて使い分け
0572デフォルトの名無しさん
垢版 |
2023/04/26(水) 00:23:36.32ID:8XaB5QqW
単純にノード単位で共有する感じか
なんか逆方向に枝分かれしながら伸ばしてツリー状のグラフを作るイメージをしてしまった
0574デフォルトの名無しさん
垢版 |
2023/04/26(水) 01:10:35.86ID:N0yJtyL8
>>564
LinkedListを単独で使う前提でVectorと比べればそりゃ大半の用途で遅くなる
そういう使い方は普通しない
CS101で習う内容
0575デフォルトの名無しさん
垢版 |
2023/04/26(水) 01:21:03.37ID:1VlSMqUT
LinkedListは要素の挿入や削除が頻繁に行われる用途で使うものだと思うけど
vectorはそんな用途には向いていない
0576デフォルトの名無しさん
垢版 |
2023/04/26(水) 01:30:48.26ID:N0yJtyL8
LinkedListでVectorより効率的に挿入や削除を行うためには
どこに挿入するかどの要素を削除するかをピンポイントで事前に把握できてる必要があるよ
0577デフォルトの名無しさん
垢版 |
2023/04/26(水) 01:45:09.49ID:xAlX+8Be
RustにもSTLのstd::listみたいなのくらいあるやろ?
自作して何がうれしいのかな?
0578デフォルトの名無しさん
垢版 |
2023/04/26(水) 01:48:47.01ID:1Uz+jjx7
>>575
意外に思うかもしれないけど
リンクリストは挿入削除の位置までリンクをたどるコストが実は非常に高い
たどった分の個数の読み出しが発生しているためベクター利用でシフト挿入削除の方が速いこともある
理由としては読み出し発生の個数は平均して両者でほぼ同じだがシーケンシャルなベクター利用が速くて勝ち
ベクター利用はそこにシフト書き込みが発生するけど御存知のようにCPUサイクルは読み込みサイクルと比べて書き込みサイクルが超高速
0579デフォルトの名無しさん
垢版 |
2023/04/26(水) 01:50:34.41ID:N0yJtyL8
LinkedListを自作するとRustのOwnershipルール/Rerefernceルールや
Rc<RefCell<T>>みたいな頻出パターンを苦労しながら学べる(らしい)
まあ学べてない人もいるけど
0581デフォルトの名無しさん
垢版 |
2023/04/26(水) 02:12:38.44ID:QEFRGsvT
>>573
その>>567のアドバイス通り
ブロックを終わらせたらborrow()のロックが解放されて動くようになったよ

if let Some(ref next) = list.0.borrow().next {
set_last(next, value);
return;
}
list.0.borrow_mut().value = value;

結局アドバイス二つ目のborrow_mut()だけを最初から使う方法にしたよ

let mut node = list.0.borrow_mut();
if let Some(ref next) = node.next {
set_last(next, value);
} else {
node.value = value;
}
0582デフォルトの名無しさん
垢版 |
2023/04/26(水) 02:20:44.73ID:V27dNYw1
参照は適当なところで死んでくれるのにRefはそうじゃないのがだるいって言ってんの
0583デフォルトの名無しさん
垢版 |
2023/04/26(水) 02:37:31.30ID:wGFuhVl0
そんな事例あるか?
Hoge(ref x) = y と
Hoge(x) = &y は完全に同じだろ
複数マッチングなどrefしか使えないこともあるから参照はrefで受けるのが好ましい
0585デフォルトの名無しさん
垢版 |
2023/04/26(水) 03:11:17.63ID:EoYJiu34
RefCellが返すRefやRefMutはロックガードの一種
他のロックを使うときと同じ利用方法でOK
一時利用が終わるかブロックを抜ければ自動解放され快適
0587デフォルトの名無しさん
垢版 |
2023/04/26(水) 03:33:09.04ID:7yfVI/A5
>>566
それはあなたの使い方が間違っているから。
576, 578 の人も同様。
LinkedListでは、場所のラベルとして、index ではなく pointer を使わなければならない。
それを守ればとても高速。
0588デフォルトの名無しさん
垢版 |
2023/04/26(水) 03:37:05.06ID:m5i6OxT0
>>586
RefCellはmultiple readers or single writerのロックをして参照や可変参照を借用できる型
RwLockと同じように読み出しは複数可だが書き込みは単独独占となる
同じようにロックガードが消えればロックは自動解放される
ただしRwLockとは異なりスレッド間では使えない
0589デフォルトの名無しさん
垢版 |
2023/04/26(水) 04:05:00.19ID:RAzLC92N
>>587
君の主張には無理があるな
君の主張通り、各ノードへの直接の各ポインタを保持するならば、それらポインタ群リストを格納する場所はどこか?
その格納場所はベクターか別のリンクリストとならざるをえない
君の主張だと二重管理となりさらに遅くなる
現実には>>578の解説のように挿入や削除ですらリンクリストよりベクターが速くなりうる
0590デフォルトの名無しさん
垢版 |
2023/04/26(水) 05:12:35.92ID:7yfVI/A5
>>589
全然違います。
特定の要素を覚えるのはアドレス(ポインタ)を番号として用います。
また、そこから隣に移動したい場合は、右隣は、pNextで、左隣は、pPrev
辿っていくことが出来ます。これらはそれぞれ1クロックしかかからないので、
idx++ と同じ速度なので、効率は最高に良いです。
ほとんどの場合、ポインタを覚えるのに別の集合は必要ありません。
もし、必要な場合は、配列の場合でも index を覚えるために別の集合が
必要になるような場合です。
しかし、それは稀です。なので、LinkedListの場合も稀です。
0591デフォルトの名無しさん
垢版 |
2023/04/26(水) 06:31:44.27ID:nP514kb2
>>590
他の方々はそのような特殊な使い方のみを前提としていない比較だと思いますが、その特殊な場合で比較してみましょう。

前後の要素へポインタを移すために、ptr++とptr--だけで済むのは配列やvectorです。
実際には最大アドレスまたは最小アドレスとの比較も必要ですが、この値もレジスタに持っておくので、比較と増減で2サイクルで済みます。

一方でlinked listの場合、前後の要素へポインタを移すためには、ptr = ptr->nextとptr = ptr->prevそして0との比較になります。
キャシュがヒットしなかったとして、メインメモリから読み出すとすると、100~数百サイクルかかります。
もちろんキャッシュに乗ればマシになりますが、linked listは予想ができません。
このようにポインタの移動だけでも、メモリアクセスが生じるlinked listは非常に不利です。

各要素の内容自体の読み込みは、どちらも同じなりそうですが、少しだけ違ってきます。
vectorならば次々とシーケンシャル読み出しとなり、確実にL1キャッシュに乗りますので、読み出しは4クロック程度で済みます。
linked listはnext/prevを読み出すときに多大なコストを払っているので、内容自体の読み込みはキャッシュに乗ってるでしょう。
しかし、キャッシュに乗ってもnext/prevのサイズ分だけ早くキャッシュから外れるため、やや不利となります。

したがって、前後の要素へのポインタの移動でも、要素の内容読み出しでも、vectorが速くなり、linked listは遅くなります。
0592デフォルトの名無しさん
垢版 |
2023/04/26(水) 08:16:17.35ID:090dM5ZS
またその話...
状況次第なので
二人ともLinkedHashMapの場合で持論を展開してください
0593デフォルトの名無しさん
垢版 |
2023/04/26(水) 08:21:46.43ID:e279LTxP
なんでも測ってみないとダメってばーちゃんが言ってた
勉強になるからいいけどw
0594デフォルトの名無しさん
垢版 |
2023/04/26(水) 09:51:14.24ID:zYbSfnJu
コンパイラ通せば終わり(キリッ)っていうバカを助長させてるだけだな。
0596デフォルトの名無しさん
垢版 |
2023/04/26(水) 12:00:07.23ID:1VlSMqUT
>>576
使い方次第では?
頭から順番にイテレートさせて条件にマッチした場合に不要要素削除や追加する場合は普通に便利だろ?
君がそういう用途を思い浮かべられないんだろ?
0598デフォルトの名無しさん
垢版 |
2023/04/26(水) 12:41:46.92ID:mk8XnWac
>>596
自分も昔はそう思い込んでた
しかし現実のほとんどの用途はvectorでまとめて処理するのが速いと分かった
0599デフォルトの名無しさん
垢版 |
2023/04/26(水) 13:29:30.45ID:8XaB5QqW
LinkedListはリストの先頭とか要素自身のインデクスを知らなくても前後に要素を差し込んだり自身を削除したりできるから
サイズが不定だったり大きかったりする要素を数珠つなぎにする場合に使える
Linuxカーネルのページ管理でそういうことしてたと思う(今現在は知らないけど)
小さい要素を大量に保持するなら挿入、削除があってもキャッシュしやすいvectorが強そう
0603デフォルトの名無しさん
垢版 |
2023/04/26(水) 16:47:25.16ID:e279LTxP
小学校の算数かよ

ごめん俺、小学校の算数躓いた勢だったわww
ちょっと算数系の学習障害 はいってるんかもしれん
0604デフォルトの名無しさん
垢版 |
2023/04/26(水) 16:48:15.43ID:9EDgaMeS
月面着陸船が落っこちたそうだが
Rustで書いてれば成功したはず
それにしてもローバーは活躍出来ず流産乙
0605デフォルトの名無しさん
垢版 |
2023/04/26(水) 17:01:55.60ID:2Da7m8zO
>Rustで書いてれば成功したはず
↑この発想がそのまま↓なんだと言う自覚ゼロ
>コンパイラ通せば終わり(キリッ)っていうバカ
0607デフォルトの名無しさん
垢版 |
2023/04/26(水) 18:28:24.85ID:FJ6FgKNy
>>600
どこの場でも同じだけど
正しい指摘ができずに
嘘!違う!とだけ言い出したら
その人は負けなんですよ
>>591に書かれていること自体は正しいと思いますよ
0609デフォルトの名無しさん
垢版 |
2023/04/26(水) 18:42:01.34ID:/TEdGcy5
言葉ではなく、脳内に画像的なイメージを描かないと駄目ですよ。
全然それが出来てない。
0611デフォルトの名無しさん
垢版 |
2023/04/26(水) 19:04:57.37ID:N0yJtyL8
>>596
便利だと思うのは自由だけど
頭から順番にイテレートしてから挿入・削除するような使い方だと
Cache Localityの違いによってVectorより性能が劣る

性能が重要ならLinkedListは挿入・削除時にイテレートが必要ないようにして使う
HashMapとLinkedListを組み合わせたLRUキャッシュとかね
0612デフォルトの名無しさん
垢版 |
2023/04/26(水) 19:11:34.98ID:4J8YauGV
>>611
ヒープに要素があってvectorがキャッシュされない状態だと要素のメンバーの条件によって削除挿入するなら
vectorの方が不利だよね?
それは理解出来る?
0614デフォルトの名無しさん
垢版 |
2023/04/26(水) 19:38:13.57ID:qH1OmRtr
>>612
メモリキャッシュ自体はヒープもスタックも関係ないが
もちろんスタック上は常にキャッシュに載るから
上限値が決まっているならば全てスタック上に載せたほうが有利
ヒープは確保と解放のコストもかかるから大きく不利

そのためベクター型でもスタックを利用するものを使うとさらに速くなる
例えばRustはスタックをなるべく多用するために3種類のベクター型が使い分けられている
(1) ArrayVec は上限値を定めてスタックのみを使うベクター型
(2) SmallVec は上限値を定めてその範囲内ならスタックのみを使って超えたらヒープを使うベクター型
(3) Vec はヒープを使うベクター型
それぞれコストとわずかに特性が異なる
0615デフォルトの名無しさん
垢版 |
2023/04/26(水) 20:22:03.82ID:Pd8SmuYa
https://ideone.com/hqXsfu
シャッフルされた数列を昇順にinsertした
{
std::vector<int> xs;
auto b = std::chrono::system_clock::now();
std::for_each(v.begin(), v.end(), [&xs](int x) {
auto pos = std::find_if(xs.begin(), xs.end(), [x](int y) { return x < y;});
xs.insert(pos, x);
});
auto e = std::chrono::system_clock::now();
std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(e - b).count() << std::endl;
}
{
std::list<int> xs;
auto b = std::chrono::system_clock::now();
std::for_each(v.begin(), v.end(), [&xs](int x) {
auto pos = std::find_if(xs.begin(), xs.end(), [x](int y) { return x < y;});
xs.insert(pos, x);
});
auto e = std::chrono::system_clock::now();
std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(e - b).count() << std::endl;
}
0616デフォルトの名無しさん
垢版 |
2023/04/26(水) 20:41:37.78ID:4J8YauGV
>>614
イメージが違うな
シーケンシャルに要素が詰まってるんじゃなくてヒープに乱雑に詰まってる大きめの要素だとキャッシュに乗りにくいだろ
vectorはそのインデックス
0617デフォルトの名無しさん
垢版 |
2023/04/26(水) 20:45:35.28ID:4J8YauGV
要素としてintが並んでるだけの実際にはないようなパターンの話をされても困るだろ
何らかのオブジェクトが大量にヒープのあちこちに詰まっててvaetorはそのポインタが入ってる
0619デフォルトの名無しさん
垢版 |
2023/04/26(水) 20:51:22.56ID:gAezaDDb
>>616
大きなデータだとそういう二段階データ構造にする場合もあるというだけだろう
例えばソートは実体を移動させるよりもインデックスだけ移動させる新たなベクターを設ける
しかしその元の実体もベクターに格納したほうが有利なことが多い
ヒープに乱雑に格納するケースはかなり限られてくる
0620デフォルトの名無しさん
垢版 |
2023/04/26(水) 20:56:32.56ID:G4JVGBup
>>615
実測いいね
リンクリストが遅い結果になるのは予想できたけど
ベクターの方が10倍以上も速いとは驚いた
0621デフォルトの名無しさん
垢版 |
2023/04/26(水) 20:57:54.91ID:4J8YauGV
限られてはいないだろ
インサート、デリートを乱雑に繰り返して格納するケースだらけだろ


普通に要素数が分からないし、生成時期も分からないものを突っ込むことが多いんだから
0628デフォルトの名無しさん
垢版 |
2023/04/26(水) 21:08:39.08ID:NzJ1LltZ
とても大きなデータならば
もう一つインデックス用vectorを用意すればよい
vectorのインサートは速いままだ
0629デフォルトの名無しさん
垢版 |
2023/04/26(水) 21:32:20.97ID:t/VPhEoq
>>615
リンクリストが唯一勝てそうなinsertまで敗北かよ
知らんかったわ
リンクリストの負けが確定だな
0630デフォルトの名無しさん
垢版 |
2023/04/26(水) 21:39:12.36ID:2SSTMM1B
データ構造の操作に限ればキャッシュにのるかのらんかで全然違うよな
まあ、リストでもスタック内で作ればいつものるけどね
0631デフォルトの名無しさん
垢版 |
2023/04/26(水) 21:40:47.62ID:Pd8SmuYa
チョコチョコやっててもキリがないけどとりあえず少しだけ…
これ以上グズグズやってもうざいやろからこれで最後ね

>>626
> intじゃなくて256byteぐらいのデータでやってみると逆転したり
https://ideone.com/8p2nq0
struct foo {
int value, a[(256 / 4) - 1];
foo(int value) : value(value) {}
};
352 ←ベクタ
296 ←リスト
ちな128bytesだとまだベクタが速かった

>>617
> 何らかのオブジェクトが大量にヒープのあちこちに詰まっててvaetorはそのポインタが入ってる
https://ideone.com/8bwMkQ
上記の生ポインタ版。
53 ←ベクタ
245 ←リスト
0632デフォルトの名無しさん
垢版 |
2023/04/26(水) 21:42:50.60ID:4J8YauGV
このスレを リンクリストで抽出してレスしてる人を見ると1人を除いて多分ほぼ同じ人だと思うわ
0633デフォルトの名無しさん
垢版 |
2023/04/26(水) 21:43:32.25ID:V27dNYw1
部分列が外から捕捉される場合があって、その場合はメインのリストから取り除かれて以降も長生きして欲しくて、それでRcRefCell使ってるという事情があるんだがなあ
そもそも目的は高速な反復処理じゃなくて状態の管理だし
>>581とかも勝手に途中のノードまでborrow_mut()して平気な顔してるし

まあそういう可能性を考えられない人は単純な構図にして勝ちを取るのに必死なんですね
ご自分の制作物にその知恵が生きるといいですね
0637デフォルトの名無しさん
垢版 |
2023/04/26(水) 22:13:00.95ID:yGAW9BPT
前提条件や用途を限定せずに性能議論しても無駄ではある
超長い配列に挿入したり探索したりが同時に発生する場合や
挿入順序維持して末尾に追加したいだけの場合はlinkedlist
0640デフォルトの名無しさん
垢版 |
2023/04/26(水) 22:36:48.98ID:Pd8SmuYa
>>637
> 挿入順序維持して末尾に追加したいだけの場合はlinkedlist
https://ideone.com/6plvA3
172 ←ベクタ(push_back(foo(i)))
107 ←リスト(push_back(foo(i)))
74 ←ベクタ(reserve(n), push_back(foo(i)))
64 ←ベクタ(reserve(n), emplace_back(i))
105 ←リスト(emplace_back(i))

こんな実測チマチマしてっても意味ないのは同意なのでもう寝ます
性能は状況状況に応じて各自が把握してたら十分と思います
0642デフォルトの名無しさん
垢版 |
2023/04/26(水) 22:46:15.95ID:X2gXmZqE
のんびりまったりやれよ
Rust勢はめんどくさい、とか言われたいかw

C++は、テスト通りゃいいんだよまであるぜ
いろいろと自由だからね はよunsafe来いw
0643デフォルトの名無しさん
垢版 |
2023/04/26(水) 22:55:15.76ID:42HUUVU4
>>636
あなたは間違ってるとか嘘とか言うだけで反論として正しいコードや正しい説明を出せたことがありません
そんなことをしていてはまわりから信頼を失いますよ
0644デフォルトの名無しさん
垢版 |
2023/04/26(水) 23:11:23.22ID:CmiQ78rr
順序維持の追加だけだと>>640のようにベクタもリストもイーブン
しかし追加するだけで終わるわけはなくそれを使うことになる
そうなると結局ベクタが有利

特定の使い方で両端から取り出して使うだけならリストが有利でないか?との疑問はあるだろう
しかしその場合もリストではなく両端キュー(double-ended queue)つまりC++ではstd::dequeueを使う
その内部実装は配列やベクタを利用となっている
0645デフォルトの名無しさん
垢版 |
2023/04/26(水) 23:17:21.42ID:4J8YauGV
>>643
誰と勘違いしてるのか知らないけど俺は一度も嘘とか言ってないよ

コード見ればわかるけどlist使ってるほうは条件にあった場所で挿入しなくて
また無駄に頭から挿入位置までiterしてるように見えるでしょ?

おじいさんはコードも読めない
0646デフォルトの名無しさん
垢版 |
2023/04/26(水) 23:39:33.42ID:D3UubLOX
>>633
borrowもborrow_mutもコストは同じだが二度のコストは避けたほうがいいんじゃないか
RefCellはスレッド内部専用だから並行して他のコードがborrowを試みるとこもないしあってはいけない
だからそこはborrow_mutのみで済ませてよい
0649デフォルトの名無しさん
垢版 |
2023/04/27(木) 00:16:45.43ID:Z1hUQzPQ
他人のことは初心者呼ばわりしておいて自分の見落としも初心者レベルじゃん
誰とは言わんがさすが
0650デフォルトの名無しさん
垢版 |
2023/04/27(木) 00:29:02.36ID:wpK/WV9k
>>647
Refはロックガードにすぎない
ブロックスコープを抜ければ自動解放
掴んだままになることはない
0651デフォルトの名無しさん
垢版 |
2023/04/27(木) 05:33:00.85ID:bgaQiY7u
>>647
関数から返すようなことさえしなければ、関数呼び出しが終わるとつかみ続けることはできず、解除される
RAIIを勉強しなさい
0653デフォルトの名無しさん
垢版 |
2023/04/27(木) 08:53:10.05ID:T3ZJ5rQy
>>640
(cacheにヒットするかとは別に)cold memoryと言う状態があってbenchmarkの場合は気を付けてください

一応今回のコードでは影響はないと思われます
https://ideone.com/lP1xkO
vector::push_back: 192
256
list::push_back: 113
vector::push_back: 194
reserve, vector::push_back: 81
reserve, vector::emplace_back: 63
list::emplace_back: 111
0654デフォルトの名無しさん
垢版 |
2023/04/27(木) 10:17:01.26ID:Xs1mJ/iz
>>653
手元でやったらvectorの完勝だった(clang-O3)
それとRamMapのあと何回か試すとcold memory?の影響も出たする

list::emplace_back: 101
vector::push_back: 74
256
list::push_back: 102
vector::push_back: 57
reserve, vector::push_back: 15
reserve, vector::emplace_back: 15
list::emplace_back: 97
0655デフォルトの名無しさん
垢版 |
2023/04/27(木) 11:18:48.87ID:EX56AJz0
int value, a[(256 / 4) - 1];
この配列aはcopyもmoveもないので計測には意味がないのでは?
0656デフォルトの名無しさん
垢版 |
2023/04/27(木) 11:58:43.55ID:JAvmRZYl
ランダムアクセスの性能が重要な状況で
頭からリニアにアクセスする時点で終わってる
0657デフォルトの名無しさん
垢版 |
2023/04/27(木) 11:59:27.22ID:JkW3E/QM
敢えてdefaultを明示しても特段の変化ないけど、違う話?
foo& operator= ( const foo & ) = default;
foo ( foo&& other) noexcept{
*this = other;
}
0658デフォルトの名無しさん
垢版 |
2023/04/27(木) 12:18:28.50ID:EX56AJz0
vectorはcapacityが不十分なときにfooのcopy(move)を呼ぶ
fooのデフォルトのcopyもmoveも
aの要素をcopyもmoveもしないので
fooのメンバーにaがある意味がない
0661デフォルトの名無しさん
垢版 |
2023/04/27(木) 13:51:50.04ID:5Zgd55kl
>>543
>>545
コンパイルしてみないとどれだけ容量食うか判らないのは可笑しいな
コンパイル前に今のcrates全部で3GB食うからそれ以上空けてないと
コンパイル開始しないで警告するようなオプション無いかな
0662デフォルトの名無しさん
垢版 |
2023/04/27(木) 14:41:22.34ID:e+kUEWUi
ポインタをちゃんと理解出来て無い人が、誤った使い方でLinkedListの性能
が悪いと思い込んでいるに一票。
0663デフォルトの名無しさん
垢版 |
2023/04/27(木) 15:20:28.37ID:W3Pq65Tl
その件は、リニアでもランダムでも個別要素に総なめアクセスするだけの問題→vector+reserveサイズで悩むだけだな

それ以外の状況は千差万別だけど、データ構造を再発明してもしょうがない、知識をつけないとね
>>599みたいな状況→LRUCache→>>592のLinkedHashMap(listと配列のハイブリッド)みたいに
0664デフォルトの名無しさん
垢版 |
2023/04/27(木) 16:24:47.29ID:usIJ504X
>個別要素に総なめアクセスするだけの問題
なら、Arena方式がOKの場合としてstd::pmr::monotonic_buffer_resourceを使ってみた

vector::push_back: 53
256
vector::push_back: 52
reserve, vector::push_back: 15
reserve, vector::emplace_back: 15
list::push_back: 96
list::emplace_back: 94
list<foo,Arena>::push_back: 22
list<foo,Arena>::emplace_back: 22
0665デフォルトの名無しさん
垢版 |
2023/04/27(木) 18:52:14.07ID:1NmRe5Ss
>vector+reserveサイズで悩む
見積を間違うとかえって遅くなるんだ(なんで?)
list+Arenaは使いどころがあるかもね

vector::push_back: 58
reserve, vector::push_back: 17 *
reserve, vector::emplace_back: 15 *
80% reserve, vector::push_back: 43 x
80% reserve, vector::emplace_back: 44 x
50% reserve, vector::push_back: 32
50% reserve, vector::emplace_back: 34
20% reserve, vector::push_back: 66 xx
20% reserve, vector::emplace_back: 66 xx
vector<foo,Arena>::push_back: 58
vector<foo,Arena>::emplace_back: 60
list::push_back: 94
list::emplace_back: 95
list<foo,Arena>::push_back: 22 *
list<foo,Arena>::emplace_back: 22 *
0666デフォルトの名無しさん
垢版 |
2023/04/27(木) 19:26:23.25ID:6exOPbwx
個人的には思ってたより面白い展開だけど
Rustで手を動かして晒す人が出てくるまで
C++側は控えても良いんじゃないかな?

でないと>>604みたいなのが増えるだけや
0667デフォルトの名無しさん
垢版 |
2023/04/27(木) 19:41:41.02ID:2LPN0u11
>>662
逆やろw
ポインタも知らず実測したこともない子が
listに対して過剰に期待寄せてるだけで
実際C++書いてるやつならもっと冷静よ
0669デフォルトの名無しさん
垢版 |
2023/04/27(木) 22:18:15.37ID:OEMrsx3I
データ追加の計測をしてるようだけど
実際にはその後にそれらデータを使うため
listは各ポインタをたどるところで不利になってしまう

vectorはreserve無しだと再配置コストがかかるけど
最大個数Mのときに再配置コスト累計はM~2Mで固定
使えば使うほど誤差になっていくので
パフォーマンスを気になるような使い方なら無視してよいかと
0670デフォルトの名無しさん
垢版 |
2023/04/28(金) 00:29:13.98ID:Oq9JkTqn
ここの人達が馬鹿なのは、LinkedListだけ本来の使い方が出来てないこと。
ポインタの使い方が根本的に理解できてないことが分かる。
0671デフォルトの名無しさん
垢版 |
2023/04/28(金) 00:39:40.76ID:Oq9JkTqn
vectorは、要素のラベルとしてindexを使うが、indexは初心者でも理解し易い。
ところが、LinkedListは、要素のラベルとしてポインタを使う。
ポインタを理解できない人は、いつまでもindexを使おうとする。
それでLinkedListの本来の性能が出ないので、LinkedListはvectorより遅い
と思い込むが、実際はその人の使い方が未熟だからに過ぎない。
多くはキャッシュのせいではなく、その人がまともに使いこなせて無い事が原因。
0672デフォルトの名無しさん
垢版 |
2023/04/28(金) 00:45:03.56ID:Oq9JkTqn
どうして馬鹿な人に限って「キャッシュのせいで」というかといえば、
キャッシュは、ケースバイケースなので、優秀な人でも断定的に語ることが
できないから、馬鹿な人でも優秀な人と似たような状況になって、能力の差異を
ごまかすことが出来そうに思えてしまうから。
キャッシュは、事を行なう順序によって、本当に千差万別の状況が生まれるし、
CPUの世代によっても変わってきてしまうから、語るのが難しいものであるが、
それ故に、理解力が無いから語れない人も、「ごまかすチャンス」を与える
ことが可能となる誤魔化しのユートピアとなる。
0674デフォルトの名無しさん
垢版 |
2023/04/28(金) 01:28:17.16ID:njQSrx5C
>>671
>vectorは、要素のラベルとしてindexを使うが、indexは初心者でも理解し易い。
STLのalgorithmの関数群に渡すときはiteratorのみ
0676デフォルトの名無しさん
垢版 |
2023/04/28(金) 01:34:03.77ID:sELX9IR8
率直に申し上げると
CとRustの相性は割と良いが
C++とRustの相性は良いとは
(特にテンプレ)言い切れない
即ちCからのリプレースに於いて
Rustが最適解に成り得るのに対し
C++はそのままC++で使い続けるが良かろう
0677デフォルトの名無しさん
垢版 |
2023/04/28(金) 01:59:46.36ID:EbgOkl/j
>>672
ケースバイケースじゃないですよ
cache hierarchyとcache localityという常識を学んでください
大昔ならいざ知らず今は大学1年生レベルでみんな習う常識ですよ
0678デフォルトの名無しさん
垢版 |
2023/04/28(金) 02:05:44.40ID:Oq9JkTqn
>>677
キャッシュは、そういう問題じゃなく、前に何をやったかによって、
キャッシュに乗るかどうかが変わってくると言うことが起きることを
「ケースバイケース」と言っている。
だから、LinkedListにおいて、要素を交換するとしても、ソートの様に
ランダムに近い2つが交換した後のソート後の集合を先頭から最後まで巡る場合には
キャッシュミスが多くなるが、必ず隣り合う前後を交換することを2個おきにやった
場合の集合を最初から最後まで巡る場合は、キャッシュミスはほとんど起きない
という事情がある。
だから、LinkedListで要素を交換すると必ず遅い、というような法則は存在
しない。
0679デフォルトの名無しさん
垢版 |
2023/04/28(金) 05:07:15.20ID:KTdsk5aJ
間違った使い方をしていると主張するならば
他の人たちのように実際にコードを示して
そして比較計測することで実証しよう
0680デフォルトの名無しさん
垢版 |
2023/04/28(金) 07:29:21.75ID:tvIf37hb
>>678
>キャッシュは、そういう問題じゃなく、前に何をやったかによって、
>キャッシュに乗るかどうかが変わってくると言うことが起きることを
>「ケースバイケース」と言っている。
君がそう思って書いてるのはわかってるよ
それが的外れだから勉強したほうがいいよと言ってるんだよ

> 必ず隣り合う前後を交換することを2個おきにやった場合の集合を最初から最後まで巡る場合
この処理がvectorより速くなるとでも?
遅い速いは相対的なものなんだから何と比べてるかくらいはわかるでしょ?
0681デフォルトの名無しさん
垢版 |
2023/04/28(金) 08:50:10.99ID:gH8UoCJq
Rustはグラフ的な構造が作れないから
単純な構造しか扱わないシステムプログラミングにはC++より
優れてると思う
0683デフォルトの名無しさん
垢版 |
2023/04/28(金) 09:39:41.22ID:ypH1tIw5
>>681
そのへんはどの言語も同じ
作れないとか優劣とかない
言語よりアルゴリズムの差が大きい
0684デフォルトの名無しさん
垢版 |
2023/04/28(金) 10:57:08.12ID:pksuSfee
Rustは、要素のラベルとしてindexを使うが、indexは初心者でも理解し易い。
ところが、C++は、要素のラベルとしてpointerを使う。
pointerを理解できない人は、いつまでもindexを使おうとする。
それでC++の本来の性能が出ないので、C++はRustよりunsafe
と思い込むが、実際はその人の使い方が未熟だからに過ぎない。
多くはC++のせいではなく、その人がまともに使いこなせて無い事が原因。
0686デフォルトの名無しさん
垢版 |
2023/04/28(金) 12:39:05.67ID:35xT11dO
>>671
vectorの使い方すら知らないのかよ
プログラムを書いたことがないんだな
次の要素や前の要素を指すにはindexを増減させるのではなく
イテレータを使いポインタでアクセスだ
次の要素を指すには++で要素の大きさ分が加算されるだけなので速い
0687デフォルトの名無しさん
垢版 |
2023/04/28(金) 12:52:16.57ID:35xT11dO
>>678
linked listのワーストケースはその通りキャッシュが効かず順にたどるのも遅くなる
そこまでわかっているならvectorが速いことも理解できるだろ
0688デフォルトの名無しさん
垢版 |
2023/04/28(金) 12:54:59.10ID:l8aVe0s/
>680
>> 必ず隣り合う前後を交換することを2個おきにやった場合の集合を最初から最後まで巡る場合
>この処理がvectorより速くなるとでも?
>遅い速いは相対的なものなんだから何と比べてるかくらいはわかるでしょ?
>686
>イテレータを使いポインタでアクセスだ

コードを晒すのはやめるけど、カスタムリストのポインタ操作で実装したらリストの方が速かった
sizeof(foo)= 256 back swap
std::vector, swap(xs[i],xs[i+1]) 55 15
std::vector, swap(*it1,*it2) 54 15
std::list, swap(*it1,*it2) 22 15
LinkList, modify prev/next 22 4
0689デフォルトの名無しさん
垢版 |
2023/04/28(金) 13:04:21.51ID:l8aVe0s/
backは末尾追加(push_backでもemplace_backでも同じ)
swapは>>678が言っている「必ず隣り合う前後を交換することを2個おきにやった場合の集合を最初から最後まで巡る場合」

試してみたら言っている通りだったけど、256バイトなのが効いている結果だと思う
それとstd::listはポインタ操作をやらせてくれなのかな?
0690デフォルトの名無しさん
垢版 |
2023/04/28(金) 13:12:38.01ID:lHXn1lC8
デカいものはそのようなそれ自体を動かすことはしない
例えばソートする場合でもポインタもしくはインデックスだけをソートする
0694デフォルトの名無しさん
垢版 |
2023/04/28(金) 17:25:35.41ID:0xBJDLDh
ポインタのインスタンス、だろ。リリースビルドではポインタだけになってるかもしれないけど。
0695デフォルトの名無しさん
垢版 |
2023/04/28(金) 18:50:51.20ID:rYsqY01x
そのvectorに格納している要素が大きな実体なのかそこへのポインタ(アドレス)なのかを理解していないとまずいぜ
要素がポインタを含めて小さい実体ならばvectorの要素の入れ替え・挿入・削除は非常に速い
0697デフォルトの名無しさん
垢版 |
2023/04/28(金) 19:07:38.08ID:aOCxNlg7
scanは先頭からvalue(int 4Byte)にアクセスしてダミーXOR演算する処理
dual link listのポインタ操作版(LinkList)はswapした後のscanが256Byteで激落ちだった xx
ForwardLinkListはforward linkかつallocate時のnextを別途キープし続けるデータ構造

sizeof(foo)= 256 n=1000000 back -> scan -> swap -> scan = total
std::vector,swap(*it1,*it2) 52.986 3.461 14.739 3.458 74.644
std::list, swap(*it1,*it2) 22.574 6.470 16.252 6.375 51.672
LinkList, modify prev/next 21.940 6.509 4.229 39.717 72.395 xx
ForwardLinkList, modify next 22.824 6.532 4.395 5.861 39.611 *

sizeof(foo)= 128 n=2000000 back -> scan -> swap -> scan = total
std::vector,swap(*it1,*it2) 60.411 6.789 14.340 7.144 88.683
std::list, swap(*it1,*it2) 28.981 13.839 16.871 14.124 73.815
LinkList, modify prev/next 27.969 13.845 10.074 16.062 67.951 *
ForwardLinkList, modify next 28.204 13.980 9.802 13.791 65.778 *

sizeof(foo)= 64 n=4000000 back -> scan -> swap -> scan = total
std::vector,swap(*it1,*it2) 62.683 7.733 14.140 7.768 92.325
std::list, swap(*it1,*it2) 35.496 14.177 18.950 14.136 82.759 *
LinkList, modify prev/next 32.240 14.129 19.082 14.404 79.856 *
ForwardLinkList, modify next 33.547 14.197 19.169 13.922 80.835 *

sizeof(foo)= 32 n=8000000 back -> scan -> swap -> scan = total
std::vector,swap(*it1,*it2) 61.452 8.084 14.104 8.230 91.870 *
std::list, swap(*it1,*it2) 51.176 17.195 22.936 17.336 108.643
LinkList, modify prev/next 47.231 17.226 23.422 17.519 105.398
ForwardLinkList, modify next 48.123 17.387 23.529 17.408 106.447
0698デフォルトの名無しさん
垢版 |
2023/04/28(金) 19:11:25.99ID:aOCxNlg7
C++側としては面白がって人の作ったベースを弄り始めたんだけれど、
sortしたり途中挿入削除しないリニアアクセスだけの問題ならどっちでも良いなw

ただし要素が小さくて途中挿入削除しないのならvector

sizeof(foo)= 16 n=16000000 back -> scan -> swap -> scan = total
std::vector,swap(*it1,*it2) 61.891 9.511 13.994 9.677 95.074 **
std::list, swap(*it1,*it2) 90.948 22.966 34.215 23.463 171.592
LinkList, modify prev/next 76.692 22.989 32.457 23.262 155.400
ForwardLinkList, modify next 76.857 23.095 31.426 23.639 155.018

sizeof(foo)= 8 n=32000000 back -> scan -> swap -> scan = total
std::vector,swap(*it1,*it2) 63.911 9.002 14.222 8.933 96.068 ***
std::list, swap(*it1,*it2) 171.875 52.681 71.011 43.465 339.032
LinkList, modify prev/next 142.104 39.655 52.617 40.589 274.964
ForwardLinkList, modify next 141.527 39.843 49.236 39.779 270.385

>>696に同意です
0700デフォルトの名無しさん
垢版 |
2023/04/28(金) 20:00:39.11ID:EmUQPNaW
>>694
メンバにサイズデカいのがあったら
moveコン呼ばれても結局コピーが発生するね
訂正訂正!
0701デフォルトの名無しさん
垢版 |
2023/04/28(金) 20:16:09.12ID:Du1IZbO4
moveがコピーをしないという意味のコピーと
今話題になっている入れ替えたりズラしたりする時にコストとなるコピーは別物だろ

moveでもコピーコストは発生する
それがポインタならばそのコピーコストが最小限になるというだけだ
0702デフォルトの名無しさん
垢版 |
2023/04/28(金) 22:34:19.60ID:/wnDoHyX
>>684
RustもC++と同じだよ
例えばvec.iter()はvecの各要素への参照(ポインタ)列を返すイテレータ
例えば要素のkey1をキーとしてソートするなら
vec.iter().sorted_by_key(|x| x.key1)
これもvecの各要素への参照(ポインタ)列をソート順に返すイテレータ
いずれも各要素自体のコピーは発生しない
0705デフォルトの名無しさん
垢版 |
2023/04/29(土) 01:18:03.83ID:yAVCYP8x
そうじゃなくて頭から最後まで要素を一回走査して挿入削除する場合は一回当たりのコスとはvectorより有利
何度も何度も繰り返し頭から走査する条件下では不利
ここでのベンチ結果は後ろのパターンばかりで不利になるのは当然

コード書いてる人が意図的に間違えてるのかセンスがないかのどちらか
アルゴリズムの意味が理解できてないと言う話
0706デフォルトの名無しさん
垢版 |
2023/04/29(土) 01:21:50.87ID:yAVCYP8x
コードを書く人間として常識的に考えればわかる
挿入時に一部だけ鎖つなぎなおすのが低コストか
毎回全部後ろまでずらすのが低コストか

削除時に一部だけ鎖つなぎなおすのが低コストか
毎回全部後ろの要素を前へずらすのが低コストか
0708デフォルトの名無しさん
垢版 |
2023/04/29(土) 01:52:27.12ID:QawJMl68
実際に色んな仕事をしたことある人たちがvector派という感じ
現実は挿入することが目的ではなくその後に使うところが本場でvectorが有利
稀に比較挿入が主たる場合もあるけど効率の悪いlinked listではなくbinary treeなどを使う
0710デフォルトの名無しさん
垢版 |
2023/04/29(土) 06:10:16.91ID:g1O4sC7f
>>705
> 頭から最後まで要素を一回走査して挿入削除する場合は一回当たりのコスとはvectorより有利

そのような走査して挿入する利用で最も多いのが何かの順序に並べるケース
その場合は結果的にソートをしていることになるがオーダーO(n^2)となり効率が悪い

効率が良い方法はvectorを利用してまずは順序関係なく要素を追加してしまい
その格納された各要素へのポインタを対象に一気にO(n·log(n))の速いソートするとよい
ソートを必要とする多くのデータ処理はそのようにvectorを利用する形になる
0711デフォルトの名無しさん
垢版 |
2023/04/29(土) 06:57:32.23ID:DIPSnmX9
なんでソート済みのなかに挿入するのにまたソートするの?
頭悪そう。
0712デフォルトの名無しさん
垢版 |
2023/04/29(土) 06:58:38.69ID:x0nehzJt
だってほら、ソート済みのオブジェクトをひっかきまわす別スレッドがあったり?w (ひっかきまわし
0713デフォルトの名無しさん
垢版 |
2023/04/29(土) 07:43:01.19ID:7W8CIlYn
Linked Listをソートに使うのはアホ
計算量オーダーを知らないアホ
既に順に並んでるところへ挿入していくから速そうだと勘違いするアホ発見器
0714デフォルトの名無しさん
垢版 |
2023/04/29(土) 08:07:10.82ID:qQ47Kbbt
>>703
節約できてねーよw
0715デフォルトの名無しさん
垢版 |
2023/04/29(土) 08:11:13.42ID:zSimqKUs
>>706
そこはみんなわかってるよ
挿入時や削除時に挿入位置と削除位置を見つけるために
LinkedListの走査が必要な使い方をしたら
性能的にはLinkedListを使う価値がなくなるという話をみんなしてるんだよ
0718デフォルトの名無しさん
垢版 |
2023/04/29(土) 10:31:22.19ID:7o70JIXk
自分の無知を知らずシッタカするド素人と
自分の無知を察して慎重にシッタカするド素人
自分の無知を察して口をつぐむ慎ましいド素人

三番目なのがRustユーザ
0719デフォルトの名無しさん
垢版 |
2023/04/29(土) 11:02:19.50ID:YiZx6les
QiitaなんかでRustポエムがいいね入れ食いなのから察するに
Rustユーザは>>563みたいな数独パズル状態でどん詰まり傾向かな?
0720デフォルトの名無しさん
垢版 |
2023/04/29(土) 11:12:39.77ID:ohv1w+T9
結局、ここに溜まるような奴はみんな、やれといわれたら(どっちもちゃんと)やる人間だろうしね

でも好きずきはある やっぱ俺はC++が好き
0721デフォルトの名無しさん
垢版 |
2023/04/29(土) 11:22:17.96ID:dmw04PPX
いやmoveを分かってないレベルのRustユーザがいる
おそらくQiitaでRustポエムをいいねしてる?

一方、C++ユーザは実動コードやらベンチ結果を晒して議論するのを面白がってる様子
どっちも無知でも、どっちが成長するのか目に見えてるなw
0723デフォルトの名無しさん
垢版 |
2023/04/29(土) 11:36:22.20ID:7o70JIXk
言語としてはある種似てるとは思うわ
言語仕様としてではなくてね
HaskellとC++とRustはいっしょのカテゴリに入ってる
シッタカしたいタイプのド素人がドヤるための言語
JavaとかPHPをドカタ言語といって蔑むのといっしょ
女さんが自分を飾るブランドを選ぶのといっしょ
0724デフォルトの名無しさん
垢版 |
2023/04/29(土) 11:42:46.52ID:yAVCYP8x
>>710
違うよ
何かを順番に並べるケースは実際はランダムアクセスなんだよ
そんな簡単なこともわからないの?
0726デフォルトの名無しさん
垢版 |
2023/04/29(土) 11:52:16.10ID:yAVCYP8x
>>710
> そのような走査して挿入する利用で最も多いのが何かの順序に並べるケース

頭から走査する回数が増えるとlinkedlistが極端に不利になるって常識的に分かるよね
そういう条件でソートをlinkedlistでやるやつは馬鹿だろ
それなのに何で頭から操作繰り返すアルゴリズムを選ぶのか?
意味分かってないのか?
0727デフォルトの名無しさん
垢版 |
2023/04/29(土) 11:59:53.23ID:yAVCYP8x
>>725
結果見れば分かるだろ

結果から見るとlinkedlistで単体の件で条件マッチするまでソートはランダムソートのコスト+比較だから

a[x] で仮に条件が合うのがkだとしてそこまでは実際ランダムアクセスでそこまで行ってるのと変わらない
数学の素養がないのは君なんだけど…

多分これを書いても理解できてないよね…
0731デフォルトの名無しさん
垢版 |
2023/04/29(土) 12:03:17.50ID:yAVCYP8x
ランダムアクセスが苦手なのに挿入のたびに実質ランダムアクセスさせられてる
それに気が付いてない人の多いこと

全件を一度走査するのと実質ちまちまランダムアクセスを繰り返す挿入ソートの違いが理解できない馬鹿頭

数学が出来ない人間と話をしても無駄なんだよな…
馬鹿は水掛け論だと誤解してるから…
0736デフォルトの名無しさん
垢版 |
2023/04/29(土) 12:11:44.15ID:MIzfr5va
ようやく理解できた
局所的に見るとlistが速い部分もあるんだけど
作業全体で比較するとvectorが速くなるってことか
0737デフォルトの名無しさん
垢版 |
2023/04/29(土) 12:13:24.42ID:yAVCYP8x
変な話だけど多分この議論の勝者は俺なんじゃないかな
数学的素養のない人間に衝撃を与えてる
0741デフォルトの名無しさん
垢版 |
2023/04/29(土) 12:25:50.80ID:OSQfAzE+
ちょっと再帰型の例として単方向連結リストが出ただけでここまで話を脱線させることができる集団
0742デフォルトの名無しさん
垢版 |
2023/04/29(土) 12:35:51.92ID:L+mlGJh3
>>735
他の人たちの説明はほぼわかったけど
きみの説明だけわからんかった
具体的なコードを出してみたらどう?
0744デフォルトの名無しさん
垢版 |
2023/04/29(土) 13:08:56.23ID:cwi8dy59
>話を脱線させることができる集団

やっぱり、LinkedListの無理問答は脱線の仕掛けだったんだ
0745デフォルトの名無しさん
垢版 |
2023/04/29(土) 13:33:17.72ID:Tjp8jVNl
論理的思考というワードを見るとなぜかテンションが上がる
所有権複製と同じぐらい

プログラムが論理的かどうかを判断するだけなら思考を研究しなくていい
最近のAI界隈が脳科学の研究をしないのと同じ
0747デフォルトの名無しさん
垢版 |
2023/04/29(土) 14:41:05.09ID:20ghSNY5
>>745
>プログラムが論理的かどうか
論理もへったくれもないこと言ってんな
どんなにトチ狂った論理でも論理は論理だし
プログラムには論理以外何も無い
何が言いたいんだこいつは
0749デフォルトの名無しさん
垢版 |
2023/04/29(土) 16:48:28.13ID:ohv1w+T9
本質的に雑スレなので、C++ vs Rust みたいな話題が好きそうな人が好きそうな話題ならなんでもいいや
0751デフォルトの名無しさん
垢版 |
2023/04/29(土) 17:04:51.89ID:LRGNcJXi
正直リンクドリストなんて一生使わないので興味ないのは図星
0752デフォルトの名無しさん
垢版 |
2023/04/29(土) 19:05:39.22ID:805CSB5r
>>739
そのコムソートのためにnとmの2つのポインタを持って、
双方向リストでmとnの入れ替えをしようとしたら、
ノードの入れ替えだけでとんでもないコストになった。
読み出しが4回と書き込みが8回もかかる

# mの前後がnを指すようにする
読 m_prev = m->prev
書 m_prev->next = n
読 m_next = n->next
書 m_next->prev = n

# nの前後がmを指すようにする
読 n_prev = n->prev
書 n_prev-> next = m
読 n_next = n->next
書 n_next->prev = m

# mがnの前後を指すようにする
書 m->prev = n_prev
書 m->next = n_next

# nがmの前後を指すようにする
書 n->prev = m_prev
書 n->next = m_next

リストのノードの入れ替えがこれだけ高コストだと、
ノードを入れ替えずに格納している要素の入れ替えをしたほうがよくて、
要素のサイズが大きければポインタのみ収容したほうがよくて、
ベクタが有利になるポインタのみ収容に行き着いてしまう?
0753デフォルトの名無しさん
垢版 |
2023/04/29(土) 19:15:52.32ID:XcHaQTov
>>752
ベクタの値の交換とどっちが高コストかはその値のサイズによるでしょ。
値の交換はリンクトリストでもできるわけだからコストの低い方を選べばいい。
0754デフォルトの名無しさん
垢版 |
2023/04/29(土) 19:31:19.50ID:s2+5kMs9
ベクタでソートする時は要素を動かす必要はなく各要素を指すポインタをソートする
リストでも同じ方法が可能だがリンクを毎回たどる分だけ不利
領域分割のクイックソートなどもリストでは使えない
0755デフォルトの名無しさん
垢版 |
2023/04/29(土) 19:41:23.91ID:IKRrkEkG
なんでソートする必要のあるデータを連結リストにぶち込もうと思ったんですか?
0756デフォルトの名無しさん
垢版 |
2023/04/29(土) 20:12:09.35ID:XcHaQTov
>>754
リンクを毎回たどるって何のことを言ってんの?>>739のように現在指している要素の隣の要素を参照するだけだよ。

>領域分割のクイックソートなどもリストでは使えない

クイックソートもインデックスでランダムアクセスが必須じゃないからリンクトリストでもいけるみたい。
最初のピボット選択に不利なくらいで。
0760デフォルトの名無しさん
垢版 |
2023/04/29(土) 21:28:35.35ID:OSQfAzE+
最悪計算量がO(1)の両端キューがどうしても欲しい場合にでも使えばいいんじゃないでしょうか
0761デフォルトの名無しさん
垢版 |
2023/04/29(土) 21:36:10.77ID:ohv1w+T9
まあ、linked list でいっかあ、ってとき。簡単なのはメリット。
おいおい、ちゃんとしたコンテナに替えてもよし。
0762デフォルトの名無しさん
垢版 |
2023/04/29(土) 21:52:36.29ID:8bsno8eR
両端キュー(deque)はリストではなくベクタ系による実装の方が好まれて使われる
std::dequeue、JavaのArrayDequeue、RustのVecDequeなど
0763デフォルトの名無しさん
垢版 |
2023/04/29(土) 22:13:48.24ID:fyMAdwwx
chatgptにlinked listがいい例を挙げてもらった
テキストエディタ、ジョブスケジューラ、メモリ管理、ハッシュテーブル
0764デフォルトの名無しさん
垢版 |
2023/04/29(土) 22:15:45.27ID:2xE5oJ1V
>>756
>リンクを毎回たどるって何のことを言ってんの?>>739のように現在指している要素の隣の要素を参照するだけだよ。
LinkedListでリンクをたどらずどうやって隣の要素を参照するのか教えてくれるかな?
0765デフォルトの名無しさん
垢版 |
2023/04/29(土) 22:23:38.61ID:XcHaQTov
>>755
ベクタ/リストをソートするのに計算量的な差は特にない。
ソート済みのものに要素を挿入するのは一長一短あるが一般にはリストが有利な場合が多いな。
挿入自体のパフォーマンスに特化するなら場合はヒープのような木構造を使うのがベストだろうが。
0767デフォルトの名無しさん
垢版 |
2023/04/29(土) 22:26:27.79ID:RlwUT4Ts
>>763
ハッシュテーブルでもリンクリストを使うチェーン法はリンクをたどるコストが無駄なので避けられる
現実的に効率の良いオープンアドレス法が好まれておりベクターが使われている
0768デフォルトの名無しさん
垢版 |
2023/04/29(土) 22:39:43.93ID:7o70JIXk
なんか偶然ソートの話になってるけど
流れを読んでからこれ書いたんじゃなくて
「ところでインサーションソートなんてベクタじゃ苦しいだろうけど
リストならすごく効率がいいんではないか? を確かめようとしたら
list::sortがおそらくすでに十分に効率的に書かれてることが分かって
インサーションソートを自分で実装する気が萎えた
(いちおう拾ったコードは乗せてあるけどクッソ遅い)」という別の話

https://ideone.com/D9ljA7
function asc desc shuf
std::sort(v) 16 13 72
list::sort 43 60 332 ←十分早い
std::qsort(v) 47 45 144 ←参考
0769デフォルトの名無しさん
垢版 |
2023/04/29(土) 22:50:51.62ID:hqB48CC6
>>766
リンクをたどらず隣の要素を参照することはできないのね
チューリング賞ものの新アルゴリズムでもあるのかと思って期待しちゃったよ
数学的に
0773デフォルトの名無しさん
垢版 |
2023/04/30(日) 00:02:56.42ID:0nNhKOfm
Microsoft's adoration of Rust does have limits.
"Rewriting Windows in Rust probably isn't going to happen anytime soon," said Weston,
"so while we love Rust, we need a strategy that also includes securing more of our native code."
0775デフォルトの名無しさん
垢版 |
2023/04/30(日) 01:22:44.98ID:bU1qZ3nv
>>769
LinkedListにおいて、キャッシュに載っていれば隣の要素は、1クロックで
辿れるから何の問題もない。アセンブリコードは、
mov rbx,[rbx + pNext]
みたいになり、キャッシュに載っていれば1クロック。
多くの場合、キャッシュに載っていることが多い。
乗っていない場合は、prefetch 命令で載せることができる。
0776デフォルトの名無しさん
垢版 |
2023/04/30(日) 01:28:36.62ID:bU1qZ3nv
Stroustrup氏は、キャッシュミス時のハードウェアによる自動 prefetch が
数百クロックかかると書いていたが、それは過去の話で、
現在の DDR4-SDRAM だと、15クロックだと聞いた。
だから、キャッシュに載ってなくても15クロックのペナルティーで済む。
また、pNext を読む前に prefetch 命令で pNext の部分をキャッシュに読み込ます
ようにしておけば、ペナルティーは 1 クロック以下に近くなる。
「以下」と書いたのは、いまの CPU は複数命令の同時命令実行機能が有るので
prefetch命令自体は0クロックで実行できることがあるから。
0777デフォルトの名無しさん
垢版 |
2023/04/30(日) 01:38:31.10ID:RN/WMs5a
ほんと頭悪すぎだろ
数学的に
0778デフォルトの名無しさん
垢版 |
2023/04/30(日) 01:38:51.52ID:bU1qZ3nv
なお、LinkedListでも多くの場合は、次のノードは、アドレスがほぼ隣接しているので
キャッシュに載っている確率が高い。ほぼ連続的なアドレスを次々に辿っていくので
ほとんどの場合、LinkedListのノードは読み込み時にキャッシュに載り続けている。
10万個の要素があった時、その内、2つの要素を10回交換したとしても、
キャッシュの乱れは、40回程度。10万要素の内の40回程度、キャッシュ
ナルティーが生じるだけ。
それぞれが15クロックほど遅くなるだけだから、10万個の要素を辿っても、
全体として、600クロックほど、キャッシュ読み込みの時間が追加されるだけ
のはず。ただし、キャッシュミス時の自動prefetchの時間が15クロック
かどうかは不明。
なお、ソフトウェア的にprefetch命令をマシン語で書いておけば、他の命令を
実行中にprefetch動作が入るので、キャッシュペナルティーを実質0クロック
にできる。
0780デフォルトの名無しさん
垢版 |
2023/04/30(日) 01:44:17.33ID:bU1qZ3nv
ここの人は何か勘違いしてるようだが、LinkedListで隣のノードに辿るのは、
C で書くと
pNode = pNode->pNext;
という1行で書けるが、アセンブリだと、
mov rbx,[rbx + (pNextのオフセットアドレス)]
という 1命令になって、1クロックに過ぎない。
一方、配列の場合の、++ptr は、
add rbx,(1要素のバイト数)
という1命令で書けて、これも1クロック。

なので、キャッシュミスがない限り、LinkedListも配列と同じ速度で
ノードを辿っていける。
0781デフォルトの名無しさん
垢版 |
2023/04/30(日) 01:48:48.78ID:bU1qZ3nv
>>754
QuickSortは、LinkedListではとても不利。
ただし、QuickSortと同じ速度のソートを俺は発見している。
なお、俺は数学的な天才だから、あなた達には無理なんだろう。
0782デフォルトの名無しさん
垢版 |
2023/04/30(日) 01:49:24.07ID:HMPc/FQf
1クロックw
数学的だねェ
0784デフォルトの名無しさん
垢版 |
2023/04/30(日) 01:58:54.26ID:p1baMidH
LinkedList指向アーキテクチャを使ってるんだろ
0785デフォルトの名無しさん
垢版 |
2023/04/30(日) 01:59:20.86ID:bU1qZ3nv
>>778
>キャッシュの乱れは、40回程度。10万要素の内の40回程度、キャッシュ
>ナルティーが生じるだけ。
>それぞれが15クロックほど遅くなるだけだから、10万個の要素を辿っても、
>全体として、600クロックほど、キャッシュ読み込みの時間が追加されるだけ
>のはず。
訂正します。
実際には、AAAABAAACAAADAAA・・・
のようになるので、「行き」はキャッシュミスが生じますが、「帰り」は
キャッシュに載っているものを再度使うだけなので、キャッシュの乱れは
20回程度となり、キャッシュロードに掛かる追加時間は、全体で300クロックで
済むと考えられます。
0787デフォルトの名無しさん
垢版 |
2023/04/30(日) 05:06:03.85ID:hShyWiBx
>>786
高速なソートアルゴリズムを新たに発見するとは
天才すぎる
これでLinkedListの逆転勝ちかあ

>>780
1クロックで読み込みできるとは
ハードウェアでも天才すぎる
LinkedListの時代が到来だあ
0789デフォルトの名無しさん
垢版 |
2023/04/30(日) 07:28:55.12ID:8jzds4J3
AIにコードを書いてもらえないかってのが研究されだして久しいけど、
Rustは(書いてもらうのに)向いてるかもね

Rustは人の仕事を奪うかもよ?w
0791デフォルトの名無しさん
垢版 |
2023/04/30(日) 09:46:01.58ID:36fy/qId
クリックベイトかな?と思ったら速攻で出ていた

>>772-773
>>788

> Microsoft's adoration of Rust does have limits.
> "Rewriting Windows in Rust probably isn't going to happen anytime soon," said Weston,
> "so while we love Rust, we need a strategy that also includes securing more of our native code."
0792デフォルトの名無しさん
垢版 |
2023/04/30(日) 09:55:02.85ID:T8NwKiLb
隣へたどる方法比較
https://ideone.com/sVvoxX
p++ 28
v ++it 29
v next(it) 30
l next(it) 151

最初の三つに数字の上では差が付いてるが本質的ではない
書いてる最中にここの数字入れ替わったりしてるので誤差
リストは遅いっちゃあ遅いけど致命的に遅いわけでもない
リストにとっては有利なメモリ配置にはなってると思うけど
0793デフォルトの名無しさん
垢版 |
2023/04/30(日) 10:14:47.83ID:YN4uZc/s
中立ぶってリストを擁護する人も、中立やめてリスト推しになるかといえば
ならないだろう
結局、誰も推してないのに誰かが推しているように偽装することを
中立という綺麗事で正当化しているだけだ
0794デフォルトの名無しさん
垢版 |
2023/04/30(日) 10:19:43.94ID:BMHs5g0C
>>792
ideoneはコンパイラバージョンが古いしマシンも古いと思う
ただしWS級だからメモリ帯域は大きそう(オンザフライ数が大きい)
vectorならDT級マシンでもHWプリフェッチがうまくやってくれる

p++ 6
v ++it 6
v next(it) 6
l next(it) 241 <- 致命的に遅い、よね?
0795デフォルトの名無しさん
垢版 |
2023/04/30(日) 10:21:32.29ID:YAk30VeP
>>768
偶然ソートの話になってるんじゃなくて誰かが書いたコードが
linkedlistに不利なソートを取り上げてたから荒れてるだけなんだ
原因はその誰かなんだ

上に書かれてるように挿入ソートは実質ランダムアクセスよりlinkedlistに不利になるんだから
そういうのをテーマに選んだ時点でちょっとセンスがないと思う
0798デフォルトの名無しさん
垢版 |
2023/04/30(日) 10:53:23.23ID:loPobIHT
>>792,794
もう面白くないからやらないけど補足すると、一昨日のlistのscanがイイ感じだったのは
Arena使っているからchunk毎にリニアアクセスだったからなんだ

>>792,794はdefault allocatorで、Cacheから出たらnext(it)ですら遅いよ
0799デフォルトの名無しさん
垢版 |
2023/04/30(日) 10:56:20.23ID:RO3CktaP
bindgenでC/C++のheader変換させると
warning: type `ho_ge` should have an upper camel case name
help: convert the identifier to upper camel case: `HoGe`
みたいな余計な御世話なメッセージが出捲るんだが
これを抑制する方法って無い?
0801デフォルトの名無しさん
垢版 |
2023/04/30(日) 14:46:52.74ID:eJ3rvh+g
.to_string() とか
.to_str() とか
.to_str().expect("やりなおせ") とか
.to_str()? とか
.as_str() とか
一貫性がないな
0802デフォルトの名無しさん
垢版 |
2023/04/30(日) 14:50:03.03ID:xL1w2Uvw
>>799
抑制する方法もエラーメッセージに出てなかったっけ?
0803デフォルトの名無しさん
垢版 |
2023/04/30(日) 16:01:15.73ID:RO3CktaP
#![allow(non_snake_case)]
#![allow(non_camel_case_types)]
#![allow(non_upper_case_globals)]
で出来たけど
#[allow(non_snake_case)]
#[allow(non_camel_case_types)]
#[allow(non_upper_case_globals)]
にしろって書いてあるサイトもある
どっちなんだろ
0804デフォルトの名無しさん
垢版 |
2023/04/30(日) 16:11:01.60ID:RO3CktaP
2つ以上のC/C++のprojectから
bindings1.rs
bindings2.rs
みたいに造って同時にinclude!()すると
定義の衝突とか出るけど
header1.hとheader2.hのどっちにも
#include <iostream>
みたいなの書いてあるとそうなるんかな
面倒だな
0805デフォルトの名無しさん
垢版 |
2023/04/30(日) 18:48:15.79ID:wJbSgVTK
DDR4-SDRAMのCASレイテンシーは、15クロックではなく、15(ns)程度だった。
3GHzのCPUだと、45クロックという事になる。
0806デフォルトの名無しさん
垢版 |
2023/04/30(日) 19:13:17.45ID:4cTphIc0
>>805
いろいろ間違ってるで
SDRAMのCASレイテンシってのはナノ秒じゃなくクロックサイクル数
それもCPUクロックじゃなくRAMクロックのサイクル数
0809デフォルトの名無しさん
垢版 |
2023/04/30(日) 19:41:46.22ID:N5T1k6H1
>>801
Rustは一貫性があるようにガイドラインで命名ルールも定められている
as_xxxとto_xxxの違いは基本的に
as_xxxはコストなく別の型とみなす
to_xxxはコストかけて別の型を作るかみなす

その例ではもちろんstrとStringは別の型
基本的にas_strとto_stringが使われる
as_strは内部でstrとみなせるデータを持っている時にそこを指すだけなのでコストがかからない場合
to_stringは任意の型からStringを作り出すのでコストがかかる
to_stringはtrait ToStringのメソッドだがtrait Displayを実装することで自動的に実装される

唯一の例外がto_str
これは外部からのデータに対して存在する
strは必ずvalidなUTF8であると保証されている
一方でOsStrやそれを使っているPathは必ずしもvalidなUTF8であると保証されない
そこでUTF8チェックのコストが生じるのでto_strとなる
FFIであるCStrからも同様にto_strとなる
0811デフォルトの名無しさん
垢版 |
2023/04/30(日) 21:38:41.35ID:JKacdrUN
1クロック君も分かってないんだから
あんまり人のことは言わんほうがええで
0812デフォルトの名無しさん
垢版 |
2023/04/30(日) 21:45:00.52ID:r3YjkTH3
Python界隈のCodonを以前評価したけど速度面でC/C++と同等なのは単純なケースに限られるようだった
しかも多分皆が最初にみたAckermannの例はgccがclangを凌駕するパターン(再帰Fibonacciなんかもそう)
良いとこだけ記事にした方がいいねもらえるという情報ジレンマ..
0814デフォルトの名無しさん
垢版 |
2023/05/01(月) 00:28:33.95ID:SO3cX7+E
>>811
1クロック君 = ID:bU1qZ3nv のことか?
流し読みだと805は1クロック君で、>>752=move君(C++,Rust,Python)とコムソートの話をしてるのね

Rustユーザ-> >>563みたいな数独パズル状態でどん詰まり傾向、途中LinkedListは遅い発言を受けるも >>581でやっと動くが何もしない
1クロック君->呼ばれて登場、いつもの虚言連射 自分の思い込みと異なる現実を見たくないから意地でもコード書かない
move君->(いろいろ分かってないので、1クロック君の虚言でも)何かしら動くコードにしてideoneに置く、慣れないC++で
C++側->面白がってコード弄る、ベンチ晒す、けど全員離脱 move君はそれでも勉強になったとお礼

move君、いい奴なんじゃね?
0816デフォルトの名無しさん
垢版 |
2023/05/01(月) 09:28:12.86ID:KqibJVEU
あらゆるところに関所がある
まるで江戸時代だ
裏山に抜け道を見付けて分け入っても
突然藪から棒に番人が現れる
ところがそんな番人も
unsafe印籠を魅せれば一撃で退散だ
unsafe万歳!!!
こんなことなら最初から
表通りでunsafe印籠を出しておけば良かったんだ
きっと番人たちも思っているはず
さっさと最初からunsafe印籠魅せやがれ
無駄な手間取らせやがって
こんなのがエコシステムとか失笑もの
0817デフォルトの名無しさん
垢版 |
2023/05/01(月) 10:11:02.89ID:PhTcfeBC
C++のバイブルeffective C++でやってることを何も考えなくても
できるのがRustだよな
0818デフォルトの名無しさん
垢版 |
2023/05/01(月) 11:26:54.16ID:58qbKD3W
C++のconstを更にウザくした感じをデフォルトにした?
まぁ安全なんだろうけども
0820デフォルトの名無しさん
垢版 |
2023/05/01(月) 12:59:11.10ID:w7ftGEnh
これが先週のLinkedListチャレンジの結末である

Rust → どん詰まり傾向、1になればゴール
慣れないC++で → 慣れてなくとも独力で0を1にして動くコード提出、その先は先輩たちがサクッと引きあげ
0821デフォルトの名無しさん
垢版 |
2023/05/01(月) 13:08:10.08ID:6zKo1tMC
ちょっとした車輪ならぱぱっと組めて当然なのがC++ (俺はまだまだだけどw
だからこそ、メモリ関係のバグ・デバグに気を取られたくない unsafeの取り込みは急務
0822デフォルトの名無しさん
垢版 |
2023/05/01(月) 13:35:33.76ID:nAkxf6DU
よろしくゴサシュー

×Rust → どん詰まり傾向、1になればゴール
〇Rust → どん詰まり、1に出来ずに、ポエムにいいね
0823デフォルトの名無しさん
垢版 |
2023/05/01(月) 13:52:07.74ID:Gt7Bjt72
FPGA君も居るんだね
0824デフォルトの名無しさん
垢版 |
2023/05/01(月) 17:12:27.61ID:eFKh9HN+
C++でもnew/deleteなんてだいぶ前から使ってないけどな
C++03時代の話を未だにしてるけど、20年も前の環境だし、Boostも1.84からC++03のサポート終了が本格化する
この際、C++20まで一気にジャンプしたら良い
C++17と20の間にも互換性の壁があるので、過去の資産があるならC++17でも良いかもしれない
C++20は便利なので、資産が無いなら一気に飛べ
0825デフォルトの名無しさん
垢版 |
2023/05/01(月) 20:01:02.15ID:K5ZoaRkG
顧客には「リスク歓迎型」と「リスク重視型」いるが、Rustはいまのところ
前者が使ってる段階。
0828デフォルトの名無しさん
垢版 |
2023/05/01(月) 21:35:47.11ID:WwaB4YeM
>>824
C++20になったらこれに対応できるようになるって話はどうなったんだっけ?

[Ruby]
a.sort().reverse().map{|x| x.to_s}.join("-")

[JavaScript]
a.sort().reverse().map(x => x.toString()).join("-")

[Rust]
a.iter().sorted().rev().map(|x| x.to_string()).join("-")
0829デフォルトの名無しさん
垢版 |
2023/05/01(月) 23:46:23.25ID:Hk/n819+
よく表れる偉そうな人は
プロジェクトでは活躍できているの?
0830デフォルトの名無しさん
垢版 |
2023/05/02(火) 00:22:12.87ID:HfuJGdbc
>>828
既存のイテレータの問題を改善するためにC++20でstd::rangesが導入された
しかし限界というか期待外れというか無理があって使いやすいものにならなかった
0831デフォルトの名無しさん
垢版 |
2023/05/02(火) 00:49:58.35ID:1DAvDJUY
>>826
リスクを恐れずに新しいものを好む人、失敗しても特になんとも思わない人が
試している状態だということ。
0832デフォルトの名無しさん
垢版 |
2023/05/02(火) 01:35:45.73ID:icSV2sCY
>>831
それは5年以上前の話
現在は様々なインフラがRust製に置き換わりつつある段階
例えばRustで書かれたAWSが安全に問題なく高速に作動し、その上に世界中の各社のサービスが動いていて、世界中の人々が恩恵を受けている
0833デフォルトの名無しさん
垢版 |
2023/05/02(火) 01:41:41.06ID:1DAvDJUY
>>832
ただ、プログラミング業界において、まだ、使用者数が1%未満くらいしかない。
イノベーター理論によれば、2.5%位までが「イノベーター層」、次の20%
位が、アーリーアダプター層で、それらを合わせた23%位が、「リスク歓迎層」
いわゆる「人柱層」であり、その後に「キャズム」と呼ばれる溝が有ると言われている。
だからRustが普及するためにはまだまだずっと先が有る。
0834デフォルトの名無しさん
垢版 |
2023/05/02(火) 01:45:06.54ID:1DAvDJUY
>>833
大勢に影響ないが、数値はちょっとずれていて、ちゃんと調べてみたら、
イノベーター層: 2.5%
アーリーアダプター層: 13.5%
----キャズム----
アーリーマジョリティー層 34.0%
だったわ。
0836デフォルトの名無しさん
垢版 |
2023/05/02(火) 01:54:56.85ID:1DAvDJUY
有料商品だとリスクを恐れて買わない人が多いけど、Rustは無料だから
試すのはタダだから、金銭的には損はしないが時間とストレージ容量は損する。
ジュースみたいに飲んで美味しいわけでもない。
0837デフォルトの名無しさん
垢版 |
2023/05/02(火) 01:58:03.27ID:1DAvDJUY
Rustを試す場合、ストレージが結構食うのと、「パス汚染」の問題や、いつのまにか
大事にしていた開発の複雑なツールチェイン環境が
「おかしくなるかも知れない問題」が有る。
経験法則として、ツールチェインが壊れることは辛すぎる。
0838デフォルトの名無しさん
垢版 |
2023/05/02(火) 02:05:41.68ID:1DAvDJUY
Rustは、確かにニーズは有ることはあるが、緊急レベルが低いのかもね。
それとターゲット層が狭いかも。
0839デフォルトの名無しさん
垢版 |
2023/05/02(火) 02:12:40.43ID:1DAvDJUY
Rustを使いたがってる層って、なぜかサーバーサイドで使おうと思ってる人が多いが、
複雑で遅くなるような処理はMySQLやSQLiteみたいなDBMSがやってしまう。
だから自分でやる部分は余り速度が必要なかったりする。
Rustは安全性と速度の両方重視だが、この場合、速度は不要であり、安全面だけ
しか残らないがだとすると、JavaやRubyなどでも互角と言えてしまう。
しかも分かり易さは後者の方が勝ってる。
0840デフォルトの名無しさん
垢版 |
2023/05/02(火) 02:15:06.87ID:1DAvDJUY
SNSを見ても、なぜかRustをフロントやデスクトップアプリで使おうとしている人は少ない。
そもそもデスクトップアプリが絶滅危惧種になりつつあるが。
多分、GAFAMが全部需要を吸い取っているからかも知れんが。
0841デフォルトの名無しさん
垢版 |
2023/05/02(火) 02:28:34.92ID:7LVjR2sm
ガンダム00のイノベーター理論か
0842デフォルトの名無しさん
垢版 |
2023/05/02(火) 02:28:36.64ID:1DAvDJUY
そもそも、サーバーサイドやフロントは、CもC++も余り使われてこなかったが、
SNSでは、なぜか、そっち側でRustを使いたがってる人が目立つ。
そもそも、デスクトップやゲームでCやC++が強い。だから、C++の優位性や
慣れ親しみが有る人と層が被ってない。
なのに、彼らは「C/C++をRustが置き換える」と主張している。
彼らにはそもそも自分がCやC++を愛した時期があったのかと問うてみたい。
C++を使いこなした上で、さらにそれより便利だからRustを使おうとしている
ならまだしも、C++とは縁遠い人達がRustを礼賛している様に思えてならない。
0843デフォルトの名無しさん
垢版 |
2023/05/02(火) 02:32:22.41ID:1DAvDJUY
もともとC++が大嫌いな状態で、C++が消えてなくなればいい、と思っている
層がRustを嬉々として使いたがっている様に見えるのだ。
そして彼らはC/C++を一切話題にしない。もし今ままでC/C++を使い倒してきた
ならば、少しは触れてもいいはずなのに、彼らが好きな言語としてあげるリスト
の中には、決まって、C/C++が全く触れられておらず、
JS、Go、Kotlin、Java、Pythonなどが上がってくる。
C#ですら上がって来ない事が多い。
0845デフォルトの名無しさん
垢版 |
2023/05/02(火) 02:36:05.66ID:1DAvDJUY
昔から言われてきたことだが、Windowsのデスクトップアプリを作るのは、
ほぼ Visual Studio 一択 だということである、
そして、その場合、通常、C/C++(MFC、Win32)、C#(WinForms、WPF)、VB
のどれかとなる。
プロは、有料のVSを購入して、C++でMFCで組むのが標準とされてきた。
0846デフォルトの名無しさん
垢版 |
2023/05/02(火) 02:50:16.47ID:7LVjR2sm
MFCは流石にストレスだな
0847デフォルトの名無しさん
垢版 |
2023/05/02(火) 02:51:03.38ID:7LVjR2sm
BoostはURLやJSON、そしてついにMySQLが入ったぞ
0848デフォルトの名無しさん
垢版 |
2023/05/02(火) 03:00:27.06ID:7LVjR2sm
RegexはC++のパワーが発揮される好例だが、あまり使われてないね
文字を返すイテレータさえ用意できれば、どんなデータ構造にも正規表現が使えるんだから凄いけどね
0849デフォルトの名無しさん
垢版 |
2023/05/02(火) 03:04:05.05ID:1DAvDJUY
>>848
RegExの基礎の部分で、日本語周りがちょっと独特の仕様だった気がする。
UTF8やSJISには状態がない(Stateless)符合なのに、状態があるかのような
独特のC関数(?)を基礎にしている。
それは、もはやほとんど使われて無い、「Shiftじゃない方のJIS」の
ShiftIn(SI), ShiftOut(SO)方式ならそうかも知れないが。
0851デフォルトの名無しさん
垢版 |
2023/05/02(火) 03:11:39.95ID:1DAvDJUY
>>843
補足すると、C++が好きで、または、どこかに問題点を感じながらも使ってきたが、
さらに良いものを見つけたからRustに移行したい、というなら、C++も好きな
言語リストに入れたり、話題に触れたりするものだが、彼らは一切、
C++に触れようとしない傾向がある。
どんな言語にも欠点があるから、長年使ってきた言語であるならば、
愛着があっても、欠点も知っている。だから、もしC++を使ってきたならば、
C++の欠点を沢山気付いても、一方で、愛着も持っているはずだ。
ところが、彼らは、C++について一切触れずに、初心者用の簡易言語で
あるところの、JS、Java、Kotlin、Go、C#、Pythonなどには沢山触れるが、
C++には一切触れようとしない。
0852デフォルトの名無しさん
垢版 |
2023/05/02(火) 03:20:05.38ID:7LVjR2sm
>>851
キミもあまりC++を使っていないのでは?
0854デフォルトの名無しさん
垢版 |
2023/05/02(火) 04:07:41.22ID:6GBjYlnU
世の中の流れが様々な方向からRustへ向かっているところをみると残るは時間だけの問題かな
ロジックに弱い一部のプログラマーはRustでスマートに組めない傾向があるからその点での差別化も進むのかもしれない
0855デフォルトの名無しさん
垢版 |
2023/05/02(火) 04:14:17.45ID:1DAvDJUY
>>854
もしかしたらそうなのかも知れないな、と思う自分もいるが、
数値を見れば、ランキングは19位くらいで、使用者数は1%未満の状態。
それと個人的には、言語としてメンドクサイ。
0856デフォルトの名無しさん
垢版 |
2023/05/02(火) 04:38:02.37ID:6GBjYlnU
>>855
Rustをメンドクサイと感じるならロジックが苦手な人なのかもしれないね
一般的にどの言語でもプログラミングする時はロジックをパズルのように解いて組み立てていくんだけど
複雑な対象かどうかでそのパズルの難易度は様々でロジックが苦手な人は難しいパズルのケースではお手上げ

Rustではその解かなきゃいけないパズルが問題によって難易度が増す場合もある
それと引き換えに様々な多大な恩恵が生じるわけだけどロジックが苦手な人には難しかったり面倒だったり無理だったりしてしまう
でも元々のパズル自体の難度に対してそれほど難しくなるわけではないためプログラマーのほとんどはクリアできるけどね
結果的に極一部のロジックが苦手なプログラマーを切り捨てることで可読性や開発効率や安全性などを上昇させるのがRustというものの本質かもね
0858デフォルトの名無しさん
垢版 |
2023/05/02(火) 04:45:42.58ID:iwR4I1Vp
ぶったぎるようでいて、多分関連ある 素直に聞かせて
上のほうでも少し出たけど、RustのOOPってどうなん 慣れればわりとなんでも書ける?
所有権関係を見習いたくて、そればっかり今まで調べてて、OOPの書き心地に目を向けてなかった
0859デフォルトの名無しさん
垢版 |
2023/05/02(火) 04:54:26.56ID:iwR4I1Vp
>>850
たまにはATL/WTLも思い出してあげてください

あれ使いこなせるようになりたいな
そんなことを思いながらC++を趣味でやってる(異業種です
0860デフォルトの名無しさん
垢版 |
2023/05/02(火) 04:58:39.18ID:6GBjYlnU
>>858
RustやGoなど最近の言語ではOOPの癌であるクラス継承を完全に廃止してくれている点が朗報
代わりにRustでは強力なトレイトがあって非常に分かりやすく可読性もよいコードに誘導されて書き心地もよいよ
ただしクラス継承という癌におかされ中毒症状というか依存症の人の一部はリハビリ期間が必要なこともあるみたい
0861デフォルトの名無しさん
垢版 |
2023/05/02(火) 05:48:34.65ID:iwR4I1Vp
COMとか使ってたしねえ 今でもあるけど
やたらややこしくしないまで含めて、継承は使ってた世代だねえ
template<>だけがあるような感覚? (概要を聞いてからリファレンス見る勢
0862デフォルトの名無しさん
垢版 |
2023/05/02(火) 06:21:41.90ID:htF/u6KD
Rustのtraitは機能や能力や属性でもあるし制約条件でもあるし抽象的な型でもあるしtraitオブジェクトとしての値でもあるし
traitと普通の型とは直交する存在だから多対多の関係になるけど
trait自体に別のtraitが制約としてつく形でtraitの持つ機能の継承のように見せかけて継承ではないけど親子関係的になったり
実際のコードではほとんどのケースで具体型にモノモーフィゼーションされるからコストはないけど
一部のケースではtraitオブジェクトになって動的ディスパッチになる点ではC++で仮想関数を定義する基底クラス的な立ち位置でもあり
0863デフォルトの名無しさん
垢版 |
2023/05/02(火) 07:08:44.62ID:KGzdAUSh
>>861
templateをRustでジェネリクスとして表現する時に、そのジェネリックパラメータに対して、条件(制約)を課す指示となる「トレイト境界」としてもトレイトが登場
そのおかげで、C++のtemplate使用時の展開深入りしたわかりにくいエラーメッセージが出る前に、Rustではトレイト境界を指定するようにとコンパイラが叱ってくれて話が早いこともある
0864デフォルトの名無しさん
垢版 |
2023/05/02(火) 07:41:43.85ID:7LVjR2sm
世界中で使われたはずのHaskellが跡形もないからどうだろな
0865デフォルトの名無しさん
垢版 |
2023/05/02(火) 08:07:22.94ID:kr+/BuUA
GC言語なんていくらでも置き換えが効くからな
しかもGC言語は用途が狭く限定
ダメ言語C++が長く崩れなかったのはライバルが登場しなかっただけにすぎない
何もかも優れている非GC言語が登場してC++がようやく崩れた
0867デフォルトの名無しさん
垢版 |
2023/05/02(火) 09:16:12.71ID:AMbvZcVM
>>833
プロダクトライフサイクルにおける顧客割合の意味を理解してたらそんなアホみたいな比較はしない
0868デフォルトの名無しさん
垢版 |
2023/05/02(火) 10:52:59.55ID:xauM/oA9
>>860
このレベルの理解力しかない複オジがRustを推すからバカにされるんだよな
いい言語なのに
0869デフォルトの名無しさん
垢版 |
2023/05/02(火) 11:28:20.72ID:pc/ucEUa
>>860
何で継承を廃止したのかな?
新たなパラダイムを採用するにしても
継承を残しとけばC++ユーザの取り込みが進んだだろうに
0871デフォルトの名無しさん
垢版 |
2023/05/02(火) 12:15:36.07ID:7LVjR2sm
>>869
C++ユーザーは取り込めないし、取り込む気もないのでは

C++より優れているという宣伝文句は、主にスクリプト言語を使っている人の心をくすぐるのだと思う
0872デフォルトの名無しさん
垢版 |
2023/05/02(火) 12:18:56.04ID:gDBZ1McM
>>870
自分で考えなよ
顧客タイプ別の割合を足せば100%になるんだからちょっと考えればわかるでしょ
0873デフォルトの名無しさん
垢版 |
2023/05/02(火) 12:23:57.05ID:avRvtz73
>>869
何でか説明してるレスに何でか聞くのってヤバいと思う
0874デフォルトの名無しさん
垢版 |
2023/05/02(火) 12:38:11.31ID:7LVjR2sm
そもそもRustはC++に比肩しうるような性能を持たない
0877デフォルトの名無しさん
垢版 |
2023/05/02(火) 14:06:17.14ID:7LVjR2sm
DEVICE=A:\DOS\HIMEM.SYS
0879デフォルトの名無しさん
垢版 |
2023/05/02(火) 14:13:06.37ID:7LVjR2sm
主にJS使いがRustを使ってるからね
0880デフォルトの名無しさん
垢版 |
2023/05/02(火) 14:21:48.41ID:moHVYXda
>>874
上手に書けば似たようなもんだろうから、性能はそんなに争わなくていいぞ
ヘタクソが使ったら性能出ない、じゃどっちもどっちw
0881デフォルトの名無しさん
垢版 |
2023/05/02(火) 14:21:50.46ID:rS/MFCk8
>>869
Rustと関係なく昔からOOPでは
継承(is-a)より合成(has-a)が望ましい
という話を聞いたことがない?
合成(has-a)の方が柔軟性が高いだけでなく
各機能ごとにコードを分けられるため
可読性も上がり保守性も良くなる
菱形多重継承の問題も避けられる
巨大な親クラスを用意する必要もなくなる

別の見方をすると
継承は複数の役割を混ぜて詰め込んでいる
コードの共通化や多層性など別々の役割が混在してる
それが上述の継承の様々な問題を引き起こしている
それぞれの役割が個別に提供されたら継承は不要となる
そして問題はなくなり可読性も保守性も向上する

以上の話はRust以前から言われてきた話
そしてGoもRustも当然のように継承は廃止した
まともなプログラマーなら継承は複数の役割が混在してることに気付いてる
だから継承がない言語でもそれぞれの役割ごとにプログラミングすることができる
一部のダメなプログラマーを除いて継承がない言語で困ることはない
コードの可読性や保守性が上がったことで継承廃止に納得賛成する
0882デフォルトの名無しさん
垢版 |
2023/05/02(火) 14:29:15.44ID:EwZoXXsg
>>872
分かりませんので教えていただければ幸いです。
Rustにおける100%になるような顧客の集合(分母)とは何に当りますか。
0883デフォルトの名無しさん
垢版 |
2023/05/02(火) 14:35:22.14ID:pc/ucEUa
>>881
新たなパラダイムを採用するにしても
継承を残しとけばC++ユーザの(Javaとかもかな?)取り込みが
もっと進んだのではないのかな?
本当に良いパラダイムであるのなら継承を残したままC++が呑み込むと思うよ
0884デフォルトの名無しさん
垢版 |
2023/05/02(火) 14:46:33.32ID:rS/MFCk8
>>876
#[derive]は継承ではない
継承とは複数の役割を混在させた汚い概念
その説明については>>881を読んでほしい

#[derive]自体は手続き型マクロによる機能の付加
だから何を付加するかそのマクロ実装によって機能は変わる
トレイトを自動実装させるものもあれば
トレイトは出て来ず無関係にその対象にメソッドを生やすことも可能
マクロといってもRustコードの構文解析木を入出力とできるため高機能
0885デフォルトの名無しさん
垢版 |
2023/05/02(火) 14:46:57.82ID:moHVYXda
継承といってすぐ思いつくのは、COMのIFoo2:IFoo みたいなときだけど、Rustでもできないわけじゃないでしょ
0886デフォルトの名無しさん
垢版 |
2023/05/02(火) 14:47:22.90ID:0THLQfdG
>>873
説明できてるつもりなのがマジでヤバいな
トレードオフを理解出来ないやつは適性ないから早めに辞めたほうが本人のためにも世の中のためにも良い
0887デフォルトの名無しさん
垢版 |
2023/05/02(火) 14:52:39.31ID:zNH+FeOM
crate hoge を使うとき
extern crate hoge; する人と
use hoge; する人がいるけど
どっちがどう違うん?
0888デフォルトの名無しさん
垢版 |
2023/05/02(火) 14:58:37.73ID:moHVYXda
ちな、C++は継承全盛の時代にクソの山が築かれたので、その反省から、継承はナシでいくって発想はそんな違和感ない
現役のC++erは、そのクソの山をくぐってる(新参も過去資産を読まされるからね)から、継承するにしても注意深く設計する
だから、あんま反論する気はないからね
0889デフォルトの名無しさん
垢版 |
2023/05/02(火) 14:58:45.32ID:rS/MFCk8
>>883
継承はコードの可読性や保守性を下げるだけの存在なので不要
継承は複数の役割が混在した汚い存在
それぞれの役割を分離して実現できる方がまともなプログラマーとってうれしい

>>885
複数の役割が混在した継承という言葉や概念を用いるのはよくない
そのような汚い継承というものはRustに存在しない
もちろんそれぞれの役割の実現方法は別々の方法としてRustにある
0890デフォルトの名無しさん
垢版 |
2023/05/02(火) 15:04:00.26ID:zNH+FeOM
>>856
C/C++もRustもどっちでも良いけど
Rustはアルゴリズムで悩むよりコンパイル通すことに悩む時間の方が長くなると感じる
まだ慣れてないだけかも知れないのは認めるが
アルゴリズムを実装したいのに集中力を削がれる
0891デフォルトの名無しさん
垢版 |
2023/05/02(火) 15:10:31.30ID:zNH+FeOM
>>858 >>860
traitは便利だけどC#のpartialに似てる部分もあって
実装があっちのファイルこっちのファイルに分散してて
管理出来てないとどこに何があるのか判らなくなる傾向はあると思う
C/C++はヘッダーさえ追いかければどこに何が定義されているか見付け易いが
Rustは時々えっこんなのここで定義してあったんだみたいな発見があるし
気付かないで再発明してから後になってえっ既にあったの?ってなるときがある
0892デフォルトの名無しさん
垢版 |
2023/05/02(火) 15:13:11.14ID:moHVYXda
>>889
伝わってねえ
継承時代のインタフェースってのがあるんだよ 特にWindowsにはね
MSが全面採用って言ったんだから、できないはずないんだって
0893デフォルトの名無しさん
垢版 |
2023/05/02(火) 15:14:50.82ID:8SBmOXa9
>>890
それは単に慣れていないだけだよ
Lispを始めた時も最初は手続き型言語以外に慣れなくて似たような感じだった
Prologの時も宣言型言語の発想の転換に慣れるまでそんな感じだった
狭い範囲の言語しかやって来てないとその感じを初体験かもしれないね
いずれも最初のうち慣れるまでを乗り越える
0894デフォルトの名無しさん
垢版 |
2023/05/02(火) 15:19:27.33ID:zNH+FeOM
>>881
>Rustと関係なく昔からOOPでは
継承(is-a)より合成(has-a)が望ましい
という話を聞いたことがない?
合成(has-a)の方が柔軟性が高いだけでなく
各機能ごとにコードを分けられるため
可読性も上がり保守性も良くなる
菱形多重継承の問題も避けられる
巨大な親クラスを用意する必要もなくなる

↑ここはNimもうまくやってると思うが
規模が大きくなると型推論とかmatchで時間かかりそう
0895デフォルトの名無しさん
垢版 |
2023/05/02(火) 15:20:21.37ID:rS/MFCk8
>>892
申し訳ないがWindows特有の話には一切関心かない
そしてそれはプログラミング言語の話でもない
マイクロソフトがRustについても大量のドキュメントとライブラリ提供している
それらを見ればよいのではないか
0896デフォルトの名無しさん
垢版 |
2023/05/02(火) 15:22:44.69ID:UlsqlHPi
>>887
extern crateはちょっと古い書き方(今でも用途ゼロではない)

rustコンパイラが外部のクレートを参照するためには
ソース内でextern crateを指定するかrustcに--externオプションで渡す必要があるんだけど
今はcargoがdependenciesの中身を全部渡してくれるからextern crateの出番は減ってる

今でも外側からのテストコードでdependenciesに含まれてない自分のクレートを参照する時は
extern crate [テスト対象のクレート名];
みたいに使われたりする
0898デフォルトの名無しさん
垢版 |
2023/05/02(火) 15:35:19.29ID:pc/ucEUa
>>889
>継承(is-a)より合成(has-a)が望ましい
使う場所が違うんでないの?
composition(has-a)を使うべきところで
継承で設計するので破綻すのではないかな?

所有権システムの話と違って
継承は合成と両立できるのなら
排除する必要はなかったと思うんだよね
0899デフォルトの名無しさん
垢版 |
2023/05/02(火) 15:43:54.19ID:moHVYXda
>>895
「言語学者」だな
どうにも話がかみ合わない時があるのは、こういうとこなんだろうな。。

じゃあ、WindowsからはC++はなくせない、貴方はその点には異論も関心もないということでおk?
0900デフォルトの名無しさん
垢版 |
2023/05/02(火) 15:44:03.40ID:avRvtz73
言語としての良さを捨ててシェアをとりにいくのは本末転倒でしょうよ
0901デフォルトの名無しさん
垢版 |
2023/05/02(火) 15:44:37.51ID:8SBmOXa9
>>897
もちろんLispの例は手続き型とは異なる例として出しただけだから直接関係ないよ
でも別の話としてRustは関数型言語としての特徴も随所に見られるから慣れてると有利だね
C++で所有権や無効な参照を生まないことに慣れてれば有利な点とは別方向だよ
それら両方に慣れてない人は多重に慣れないといけないもんね
0902デフォルトの名無しさん
垢版 |
2023/05/02(火) 15:57:21.78ID:rS/MFCk8
>>898
継承と呼ばれているものは複数の役割を混在させた醜い悪だから廃止が好ましい
全く異なる言語であるGoでもRustでも同じ結論となったことがそれを実証している
複数の役割を各々個別に用意しているのでプログラマーが困ることはない
むしろコードが役割毎に分離されて保守性も可読性も上がっている
0903デフォルトの名無しさん
垢版 |
2023/05/02(火) 16:09:56.45ID:jUW5YyXB
OOP理解してないやつが継承にダメ出ししてるからクソレスにしかならんよなw
0904デフォルトの名無しさん
垢版 |
2023/05/02(火) 16:12:23.50ID:ADB1nCOj
Rustと違ってGoには実質継承と同じ使い方ができる機能があるのにね
0905デフォルトの名無しさん
垢版 |
2023/05/02(火) 16:18:52.28ID:AI1f/TNN
STLのコンテナを拝借したいときとか
private継承protect継承は便利やぞ
これってRustの合成にあたる?
0907デフォルトの名無しさん
垢版 |
2023/05/02(火) 17:47:10.50ID:moHVYXda
Rustの美しいところだけで作ったOS…組み込みとかではできるかもしらんが

そうじゃない、Rustだって、泥臭いOOPもカバーできるだろ
泥臭いことを一切すべきでないとかいうなら、Rustは要らんぞ
0908デフォルトの名無しさん
垢版 |
2023/05/02(火) 18:05:24.51ID:7LVjR2sm
いや、Rustは要らんだろ
Javascriptで十分
0909デフォルトの名無しさん
垢版 |
2023/05/02(火) 18:26:29.87ID:h3kIy3/6
>>906
継承のメリットデメリットを理解してたら
そんな中身のない反論をするわけないんだけどな
まぁ他の人たちが複オジの嘘に騙されなければそれでいいや
0910デフォルトの名無しさん
垢版 |
2023/05/02(火) 18:47:19.21ID:dbPFRoX3
継承と移譲は考え方も方向も真逆だよな
移譲を使うべきところで何でも継承を使ってしまう継承しか知らないプログラマーが多くて困ったことだが
0911デフォルトの名無しさん
垢版 |
2023/05/02(火) 19:13:40.31ID:7LVjR2sm
ウィンドウシステムを考える時、

ボタンクリックで呼び出されるあなたのコードを

デリゲートで実装するか継承で実装するか

という風に考えると

まあ大した違いは無い
0915デフォルトの名無しさん
垢版 |
2023/05/02(火) 22:22:33.76ID:61XWC/5S
>>913
これまだ世に出しちゃいけないレベルでは?
未完でも早めに発表しないと資金切られるのか?

https://github.com/memorysafety/sudo-rs
⚠ WARNING

Sudo-rs is currently under active development and is not suited for any production environment. Using sudo-rs is only recommended for development and testing purposes, but you should expect any system that has sudo-rs installed to break easily and to not be secure.

Rust part20
https://mevius.5ch.net/test/read.cgi/tech/1677771928/354
354: デフォルトの名無しさん sage 2023/05/02(火) 20:03:17.56 ID:6g8Nsfp3
>>341,345
sudu-rsとsudo(original)のtokeiしました
LOCが違い過ぎて機能的に同等とは思えませんが誰か確認してください
https://i.imgur.com/wqUfNLQ.png
0916デフォルトの名無しさん
垢版 |
2023/05/02(火) 22:58:22.97ID:moHVYXda
>>913,915
スポーツ新聞やあるまいしw
挑戦するのはいいが相手がでかすぎる 1年かけてやりますってぶち上げたんだろ
0917デフォルトの名無しさん
垢版 |
2023/05/02(火) 23:01:31.89ID:qhte9zom
>>914
確かに最初はそう思った
0919デフォルトの名無しさん
垢版 |
2023/05/03(水) 02:03:29.65ID:KEEkEyxd
>>918
基本は公式
1. 2018 Edition Guide
2. Rust By Example
3. The Book
0920デフォルトの名無しさん
垢版 |
2023/05/03(水) 10:07:34.41ID:vFyxX5cE
クレート・モジュール周りでわかりにくかったのは以下の2点
どっちも公式に書いてはいるんだけど直感的じゃないからわかりにくい

1. modにはinline定義と定義読み込みという2つの使い方があること
2. main.rsとlib.rsが両方あるプロジェクトは2つのcrateができるのでmain.rs内でcrate::と書いてもlib.rs内のモジュールは参照できないこと
0921デフォルトの名無しさん
垢版 |
2023/05/03(水) 11:03:39.95ID:RL708iOG
>>920
インライン定義とファイル指定の二種類あるのは色んなものでそんな感じ
Rustでも色んなサンプルを見てそうなってるから初めてでも違和感なかった

プログラムのディレクトリにはlib.rsは無しでmain.rsが始点
クレートのディレクトリは別に作ってlib.rsが始点とするよね
Cargo.tomlも分けたいし
0922デフォルトの名無しさん
垢版 |
2023/05/03(水) 11:20:24.78ID:VnqPz5Ow
>>921
さすが複オジ
わかってないね
0924デフォルトの名無しさん
垢版 |
2023/05/03(水) 11:55:22.78ID:lWIcvRA0
クレートとモジュールの仕組みがあまり賢い作りじゃない気がする
なんかもっとやりようがあっただろうと
0925デフォルトの名無しさん
垢版 |
2023/05/03(水) 12:04:46.25ID:654rMlMr
>>914
>>924
なぜ全く別物であるクレートとモジュールを混ぜて語るんだ?
区別ついてるならそこを問題にしないだろ
0928デフォルトの名無しさん
垢版 |
2023/05/03(水) 13:04:28.94ID:mKdwc3tr
>>923
太古からあるCだからこそ、太古のソースをも扱うってわけさ
おかげで、文字列の扱いがよそ(他言語)と比べて一見美しくないw
0931デフォルトの名無しさん
垢版 |
2023/05/03(水) 14:05:40.38ID:LKV06yDn
クレートは独立した存在として
パッケージ内にいようが外部パッケージにいようが動作するはずだよね
紛らわしいならパッケージを分離して確認してみたら
0932デフォルトの名無しさん
垢版 |
2023/05/03(水) 14:17:42.39ID:KMrNo7SY
クレートとモジュールを整理するとこんな感じ
どこか間違ってるかもしれない

・Rustのクレートは1つの仮想的なソースファイル(以下ルートファイル)から作られる
(rustcはインプットで1つのrsファイルだけを受け取ってクレート(bin, rlib, etc.)を出力する)

・ルートファイルは内部に階層的なモジュール(mod foo {...})を持つことができる

・ルートファイルのモジュール"mod foo {...}"は"mod foo;"とすることでモジュール本体を別ファイルに切り出すことができる
 別ファイルのパスはそのモジュールの階層と名前によってルートファイルから相対的に決定される(ここが分かりにくい)
 また、#[path="..."]で場所を直接指定することもできる
 参考:https://doc.rust-lang.org/stable/reference/items/modules.html

・ルートファイルは慣習的に"main.rs"(実行用)、"lib.rs"(ライブラリ用)が使われる
 (Cargo.tomlのpathで指定可能)
 テスト実行用のルートファイルは見えないところで勝手に作成される

ルートファイルとかオプションを切り替えることで同じファイル群から
複数のクレート(ライブラリ、ツール、テスト、etc.)を出力できるのがパッケージかな
別に複数じゃなくてもいいけど
0934デフォルトの名無しさん
垢版 |
2023/05/03(水) 14:56:29.41ID:qfRwg4l4
>>932
>どこか間違ってるかもしれない
こう思わせること自体が間違いだな
どんだけ複雑なんだよ
0935デフォルトの名無しさん
垢版 |
2023/05/03(水) 15:09:24.50ID:IgWfoZ6k
>>932
ルートモジュールやクレートルートならわかるがルートファイルという言葉は初めて聞いた
公式のどこかに出てくる用語?
0937デフォルトの名無しさん
垢版 |
2023/05/03(水) 15:26:33.96ID:FRBHH05h
>>934
Rustが複雑に見えるように枝葉末節を混ぜて説明してるだけだろ
単純にクレートという名の各々独立したライブラリ用クレートまたはプログラム用クレート(=バイナリクレート)があるだけだ
モジュールも単純でクレートの内部の名前空間にすぎずファイルディレクトリ構造と一致(もしくはmod xxx {...}と内蔵)
パッケージは複数のプログラム用クレート(とおまけに一つのライブラリクレート)をまとめただけ
以上で終わり
0938デフォルトの名無しさん
垢版 |
2023/05/03(水) 15:30:44.88ID:KEEkEyxd
>>932
>・Rustのクレートは1つの仮想的なソースファイル(以下ルートファイル)から作られる
ふーん

>・ルートファイルは慣習的に"main.rs"(実行用)、"lib.rs"(ライブラリ用)が使われる
仮想的やなかったんかーいwww
0939デフォルトの名無しさん
垢版 |
2023/05/03(水) 15:35:16.94ID:CpOUjLJu
rustのモジュールの仕組みが分かりにくいから徐々に仕組みが変わったんじゃないの?
0940デフォルトの名無しさん
垢版 |
2023/05/03(水) 15:42:15.30ID:KMrNo7SY
>>935
「ルートファイル」は説明のために勝手に作った
モジュールとかクレートを説明するのに「ルートモジュールやクレートルート」は使いにくい
0941デフォルトの名無しさん
垢版 |
2023/05/03(水) 15:43:07.18ID:FRBHH05h
>>939
モジュールは単純明快
クレート内部の名前空間にすぎない
ファイルディレクトリ構造と一致
クレートの外に対してその深い構造を見せたくないならpub use boo::foo::woo;とシンボリックリンク相当を張るだけ
0942デフォルトの名無しさん
垢版 |
2023/05/03(水) 15:49:18.63ID:CpOUjLJu
コアのstructをファイルごとに分ける場合が単純にわからない
他の言語は分けて書けば終わり
rustはそれがどうなるのかわからない
0943デフォルトの名無しさん
垢版 |
2023/05/03(水) 15:50:38.86ID:CpOUjLJu
traitなどもどのようなファイルに書いてどのように分割していくのかがわからない
モジュールなんだろうけど意味がわからない
0944デフォルトの名無しさん
垢版 |
2023/05/03(水) 16:01:29.37ID:CpOUjLJu
trait animalがファイルであって
struct dog
struct cat
を別ファイルにした場合どのように書くのが正解なのかがわからない
traitを何らかのモジュールにおいて別のモジュールでdog catを実装するのか

もうそこから理解できない
0945デフォルトの名無しさん
垢版 |
2023/05/03(水) 16:05:48.81ID:CpOUjLJu
それとも別のクレートにおいてそれを利用するのが正しいのかそしたら同のように利用するのが正しいのかもわからない
パッケージクレートモジュールの設計がわからない
そこから何も進まない
0946デフォルトの名無しさん
垢版 |
2023/05/03(水) 16:19:54.29ID:KMrNo7SY
ファイルの分け方に正解はないと思う
pubじゃない要素(構造体フィールド等)にアクセスしたいかどうかが一つの指標になるけど
自分はとりあえずJavaみたいに1ファイルにつきpub型定義1つをベースにしてる(絶対ではない)

参考になるかは分からないけど
・モジュール内ではpubでない要素に相互にアクセスできる
・子モジュールは親モジュールのpubでない要素にアクセスできる
・親モジュールは子モジュールのpubでない要素にアクセスできない
が設計のヒントになるかな

Javaのデフォルト公開(パッケージ内アクセス)みたいなことがしたければ
同じクレート内でのみアクセスできるpub(crate)みたいな公開指定もある
0947デフォルトの名無しさん
垢版 |
2023/05/03(水) 16:23:38.18ID:CpOUjLJu
仮に自由にかけるとしてもベストプラクティス的なのがまだ育ってないのがRustの巨大な弱点だと思う
0949デフォルトの名無しさん
垢版 |
2023/05/03(水) 16:40:24.03ID:VH6J0Pal
ファイルは別けるな
だな
0951デフォルトの名無しさん
垢版 |
2023/05/03(水) 16:49:42.50ID:qOKBVCag
メカニズムがわからないという話かと思ってたが
プラクティスがわからないという話だったのか
0952デフォルトの名無しさん
垢版 |
2023/05/03(水) 16:55:25.45ID:CpOUjLJu
>>951
メカニズムがそもそもおかしい
それでベストプラクティスが必要になる

実際はこれという書き方のために仕組みができたはずなんだけどこれと言うものが見当たらず…
それで大勢が迷いながら試行錯誤しながら書いてる
おかしいことこの上ない
0955デフォルトの名無しさん
垢版 |
2023/05/03(水) 17:37:47.24ID:ycNdXH31
ファイルは変更のタイミングで分ければいいんじゃないか
AとBがあるとして、Aを変更するときに、Bも変更しがちなら同じファイル、
そうでないなら別のファイルてな具合にね
0956デフォルトの名無しさん
垢版 |
2023/05/03(水) 17:43:35.45ID:8i5w0ffn
>>944
モジュールの主目的は関数や型の論理的グループをまとめるためなので分け方にRust特有の事情は基本的にないよ

ファイルを別にしたら必ず別モジュールになるんだけどそれは理解してる?
0957デフォルトの名無しさん
垢版 |
2023/05/03(水) 18:01:00.42ID:QkSJi2Wv
例えば>>927の動画だとルート含めて4つのモジュールに分割してる

auth_service(ルート)
auth_service::auth_util
auth_service::auth_util::models
auth_service::database

この分け方に正解はなくてアプリの用途や開発組織の事情でいろんな分け方になりうる
それはRust以外の他言語でも全く同じ
0958デフォルトの名無しさん
垢版 |
2023/05/03(水) 18:02:29.01ID:ZUjoJdUJ
Rustが言語レベルでデザインパターンを縛っているわけでもないんだから
言語レベルでのベストプラクティスとかあるわけもなし
0959デフォルトの名無しさん
垢版 |
2023/05/03(水) 18:03:18.87ID:QkSJi2Wv
部分的に別クレートに分けるかどうかはRust特有の事情が絡んでくるけどクレート分割を考えるのはプロジェクトが大きくなってからで十分
0960デフォルトの名無しさん
垢版 |
2023/05/03(水) 18:41:43.51ID:CpOUjLJu
どうもRust勢の答えがずれてるね
ファイル分轄したいときは普通はどうしますかって問いにまともに答えていない

他の言語だと大体はファイル分轄しても同じ名前空間的なものにつっこめばそれでもう参照可能
rustは違うんだろう?
それが何でそうなったのかは考えたことがあるのかな?
それで何かコーディングするうえで有利だなと思ったことはあるのかな?
なんかもう回答のレベルが低い
0961デフォルトの名無しさん
垢版 |
2023/05/03(水) 18:44:09.53ID:Evi6pte5
>>946
>自分はとりあえずJavaみたいに1ファイルにつきpub型定義1つをベースにしてる(絶対ではない)
RustのモジュールはJavaだとクラスよりパッケージに当たるものでは?
0962デフォルトの名無しさん
垢版 |
2023/05/03(水) 18:45:33.01ID:CpOUjLJu
他の言語やってた時は1クラス1ファイルでとか言ってたくせにrustに移動したら
大きなコード書くまで考えなくてもいいとか言い出すのは変だよ

こんなレベルの低い回答はないし答えなくてもいい
識者が答えればいいんだ
0963デフォルトの名無しさん
垢版 |
2023/05/03(水) 18:48:42.23ID:5z4fSxCy
イノベーター(マニアに近い)には「なぜか売れる」という現象がある。
熱狂的に支持する層が一部にはいる、ということは恐らく事実で悪いことではないが、
それはたまたまその人達のニーズに合っていただけであり、それだけで普及には
至らない。
0964デフォルトの名無しさん
垢版 |
2023/05/03(水) 18:52:33.52ID:5z4fSxCy
何か作って売るとき、この商品は競合品に比べると総合的に見て欠点が多くて
お勧めは出来ないんだけど、一部の人にはなぜか売れて、結構評判もいい、
ということがある。
それがRustではないか。
0965デフォルトの名無しさん
垢版 |
2023/05/03(水) 19:00:10.90ID:IJcGoA2a
個人的にC++よりRust使いたいけど、結局Windows App SDKなりCUDAなりがデフォルトでRustインターフェースを提供していないので、ハイパフォーマンス&ローレイテンシなデスクトップアプリ/ゲーム開発に使うのが大変で厳しいって話はもう数年間改善されてない

コミュニティ的にはWebview使う方向に行ってたりして方向性かみ合わないし

いやWin32とDirectX叩けるだろって言われたらそうなんだけど、そこから実用レベルまで個人で環境やライブラリを叩き上げるのは現実的ではないと思ってる

この辺の話はどうよ
0966デフォルトの名無しさん
垢版 |
2023/05/03(水) 19:08:54.73ID:CpOUjLJu
rust使ってても1ファイルで完結するようなものしか作ってないのかな?
それとも一個モジュール作ってそこに全部入れて膨大なソースをスクロールさせてるのか?
0967デフォルトの名無しさん
垢版 |
2023/05/03(水) 19:13:03.51ID:ycNdXH31
ファイルの分け方は言語論というより開発論だよな
この話は終わりでいいかと
0969デフォルトの名無しさん
垢版 |
2023/05/03(水) 19:18:34.10ID:KMrNo7SY
>>961
Rustのモジュールは階層化して親子関係を作れるからJavaのパッケージよりちょっと柔軟かな
必要ならもう1つ上の階層のモジュールをJavaのパッケージに対応させればいいし
自分がファイルを分けてるのは単純に編集しやすいから
0970デフォルトの名無しさん
垢版 |
2023/05/03(水) 19:30:08.58ID:CpOUjLJu
Rustでは実用上有意義なファイル分轄は難しいので1ファイルにしてくださいと言うことでいいのか?
それも特殊な例じゃなくて本当によくあるケースレベルで分割は難しいってこと?
0971デフォルトの名無しさん
垢版 |
2023/05/03(水) 19:32:28.01ID:5z4fSxCy
「Rustのここはおかしいんじゃないか」と言った時、「いやいや、それは現実的
には問題ない、それより○○が素晴らしいから何の問題もない」
という受け答えをよく目にするが、それはまさにその人の「ニーズ」に
たまたま合っている、ということであり、イノベーター理論が語るところ
であろう。イノベーターはあらゆることでマニアやオタク、ということではなく、
たまたま、その商品に対してだけはニーズに合っていた、と言われている。
0972デフォルトの名無しさん
垢版 |
2023/05/03(水) 19:39:09.58ID:CZOik0F4
何かしらのフレームワーク使ってるならそこに分ける方針とかだいたい書いてんじゃねーの
そういうのが無いならご自由にどうぞ
別に分け方を間違えたからって困ることは無い
0973デフォルトの名無しさん
垢版 |
2023/05/03(水) 20:14:37.30ID:CpOUjLJu
それは言いがかりだ!Rustはすばらいぃいいいいと言う人が出て来ないんだけど
自分のような初級三軍質問者の愚問には答えられないんだろうか?
0974デフォルトの名無しさん
垢版 |
2023/05/03(水) 21:54:10.72ID:FqNPXkOF
プラクティスがわからないんじゃなくて
結局メカニズムがよく理解出来ませんって話みたいね

ファイルを分けたときに分けたファイルをどうやって使えばいいか分からないってことでいいのかな?
0975デフォルトの名無しさん
垢版 |
2023/05/03(水) 23:29:24.40ID:ZZCdQXOG
>>960
Rustはファイル分割の自由度が高く簡単に分割することが可能
分割するか否かは自分やプロジェクトの方針次第
最初はmain.rs一つから始めて進行とともに分割していく方針でも構わない

名前空間としてはファイル名がそのままモジュール名となる
その同名ディレクトリを作ればその下のファイルがサブモジュールになる
いずれもmod foo;と書くだけで使えるようになる
あとはfoo::TypeNameやfoo::boo::func_nameで自由に使える
長くて面倒ならuse foo::boo::func_name;すればfunc_nameで使える

ただしモジュール側ではモジュール外で使えるようにpub宣言が必要
逆に言えばpub宣言しなければモジュール内にプライベートにできる
pub宣言はpub(crate)やpub(super)など公開範囲の制限も可能

以上がモジュール分割
その一部を複数のプロジェクトから使えるライブラリとして独立させたくなったらクレート分割
クレートは並列コンパイル単位にもなるので専属利用でも敢えてクレート分割することもある
他にも構文解析木を入出力とする手続きマクロを作るときも単独クレート化が必須
0976デフォルトの名無しさん
垢版 |
2023/05/04(木) 00:00:52.77ID:E2F33yJd
>>975
そこに書かれてる内容がすべてならファイル分轄の自由度は低いよね
ファイル名がモジュール名になるんなら自由度は制限される
サブモジュールの位置もフォルダ内と限定されてる
0977デフォルトの名無しさん
垢版 |
2023/05/04(木) 00:27:31.14ID:dgAQoWCg
>>965
需要が無い
Webviewで十分
0978デフォルトの名無しさん
垢版 |
2023/05/04(木) 00:31:42.11ID:BOGxwae7
>>976
Rustは自由度が高い
分割する時にはモジュール=ファイルにすぎない
一部の言語のようにモジュールの意味や位置付けや使い方を限定していない

さらにコード上(=ファイル上)はモジュールやサブモジュールにあっても公開位置付けは別にできる
例えばpub use foo::Foo;とすることでFooがfooの下にあるにも関わらず直上にあるものとして公開できる

つまりプログラミングするときは完全に自由にファイル分割やディレクトリ分割していくことが可能
それらを公開するときにその分割内部構造を見せたくないならば見せずに整理して公開することが可能
公開するときのモジュールの位置付けとコーディングするときのファイル分割の自由度それぞれが独立に存在できる
0980デフォルトの名無しさん
垢版 |
2023/05/04(木) 08:18:45.38ID:tHpAcWOx
Javaとかはその当たり結構うるさいけど他の言語ってそもそもあまりそういうのうるさくないよな。JVM系の言語はJava文化圏の中にあったりクラスファイルの仕様が言語側のモジュールの粒度を規定してしまうけど、そういうのがない言語だとどういう分け方がベストかみんな試行錯誤している期間があったり、ベストプラクティスが結局ない状態になるよな。

俺から見るとGoとかは現代の言語としてはありえないぐらい無法なディレクトリ構成がまかり通ってると思うけど、ああいうのが性に合ってる人もいる。
0981デフォルトの名無しさん
垢版 |
2023/05/04(木) 09:11:56.85ID:4+acb+xt
>>978
> 分割する時にはモジュール=ファイルにすぎない

本当にこれだけなら非常に自由度が低いなあ…
他の言語知らないのか?
0982デフォルトの名無しさん
垢版 |
2023/05/04(木) 09:18:33.73ID:4+acb+xt
1ファイルが1モジュール限定なら1960~80年代の古代の言語じゃん
ファイルの冒頭でモジュール名やプロシージャー名を指定するあれ
0983デフォルトの名無しさん
垢版 |
2023/05/04(木) 09:23:38.28ID:aSm9nQgp
>>979
ありがとう
0984デフォルトの名無しさん
垢版 |
2023/05/04(木) 09:28:14.17ID:BOGxwae7
>>981
その後に説明しているのに
説明を読まずに一部を切り取りするとは性格歪んでる

>>982
Rustはそんなことはなく自由度が高い
自由にファイル分割やディレクトリ分けをして全体を一つのモジュールとして見せることも可能
逆にファイル一つに複数のモジュールを定義することも可能
0985デフォルトの名無しさん
垢版 |
2023/05/04(木) 12:05:42.79ID:XE2Na1jR
自由度が高いからJavaのように何も考えなくてもファイル分割できる指針がなくて困ってるんでしょ

モジュール分割って疎結合高凝集になるようグルーピングしましょうという当たり前の話なんだけどたぶんやったことがないと難しいんだよ
だからどうモジュール分割すべきかなんて小難しいそうなことを考えなくてもファイルを分割できる指針を”ベストプラクティス”という名で求めてるんだと思う
モジュール分割が先にあってそれに合わせてファイル分割するのが本来の姿だから考え方が逆なんだけどね
0986デフォルトの名無しさん
垢版 |
2023/05/04(木) 12:16:56.04ID:UA4lEoz+
>>985
「公開されるモジュール仕様」に対して
「実際にプログラミングする際のファイルやディレクトリ構成」の自由度がどの程度かが焦点だろ
前者の「公開されるモジュール仕様」はプログラミング言語やその機能とは直接関係ない話でありこのスレでも対象外
後者の「実際にプログラミングする際のファイルやディレクトリ構成」の自由度が言語により異なってくる部分
Rustは最大限の自由度がある言語の一つ
0987デフォルトの名無しさん
垢版 |
2023/05/04(木) 12:27:57.50ID:BxJFarE7
Javaも
クラス大きすぎるとダメだから分けろとか
クラス多すぎるとダメだからまとめろとかパッケージ分けろとか
パッケージまたぐと絡まるから変な分け方するなとか
それなりに悩みはあったと思う

ただC++でも似たような悩みはあるはずだからファイル分割の仕組みの違いで戸惑いがあるのかもしれない
C/C++はソース単位でコンパイルして最後にリンカでくっつけるけど
Rustは全体を分割された1つのソースの塊とみなして一気にコンパイルする感じだから
とりあえず部品から考えるボトムアップ的なアプローチの人は引っ掛かりそう
0989デフォルトの名無しさん
垢版 |
2023/05/04(木) 12:47:28.68ID:nFTKSuN5
>>987
どういう方針でモジュールを分けるかはプロジェクトの方針やライブラリの方針でしょう
その方針に対してプログラミング言語によってはモジュール分けやファイル分けやディレクトリ分けに何らかの制限があって方針が引き摺られてしまうかどうかが重要なところでしょう
Rustはそこに制限はないから方針が言語によって引き摺られることはないでしょう
仮にどんなにファイルを分けたとしてもRustではそれとは関係なく外に対して見せずに済みますから外向けと内部構造は互いに自由度があります

>>988
外に対してどう見せるかと内部をどう分けるかを別々に決められるようになっているからその区別する意識を持たないと迷う人が出るかもしれませんね
0990デフォルトの名無しさん
垢版 |
2023/05/04(木) 13:05:47.30ID:Sq+gJjNT
>>986
Javaの1クラス/インターフェースで1ファイルという指針があれば自由度は低いけど考えなくて済むでしょ
Rustではstructの定義とimplをtraitの実装と同じモジュールに入れることもあればtraitを定義してるモジュールのほうにstructのtrait実装を含めることもある
そんなに自由だとどうしていいかわからないからもっとルール(ベストプラクティス)で縛って欲しいというのが最初の質問者の本音だと思うわけ
だとしたら君の返答は的外れじゃないかい?ってこと
0991デフォルトの名無しさん
垢版 |
2023/05/04(木) 13:23:02.85ID:JNVfsZ/B
何でそんなつまらんことで議論してるのか分からんC/C++ユーザの俺
0993デフォルトの名無しさん
垢版 |
2023/05/04(木) 13:42:19.29ID:JNVfsZ/B
モジュールの分け方なんてC/C++で完成されてると思うんだけども
後発の言語は何が便利になったのかね?
0994デフォルトの名無しさん
垢版 |
2023/05/04(木) 13:56:22.33ID:i7Oqolfe
Rustだと何かができなくて困る、ってことは何もない
Java方式でも他の方式でも何でも各自や所属先やプロジェクトの方針でやればいい
まともなプログラマーは標準ライブラリや有名クレートのソースを読むのでRustでの普通の流儀を分かっている
参考になるものが公開されているのに見ずに文句を言うバカは放置しとけ
0995デフォルトの名無しさん
垢版 |
2023/05/04(木) 14:17:24.34ID:VOb3FI4m
rustだけで見ていてはダメだな。
CとRustが混在するprojectを考えないと本当の用途は分からない
0996デフォルトの名無しさん
垢版 |
2023/05/04(木) 14:18:33.91ID:c9bfGq1+
リファレンス読む前に、概要を教わりたい派だから、ゆるい議論は役に立ってるよ
文句は言わないから
0997デフォルトの名無しさん
垢版 |
2023/05/04(木) 14:43:36.62ID:Rp6nFyYP
>>993
完成してんのにC++20でも変更するのかよw
0999デフォルトの名無しさん
垢版 |
2023/05/04(木) 14:48:32.70ID:K35qCUKZ
RustのmoduleはPythonと似てる
違うのは
Rustはmodule.rsと同じsubdirectory(./module)を造ってsubmodule.rsを入れる
module.rsにsubmoduleを描く人もいる
Pythonはsubdirectory(./module)を造って__init__.pyを描く
__init__.pyの中にsubmoduleを描く人もいるし./module/submodule.pyを描く人もいる
10011001
垢版 |
Over 1000Thread
このスレッドは1000を超えました。
新しいスレッドを立ててください。
life time: 32日 14時間 6分 22秒
10021002
垢版 |
Over 1000Thread
5ちゃんねるの運営はプレミアム会員の皆さまに支えられています。
運営にご協力お願いいたします。


───────────────────
《プレミアム会員の主な特典》
★ 5ちゃんねる専用ブラウザからの広告除去
★ 5ちゃんねるの過去ログを取得
★ 書き込み規制の緩和
───────────────────

会員登録には個人情報は一切必要ありません。
月300円から匿名でご購入いただけます。

▼ プレミアム会員登録はこちら ▼
https://premium.5ch.net/

▼ 浪人ログインはこちら ▼
https://login.5ch.net/login.php
レス数が1000を超えています。これ以上書き込みはできません。

ニューススポーツなんでも実況