5ちゃんねる⇒プログラム技術@5ch掲示板
設定
ダークモード
広告表示
画像・外部リンク

UPLIFT会員は外部リンクへ直接移動します。確認は初期設定でオンです。

機能のオン・オフ

このブラウザ・このサーバーのみ。オフにしても保存済みデータは残ります。

UPLIFT

1002コメント394KB

オブジェクト指向はオワコン? part3

レス数が1000を超えています。これ以上書き込みはできません。
垢版
返信 [1]
過去スレ
オブジェクト指向はオワコン (2023/08/26~)
https://mevius.5ch.io/test/read.cgi/tech/1721393540/
オブジェクト指向はオワコン? (2024/07/19~)
https://mevius.5ch.io/test/read.cgi/tech/1721393540/
オブジェクト指向はオワコン? part2 (2026/08/13~)
https://mevius.5ch.io/test/read.cgi/tech/1786599483/
垢版
返信 [1]
場のオブジェクト指向は考え中のものだから、破綻はしていない、むしろ、
今回のようなルールが無限に増える場合に対応するものとして構想している。
ルールに割れるだけはなく、含むが加わった。
しかも、どうやら指数すらも含まれるような感じ。
自然数を表現可能なすべての表記が入るのだろう。n進数も。
自然数限定だが表現論の問題になっている。
垢版
>>17
「含む」は10進数で表現した時すなわち文字列化した時に含まれるかどうかが今回の仕様だね
人間が扱う自然な仕様は10進数だけだろうけど
垢版
返信 [1]
>>9
ざっと縦読み目を通したけどmethoc chainで呼んだ場合の処理とカ書いてあって
結局、各方式ごとの関数なりmethodが要るってことになるし
昨日関数間でコードの共通化できるとことはあんまりない感じだな
垢版
返信 [5]
今回の件は全体が見やすいように3つの部分に分けるとプログラムはこれだけだね
type Count = fn(usize, usize) -> usize;
const DIV: Count = |t, n| (t % n == 0) as usize;
const IN: Count = |t, n| t.to_string().contains(&n.to_string()) as usize;
const DIV_OR_IN: Count = |t, n| (t % n == 0 || t.to_string().contains(&n.to_string())) as usize;
const DIV_AND_MULTI_IN: Count = |t, n| (t % n == 0) as usize + t.to_string().split(&n.to_string()).count() - 1;

type Rule<'a> = (Count, &'a[(usize, &'a str)]);
const CLASSIC: Rule = (DIV, &[(3, "Fizz"), (5, "Buzz")]);
const DIGITS: Rule = (IN, &[(3, "Fizz"), (5, "Buzz")]);
const BOOM: Rule = (DIV_OR_IN, &[(3, "Fizz"), (5, "Buzz"), (7, "Boom")]);
const WOOF: Rule = (DIV_AND_MULTI_IN, &[(3, "Fizz"), (5, "Buzz"), (7, "Woof")]);
const POP_WHACK: Rule = (DIV, &[(3, "Fizz"), (5, "Buzz"), (7, "Pop"), (11, "Whack")]);
const ZING_CHOP: Rule = (DIV, &[(3, "Fizz"), (5, "Buzz"), (7, "Pop"), (8, "Zing"), (11, "Whack"), (13, "Chop")]);

struct FizzBuzz<'a>(usize, Rule<'a>);
impl<'a> std::fmt::Display for FizzBuzz<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
let FizzBuzz(target, (count, list)) = self;
let mut is_done = false;
for &(number, name) in *list {
for _ in 0..count(*target, number) {
f.write_str(name)?;
is_done = true;
}
}
if !is_done {
write!(f, "{target}")?;
}
Ok(())
}
}
垢版
返信 [2]
>>20のプログラムの検証
他のプログラムが通してる事例を参考にしました

fn main() {
use itertools::Itertools;
assert_eq!((1..=15).map(|t| FizzBuzz(t, CLASSIC)).join(" "),
"1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz");
assert_eq!((1..=15).map(|t| FizzBuzz(t, DIGITS)).join(" "),
"1 2 Fizz 4 Buzz 6 7 8 9 10 11 12 Fizz 14 Buzz");
assert_eq!(FizzBuzz(35, DIGITS).to_string(), "FizzBuzz");
assert_eq!((1..=15).map(|t| FizzBuzz(t, BOOM)).join(" "),
"1 2 Fizz 4 Buzz Fizz Boom 8 Fizz Buzz 11 Fizz Fizz Boom FizzBuzz");
assert_eq!(FizzBuzz(7539, BOOM).to_string(), "FizzBuzzBoom");
assert_eq!((1..=15).map(|t| FizzBuzz(t, WOOF)).join(" "),
"1 2 FizzFizz 4 BuzzBuzz Fizz WoofWoof 8 Fizz Buzz 11 Fizz Fizz Woof FizzBuzzBuzz");
assert_eq!(FizzBuzz(35, WOOF).to_string(), "FizzBuzzBuzzWoof");
assert_eq!(FizzBuzz(303, WOOF).to_string(), "FizzFizzFizz");
assert_eq!((1..=15).map(|t| FizzBuzz(t, POP_WHACK)).join(" "),
"1 2 Fizz 4 Buzz Fizz Pop 8 Fizz Buzz Whack Fizz 13 Pop FizzBuzz");
assert_eq!(FizzBuzz(1155, POP_WHACK).to_string(), "FizzBuzzPopWhack");
assert_eq!((1..=15).map(|t| FizzBuzz(t, ZING_CHOP)).join(" "),
"1 2 Fizz 4 Buzz Fizz Pop Zing Fizz Buzz Whack Fizz Chop Pop FizzBuzz");
assert_eq!(FizzBuzz(120120, ZING_CHOP).to_string(), "FizzBuzzPopZingWhackChop");
}
垢版
なぜかIDが変わってるけど
>>20の検証部分が>>21ね
垢版
>>19
それは仕様を言葉で説明すると曖昧になりやすいからの理由でしょう
その通りのまま実装してる人は誰もいないから大丈夫だよ
垢版
返信 [1]
結局ルール辞書作ってぶん回すだけ
垢版
>>24
ルール辞書の作り方や構造が難問
様々な問題に対して自動的に汎化させることは難しい
垢版
返信 [1]
>>9 ocaml
https://ideone.com/iRLbSx
・>>6から若干の改善
・判定につかってたcontains,countの実装が簡易的だったので整数比較版に差し替え
・結果のリストに対するinspect関数つくっといた
 to_s関数を`List xsに対応させてみたりしたけどなんか使い勝手が悪かったのでこっちにした
垢版
もしやこのコードは

>>26
let count m n =
let m, n = abs m, abs n in
let d = if n = 0 then 10 else int_of_float (10. ** (1.0 +. (floor (log10 (float_of_int n))))) in
let rec aux acc = function
0 -> acc
| m -> aux (if m mod d = n then acc + 1 else acc) (m / 10)
in if m = n then 1 else aux 0 m
let contains m n = 0 < count m n
垢版
返信 [2]
今のところ前スレ>>938が一番まともやな
変換辞書と変換ロジックのセットとして扱ってればなお良かった

にしても不必要なcount変数やflag変数を導入するやつとか
ToString()にドメインロジックを全部突っ込むやつとか
おかしなやつが多いな
垢版
938を見たら145行もあった
動作確認printしてるmain関数8行を除いても130行以上ある
垢版
行数が多いとその分稼げるから
垢版
返信 [1]
>>28
これは文字列化する課題だよね
みんなが文字列化の関数にドメインロジックを書いているのは当たり前だと思いますが
垢版
返信 [1]
>>20
これはRust? OCamlかと思った
垢版
>>31
神クラスならぬ神toStringか
垢版
>>28
その938もToStringする関数にメインロジックを書いてるけど938をお気に入りな理由は何?
垢版
文字列にする関数とドメインロジックを分けることがそもそも可能なのかね?
垢版
返信 [1]
javaのtoString()はデバッガでも表示に使用されるため、
オブジェクトの区別がつけられるユニークな内容のみで使用するのが望ましい。
できればデバッグ用以外には使用しない。
デバッグで必要となるため、
すべてのオブジェクトは、toString()でオブジェクトの文字列表現を正しく返すように実装すべき。
垢版
唐突に何だろ
そんなレベルの問題を起こしてるコードはこのスレで見たことない
垢版
extends is evilの潜在的バグはtoString()用法の間違いが一番多いので。
垢版
それは文字列化とデバッグ用を混乱しているJavaの問題
オブジェクト指向プログラミングとは無関係
垢版
いつもJavaの仕様や方針が足を引っ張ってるような
垢版
javaは単純化しようとしてかえって初心者には扱えないものになってしまった。
toString()の例は、オブジェクト指向(設計)の例で、
設計や、実装の段階では、指示しているオブジェクトが正しいつもりでも、
実際に実行してみると、想定とは異なったオブジェクトにメッセージを投げていたりする。
相手だけではなく、自分自身も設計・実装時に想定していた自分(this)とは違う自分(this)
になっていたりする。
手続き型の現物プログラミングやスクリプト言語ばかりやっていたりすると、
オブジェクト指向の抽象プログラミングでバグる。
設計が正しくても、実装する側が手続き型しか使ったことがなかったりすると、確実にバグが発生する。
垢版
「オブジェクト指向の抽象プログラミング」
「確実にバグが発生する」
垢版
「Javaによく慣れて精通していないと嵌る落とし穴のある言語だ」
くらいに抽象化して言えないのかな
垢版
よく慣れて精通していないと嵌る落とし穴満載の言語で最たるものはC++が王様だな
いや、たとえ精通していても…
垢版
特に何も抽象化していないいのに抽象化という言葉を使うのはやめましょうよ
ものすごい違和感というかもはや不快感を覚える
垢版
オブジェクト指向(設計)とは抽象化ですよ。
オブジェクト指向言語は抽象化言語。
オブジェクトやメッセージに抽象化することで状態や実装を隠ぺいする手法なのです。
垢版
javaは単純化したのが命取りのようではあるが、
手続き型中心のオールドプログラマを攪乱し、リバースエンジニアリングさせない効果はある。
垢版
parseIntが面倒糞かった
垢版
返信 [2]
どちらかというと、手続型(命令型)と関数型(宣言型)が対立的な概念で、オブジェクト指向は手続型の範疇というイメージかな。もっとも、関数型(宣言型)の良いところを部分的にではあれ取り入れようという動きは顕著よね。
手続型(命令型)の書き方をベースに書くときに、どの程度オブジェクト指向的な書き方をするかと、どの程度関数型的な考え方を取り入れるかはそれぞれ独立のことだと思う。
垢版
返信 [1]
>>49
その二つも差はなくね?
関数を入れ子にして手続き書いていくとか
メソッド関数を数珠繋ぎにして手続き書いていくとか
見かけは宣言型でも手続き型と何が違うの?
垢版
返信 [1]
オブジェクト=タスクマシン
他のプログラムに干渉されずに独立してプログラムを実行できる仕組み、ならいいんだが

delay()使っても止まってるのはそこだけで、他を止めない
垢版
返信 [1]
>>51
それは非同期並行タスクとしてそれを持つ各言語で実現されてる
垢版
>>52
で、1000以上のキャラの弾幕ゲームを作れるかね?
全部のキャラを独立したオブジェクトでさ
垢版
>>50
関数型の考え方を取り入れるというので想定していたのは、純粋でない関数はできるだけ減らすとか、高階関数を活用するとかの素朴な考え方だけど、これらはオブジェクト指向の直接的な関心事ではないでしょう。オブジェクト指向でも取り入れることはできるけど。
いわゆるメソッドチェーンは、それ自体としては宣言的になる場合もあれば、命令的になる場合もあるんじゃないかな。
垢版
宣言的な度合いに相対的な高低差があるというだけ
垢版
何か抽象的なような煙に巻くような言い方だなw
垢版
>>46-47 こういう人が未だに居るんだな…
残り少ない生き残りというか残党みたいな信奉者(やや狂信的傾向)
最後まで城を守る!あるいは船と沈む!みたいな
垢版
他の言語やパラダイムも勉強して視野広げたほうが良いと思うの
それから、客観的にものを見られるようになったり、合理的に考えたりする力の訓練もね
垢版
まあ、どうのこうのといっても、手続き型言語も抽象化されたものだし、
CPUやGPUなども抽象化されたものだし、
その意味では、最初からオブジェクト指向で設計されているともいえる。
数学的な理論づけとしては圏論も欠かせない。
が、これから重要なのは情報理論。それはエネルギー論でもあり、場の量子論でもある、ということ。
垢版
場のおじさんだったかw
垢版
CPUやGPUは尤も生々しい具現だチューにw
あんた、場だの論だの抽象だの既存の権威付けられた言葉の印象に憧れてるか酔ってるだけでは?
垢版
返信 [1]
>>9 java
https://ideone.com/DCrHR4
・Woofの303がFizzFizzFizz版
・countは正規表現つかって実装
・clone, list(b, e)メソッド追加

>>9 ruby
https://ideone.com/1G57lm
・Woofの303がFizzFizzFizz版
・countは正規表現つかって実装
垢版
勉強不足ですなー。CPU/GPUは抽象計算機を物理的に実装したものですよ。
計算モデルに従います。
垢版
返信 [1]
CPU/GPUもやっぱり場の理論によって動作しているのですか?
垢版
場の理論といえばやっぱりランダウのバコテン(場の古典論)、QEDはFeynmanが懐かしい
垢版
論的量子力学・QFDはBjorken Drell、QCDはFeynman
垢版
オブジェクト指向はオワコン?

んなこたーない
垢版
返信 [1]
>>64
ま、量子世界にいるわけですから、いまのところ場の量子論で動作しているということでも
いいわけですが、量子レベルの現象を直接扱っているわけではないと。
現在の計算モデルは、何世代目かの宇宙における構造(カラビヤウ多様体)に起因していると考えております。
垢版
オブジェクトンとオブジェクティーノの対称性
垢版
>>32
その通りRustだよ

>>36
Rustは3つのインターフェースに分かれてるよ
trait Debug デバック表示用の文字列化
trait Display 通常の文字列化
trait ToString 通常の文字列化+文字列型Stringに格納するためのメモリ確保

文字列型へのToStringはこのように非常に重い処理なので分離されてる
表示や既存文字列への追記は中間生成Stringを作ると無駄だからね
プログラマはDisplayを実装すればToStringは自動実装されるよ

Debugはそれらと独立のもので自分でも実装していいけど
各型の宣言に #[derive(Debug)] を修飾すると機械的に自動実装してくれる
垢版
返信 [1]
FizzBuzzへのtrait Displayの実装例が >>20
コストの高いメモリ確保処理は分離されて純粋な文字列化処理のみになってるよ
Rustはこれが標準で数値などのプリミティブ型も全てtrait Displayを実装

こうすることで何がメリットかというと
例えば >>21 のこの処理

 「1から15までのBizzFizzの結果をスペースで繋げて1つの文字列にするコード」
 (1..=15).map(|t| FizzBuzz(t, CLASSIC)).join(" ")

よくある15個のStringを生成してそれらを繋げて1つのStringを作るのと比べて
join()はtrait Display実装型を受け付けるため一気に1つのStringのみ作ります
15個の中間生成Stringのメモリ確保と生成を省くことができてます
これはjoin()に限らずprint!系なども同様です
垢版
自然数の文字化だけだとユニークで一対一なのでフェルミだ。
これを3の倍数とか5の倍数とかで文字化すると、そこは複数の値が同じ文字になるのでボゾンだ。
量子統計が異なる。
で、フェルミが積で、ボゾンが和だ。場の量子論から、そうなる。(かなりすっ飛ばした結論笑)
区別がつくものは積であらわされ、区別がつかないものは和であらわされる。
積と和がハイブリッドしたもの...それはアレだ!(ホントかどうか調査中)
垢版
返信 [2]
>>71
実に醜いし
CPUがやってる作業も壮大な無駄と遠回りだろう

普通にシンプルな手続き型でやりゃいいことを、無駄にオブジェクト指向で作る意味はない
垢版
返信 [2]
>>73
オブジェクト指向だから実現できてるんじゃね?
使わないと無理っぽい
垢版
返信 [1]
手続き型で普通のシンプルな条件処理で済むじゃん
垢版
>>75
見たい
コード書いてみて
垢版
BizzFizzの話題になった初期に出てるじゃん
垢版
>>73
オブジェクト指向によってその無駄なCPUの作業を減らしている好例だよ
「文字列型への変換」という格納メモリ確保を伴う重い作業から
「純粋に文字列への変換のみ」を別のインターフェースとして切り出している
そうすることで無駄な一時的な文字列型の生成を防ぐことができているよ
垢版
>>74
「何が」オブジェクト指向だから実現できてるの?
垢版
返信 [1]
オブジェクト指向によって
全ての型に対して「(メモリ確保を伴わない)純粋な文字列化変換」という共通インターフェース(trait Display)を設けて各型がそれを実装しています
それを用いて「(メモリ確保を伴う)文字列型への変換」という共通インターフェース(trait ToString)が全ての型に自動実装されます
この両者の分離により無駄なCPU処理と無駄な一時メモリ確保を防いでいます
垢版
>>80は>>74と同一人物なのかな?
垢版
一般的にオブジェクト指向を使わないとインターフェイス抽象型による共通の扱いができないから各々の型でバラバラにやることになって破綻だよな
垢版
複数の異なる型を同じメソッドで呼び出しできる
これがオブジェクト指向の最大の利点だ
垢版
多相性は型システムの問題のような気もするけど。
垢版
単なる多相性だと型を横断しての共通呼び出しが保証されない
垢版
>>49
無駄なこだわり主張して現場を困らせるやつの典型例だな
垢版
返信 [1]
手続き型が小汚いので、各オブジェクト指向系言語は工夫しているが、
ダメなものはダメで、さらに小汚いものが書かれて、それをオブジェクト指向のせいにしている。
Why extends is evil が、その典型的な例で、最後にはなにも解決せず、さらに悪化させたまま
終わっている。そこには絶望しか残っていない。
手続き型でも、キレイにかけるやつはかけるのだが...残念なプログラマが多い。
プログラムは文学的/文芸的であるが、叙述ミステリーであっては困る。
垢版
返信 [1]
>>9 java
https://ideone.com/C9Cmel
・Woofの303がFizzFizzFizz版
・OOPらしく(?)継承でなんとかするやつ
・委譲でなんとかするやつは>>62

>>9 octave
https://ideone.com/MXBicD
・Woofの303がFizzFizzFizz版
・Java版のRuby移植のOCaml移植のOctave移植
・ほかの言語のクセが混入しちゃってOctaveらしくないかも
垢版
返信 [3]
use v5.36; use utf8;

my %h = ( 3=>'Fizz', 5=>'Buzz', 7=>'Boom/Woof/Pop', 8=>'Zing', 11=>'Whack', 13=>'Chop' );

sub 割り切れる($n, $d){ 0 == $n % $d }
sub 桁に含む個数($n, $d){ scalar (() = $n =~ /$_/g) } # $n =~ tr/$d//r

sub 割り切れれば変換($n, @s){ join '', map{ $h{$_} if 割り切れる($n, $_) } @s }
sub 桁に含むなら変換($n, @s){ join '', map{ $h{$_} if 0 < 桁に含む個数($n, $_) } @s }

sub Classic{ map{ 割り切れれば変換($_, 3, 5) or $_ } @_ };
sub Digits{ map{ 桁に含むなら変換($_, 3, 5) or $_ } @_ };
sub Boom{ $h{7} = 'Boom'; map{ my $n = $_;
     join('', map {$h{$_} if 割り切れる($n, $_) or 0 < 桁に含む個数($n, $_)} 3,5,7) or $n} @_ };
sub Woof{ $h{7} = 'Woof'; map{ my $n = $_;
     join('', map {割り切れる($n, $_) and $h{$_} . $h{$_} x 桁に含む個数($n, $_)} 3,5,7) or $n} @_ };
sub Pop_Whack{ $h{7} = 'Pop'; map{ 割り切れれば変換($_, 3,5,7,11) or $_ } @_ };
sub Pop_Whack_Zing_Chop{ $h{7} = 'Pop'; map{ 割り切れれば変換($_, 3,5,7,11,13) or $_ } @_ };

# test main
do { my ($func, @args) = @$_;
   say "@{[$func->(@args)]}" }
 for [\&Classic, 1...15], [\&Digits , 1...15, 35], [\&Boom , 1...15, 7539], [\&Woof , 1...15, 35, 303],
 [\&Pop_Whack, 1...15, 1155], [\&Pop_Whack_Zing_Chop, 1...15, 120120];


※closureや関数の部分適用などOOPSやFunctional的な仕組みを使ってみようかと思ったけど、使うまでもなかった
垢版
返信 [3]
実行結果

~ $ perl FizzBuzz_variations-26830.pl
1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz
1 2 Fizz 4 Buzz 6 7 8 9 10 11 12 Fizz 14 Buzz FizzBuzz
1 2 Fizz 4 Buzz Fizz Boom 8 Fizz Buzz 11 Fizz Fizz Boom FizzBuzz FizzBuzzBoom
1 2 FizzFizz 4 BuzzBuzz Fizz WoofWoof 8 Fizz Buzz 11 Fizz 13 Woof FizzBuzzBuzz BuzzBuzzWoof FizzFizzFizz
1 2 Fizz 4 Buzz Fizz Pop 8 Fizz Buzz Whack Fizz 13 Pop FizzBuzz FizzBuzzPopWhack
1 2 Fizz 4 Buzz Fizz Pop 8 Fizz Buzz Whack Fizz Chop Pop FizzBuzz FizzBuzzPopWhackChop
垢版
返信 [1]
おー、octaveって初めて見た。
垢版
返信 [1]
>>90
むむ、4番目と6番目の結果が違う

4番目
1 2 FizzFizz 4 BuzzBuzz Fizz WoofWoof 8 Fizz Buzz 11 Fizz Fizz Woof FizzBuzzBuzz

6番目
1 2 Fizz 4 Buzz Fizz Pop Zing Fizz Buzz Whack Fizz Chop Pop FizzBuzz
垢版
返信 [1]
>>87
俺のオブジェクト指向を見てくれ、こいつをどう思う?
https://paiza.io/projects/74r7Bk2gDxB1PllUsjS1vQ
垢版
返信 [1]
>>93
失格
皆が検証しているwoofの303やchopの120120を求めることすらできないプログラムになっている
垢版
返信 [1]
>>92
90 の 4,6行目と 93の 4,6行目は合っているように見える

オレの目が疲れている?
垢版
>>94
余裕でした、なぜならオブジェクト指向だから
https://paiza.io/projects/JoOYtyQ9TMC-CV0n_HWDuA
垢版
返信 [1]
>>95

4行目
1 2 FizzFizz 4 BuzzBuzz Fizz WoofWoof 8 Fizz Buzz 11 Fizz 13 Woof FizzBuzzBuzz
1 2 FizzFizz 4 BuzzBuzz Fizz WoofWoof 8 Fizz Buzz 11 Fizz Fizz Woof FizzBuzzBuzz

6行目
1 2 Fizz 4 Buzz Fizz Pop 8 Fizz Buzz Whack Fizz Chop Pop FizzBuzz
1 2 Fizz 4 Buzz Fizz Pop Zing Fizz Buzz Whack Fizz Chop Pop FizzBuzz
垢版
返信 [1]
FizzBuzzのプログラムを書いてみるとデータと操作は分けた方がいんじゃないかという思いが強まるよな
なんでもかんでもオブジェクトにするのが旧オブジェクト指向だとすると
データ構造や言語機能の補間のためにオブジェクトを作るのが新オブジェクト指向なのかもしれない
垢版
>>91
octaveに三項演算子があるか
ifが式で値を返せるようになってたらなあ

x = {b m}(1 + isempty(b)); ←こんなこと書きたくはなくて
x = isempty(b) ? m : b; ←こう書けたり
x = if isempty(b) then m else b; ←こう書けたらなあ!
x = ifelse(isempty(b), m, b); ←こうは書けるみたいだけど欲しいものとはまた違うし

それ以外は良い言語だお( ^ω^)
いっしょに行列グリグリしようず
垢版
>>98
行きつくところはFizzBuzz拡張DSL

Haskell等でeDSLか
他言語でインタープリタかJIT
垢版
>>97
指摘ありがとう。

>>90の4行目で13がFizzにならず13がそのまま出力されていたのは、演算子優先順位の影響を見落とたbugだった。
>>89の16行目sub Woof{ 内式を ()でくくって明示しFix
     join('', map {割り切れる($n, $_) and $h{$_} . $h{$_} x 桁に含む個数($n, $_)} 3,5,7) or $n} @_ };
             ↓                 ↓
     join('', map {(割り切れる($n, $_) and $h{$_}) . $h{$_} x 桁に含む個数($n, $_)} 3,5,7) or $n} @_ };

6行目で8がZingにならなかったのは、sub Pop_Whack_Zing_Chop で8を変換対象として「割り切れれば変換()」
の引数に指定漏れていた。8を追加しfix
>>89の18行目sub Pop_Whack_Zing_Chop{ 内修正
sub Pop_Whack_Zing_Chop{ $h{7} = 'Pop'; map{ 割り切れれば変換($_, 3,5,7,11,13) or $_ } @_ };
                                               ↓
sub Pop_Whack_Zing_Chop{ $h{7} = 'Pop'; map{ 割り切れれば変換($_, 3,5,7,8,11,13) or $_ } @_ };
垢版
>>68
ウィック回転することでFizzBuzzの時間の流れから時間を消し去ることが可能
垢版
返信 [2]
>>90
スマソ、もう一個軽微なBugあった。

6行目
sub 桁に含む個数($n, $d){ scalar (() = $n =~ /$_/g) } # $n =~ tr/$d//r
                             ↓$_を $d に修正
sub 桁に含む個数($n, $d){ scalar (() = $n =~ /$d/g) } # $n =~ tr/$d//r

ただ、このBug $_でも解は合うんだよね。
上位関数から呼び出すとき、第二引数に $_ を渡すため、下位関数で引数 $d のかわりに $_ を参照してもたまたま動いちゃってたというだけ。
垢版
>>103
アンカー間違えた orz
>>89 のソースの修正ね
垢版
>>103
それ13などの二桁以上の数字に対応できる?
垢版
返信 [1]
「各桁に含まれる数字か」というルールについては、元のルール(>>9)自体が、2桁以上の数字を想定してないと思うよ。11とか13を基準の数字とするpopwhackとzingchopは「割り切れるか」の方のみを判定条件にしているし。
仮に2桁以上の数字についても「含まれるか」ルールでの判定をするのであれば、たとえば111に11が含まれる回数を1回と考えるのか、2回と考えるのか決めておく必要があると思う。
垢版
よくある常識的なルール
消費した分を再び使うことはできないものとする
によって曖昧性を排除できるかと
垢版
>>106
決めればいいじゃないw
その場合は2回だな
垢版
重複していても異なるなら数えることならば3030303030に303は4つ?
垢版
正規表現で数えましょ
垢版
決めなくて良くないか?オブジェクト指向と関係あるとは思えない
垢版
2桁以上の数字の「含まれる」基準の解釈を、オーバーラップ許容型(部分文字列として含めばすべてカウントする)かオーバーラップ非許容型(消費した部分文字列は再利用不可とする)かのどちらかに決めてそのとおりに実装するというのは別に難しいことではないだろうけど、拡張FizzBuzzルールとしてはどちらでもいい枝葉末節の話だからね。前スレの942(Woofルールは303をFizzFizzFizzに変換するのではないか)のような本質的な指摘とは異なる。
2桁以上の数字の「含まれる」基準の判定にも対応するべきだ、その際の基準はオーバーラップ許容型(あるいはオーバーラップ非許容型)であるべきだという主張をすること自体は別に否定しないけど、元の要求仕様(>>9)に含まれている内容ではないから、個人的にはどうでもいい話だと思う。やりたい人がやればいいのでは。
垢版
返信 [2]
口達者やなー
垢版
返信 [3]
元々の話は想定される仕様拡張にオブジェクト指向プログラミングなら対応できるのか?で始まったのがFizzBuzz拡張
だから今回の仕様拡張『2桁以上の数字が含まれる場合』が『その含まれるがオーバーラップを許す場合と許さない場合それぞれを実装』にも対応できるか試されるところ
対応できなければ失格だろう
垢版
返信 [1]
エクセルの表でスマートに作れる
垢版
>>114
ほお、ではお前が対応できるか見てやろう、やってみろ
垢版
返信 [1]
>>113
お前もだ、お前もやれ
垢版
俺がオブジェクト指向審査委員長をやる
垢版
逃げるなよ
垢版
返信 [1]
>>115
もしそんなことができるならエクセルはオブジェクト指向
垢版
>>113
>>114
期限は3時間な、今日の14時までに出来なかったらお前らにこのスレ一番の無能の烙印を押したうえでオブジェクト指向審査失格の判定をくだすからせいぜい頑張れよ
垢版
俺はどっちも逃げるに1票入れとくわw
垢版
返信 [2]
たとえば、Pythonならstr.countを使えばオーバーラップ非許容版になるし、オーバーラップ許容版は先読みアサーションでできる。他の言語でも実装は同様に簡単だろうし、どうでもいい話だと思うよ。

print('111'.count('11')) #->1
print('3030303030'.count('303')) #->2

import re
print(len(matches := re.findall(r'(?=11)', '111'))) #->2
print(len(matches := re.findall(r'(?=303)', '3030303030'))) #->4
垢版
せやな
あとは >>114 の問題だな
>>114 が言い出したオブジェクト指向を自分でやり遂げられるのか
それを最後まで見届けよう
垢版
返信 [2]
the digits contained by a given number
repeated as many times as the condition is true
という原文を考慮するとWoofに
{11: "Whack”, 13: “Chop”}}を追加すれば
111は"FizzWhackWhack”
313は"FizzFizzChop”と解釈するのが普通かな

replaceに重きを置いてdigitは消費ルールにするんなら
111は"FizzWhack”
313は"FizzFizz”

どっちもありだけど
replaceするワードごとに消費リセットするのは
実装から逆算したご都合主義的なルールなので無しだな
垢版
返信 [1]
>>125
よしわかったお前もエントリーな
14時までに書けよ
垢版
返信 [1]
>>126
いや、仕事しろよ
垢版
返信 [1]
>>123
FizzBuzzで正規表現を持ち出すのは大袈裟すぎ
正規表現は禁止で
垢版
返信 [1]
X.comはクリーンアーキテクチャゴミ過ぎるって話題で盛り上がってるな、クリーンアーキテクチャこそオブジェクト指向の負の遺産だよな
垢版
>>128
縛りプレイか
お前はそれでやれ
14時までだぞ
垢版
113, 114, 125, 128
こいつらが14時までにできるのかご注目
垢版
>>125
123のオーバーラップ非許容版(一度消費すると再利用不可版)はたしかに基準となる数字ごとに消費をリセットしているけど、別にそれが実装上のご都合主義とは思わないけどね。仮にこれを良しとしないなら、基準となる数字同士の間に包含関係がある場合にどう変換するかも仕様として定めておく必要がある。たとえば、2 -> hoge, 22 -> puge みたいな変換ルールが与えられたときに222をどう変換すべきかみたいな話ね。>>123のオーバーラップ非許容版ならhogehogehogepugeとなるのに対し、消費をリセットしない仕様ならhogehogehogeかpugehogeみたいな感じになるんだろうけど、いずれにせよどちらの仕様にしたいかというだけの話だと思うけど。

仕様を決めればそのとおりに実装することはどうとでもなるだろうけど、こういう枝葉末節の仕様を細かく決めていくこと自体にはそんなに意味がないんじゃないかなとは思う。
垢版
>>127
仕事とオブジェクト指向どっちが大事なんだ!
垢版
返信 [1]
>>20 を対応

これらは非オーバーラップ版としてそのまま動作

>> const IN: Count = |t, n| t.to_string().contains(&n.to_string()) as usize;
>> const DIV_OR_IN: Count = |t, n| (t % n == 0 || t.to_string().contains(&n.to_string())) as usize;
>> const DIV_AND_MULTI_IN: Count = |t, n| (t % n == 0) as usize + t.to_string().split(&n.to_string()).count() - 1;

オーバーラップ版は新設

const DIV_AND_MULTI_IN_OVERLAP: Count = |t, n| (t % n == 0) as usize + overlap_count(t, n);

fn overlap_count(haystack: usize, needle: usize) -> usize {
let haystack = haystack.to_string().into_bytes();
let needle = needle.to_string().into_bytes();
haystack.windows(needle.len()).filter(|&target| target == needle).count()
}
垢版
返信 [1]
>>129
抽出化を入れまくったりしてクリーンアーキテクチャの実装様式をゴミにする開発担当が悪いのであって
依存方向を制限するという原則自体には依然として価値があるぞ
垢版
返信 [1]
>>117
オレ89の作者なんだけれども…
垢版
返信 [2]
>>135
ドメインロジック部分から周辺入出力まで各階層を分けるのはどのモデルでもだいたい同じで
あとは依存性逆転の原則を守ればいいだけだよね
つまり双方がインターフェースのみに依存せよが正しいオブジェクト指向プログラミング
垢版
>>89の6行目のまま複数桁に対応すんじゃねーかな
パターンじゃなくて特定の文字へのgマッチだから
確認・検証、略

こう見えてもオジサン忙しいんだよ
垢版
なお、6行目の些末なbugはこう直してね、その方がお行儀がいいから
sub 桁に含む個数($n, $d){ scalar (() = $n =~ /$_/g) } # $n =~ tr/$d//r
                             ↓$_を $d に修正
sub 桁に含む個数($n, $d){ scalar (() = $n =~ /$d/g) }
垢版
>>136
なんかすみません…
垢版
>>134
Rustはええよなー標準ライブラリがつおい
垢版
>>137
だったらその正しいオブジェクト指向プログラミングとやらでFizzBuzz書いてみろよタワケが
垢版
返信 [1]
>>120
エクセルの表はセル内の数式で勝手に演算するからなぁ
誰もどこからもプログラムで指令なんかしない

つまりオブジェクト指向ってのはツールで実現できるから、言語で実装しようとするから汚くなる
垢版
>>143
せやかて工藤、プログラム言語でFizzBuzzを計算できる人たたくさんいるけどExcelでFizzBuzzを計算できた人はいまのところお前も含めて一人もおらんぞ、ちゅうことはやExcelの方が不便なんじゃねえのかな
垢版
返信 [1]
は?
エクセルの列に3の倍数、5の倍数とか作れば終わるじゃん

で、列を統合すりゃ完成よ
垢版
>>145
FizzBuzz各バリエーションはどうするの?
垢版
返信 [1]
>>9 java
https://ideone.com/YO6IJy
・class FizzBuzz廃止

>>9 ruby
https://ideone.com/oNWERQ
・class FizzBuzz廃止

>>9 octave
https://ideone.com/aqe5by
・関数の呼び出し関係を↑のJavaやRubyと同じに変更
・fizzbuzz関数が結果を返していたのが>>88
・fizzbuzz関数がクロージャを返すのがこれ
垢版
返信 [1]
エクセルニキ完全沈黙
垢版
返信 [1]
>>137
>インターフェースのみに依存せよ
別にオブジェクト指向じゃなくても普通のプログラミングの原則やろ
垢版
返信 [1]
>>148
エクセルニキじゃないけど出来ないと思うのが逆に不思議
Excel苦手?
垢版
エクセル苦手っていうか表計算の仕組みを全く理解していないんだろうな
垢版
>>150
俺には無理、イキリ散らしているお前でさえ出来てない、いまのところExcelで出来た人は0人
いまの状況でExcelでできるというのが逆に不思議、何の根拠もない
垢版
> 115 デフォルトの名無しさん 垢版 | 2026/08/31(月) 10:37:57.07ID:Jy5vPfka
> エクセルの表でスマートに作れる

はよ作ってみせろや、スマートになw
垢版
返信 [1]
本当に馬鹿なんだねぇ
垢版
>>154
まだ出来ないのか?w
垢版
おいおいまだ出来てないんだってよこいつw
いつまでかかってんだよ、さっさとやれよ
垢版
できるんだよね〜Excelならスマートにできるんだよね〜お〜ん?www
垢版
またお前か
垢版
A列に1からnまでの連番を作って、B列に変換関数を書いて、C列に結果を出力するみたいな感じ? それでできたことになるのかは、自分にはちょっとよく判断がつかないが。今のExcelってLetとかが入ったから、理論的には他のプログラミング言語と同等の記述能力があるんでしょ。だから変換関数自体はいちおう書けるんじゃないかと思うけど(見やすいかどうかはともかく)。
垢版
返信 [1]
A列に
1
2
3
…
=一個上-1

と入力しておいて、B列に式

=IF(AND(MOD(A1,3)=0,MOD(A1,5)=0),"FizzBuzz",IF(MOD(A1,3)=0,"Fizz",IF(MOD(A1,5)=0,"Buzz","")))

を縦ににずっと設定していけばできるだろJK

これはCLassicで、多少ややっこしくなるけれど他のvariationも頑張れば同様に
VBA等を使うまでもなく式でもできるさ

variationは多少煩わしのでオレはいいや気が乗らん
垢版
>>160
=一個上-1
↓
=一個上+1

な。
垢版
返信 [2]
B列は3の倍数
C列は5の倍数・・・でいいんだよ

あとはVBAで必要な数与えりゃ、必要分の行をコピーで増やせば出来上がり

行がオブジェクトでもあり、列がオブジェクトでもあり、セルがオブジェクトでもある
ループも使わず結果が出る
垢版
返信 [2]
>>9のFizzBuzzバリエーションwoofも書ける?
垢版
>>163 またせた、っ >>162
垢版
返信 [1]
各列にルールごとの変換結果を持っておいて、それを適宜組み合わせるという発想は、「最初からテーブルで全部持っておく」おじさんの理想にかなり近いのでは。
垢版
=LET(Ary,A1#,Res,
IF(MOD(Ary,3)=0,"Fizz","")
&IF(NOT(ISERROR(FIND(Ary,"3"))),"Fizz","")
&IF(MOD(Ary,5)=0,"Buzz","")
&IF(NOT(ISERROR(FIND(Ary,"5"))),"Buzz","")
&IF(MOD(Ary,7)=0,"Woof","")
&IF(NOT(ISERROR(FIND(Ary,"7"))),"Woof",""),
IF(Res="",Ary,Res)

A1にスピル配列で
なんでExcelでFizzBuzzができるかという話になってるのかは分からないけど、条件増えてもこれで配列渡しでもイケると思う
垢版
FINDの引数を入れ替えるミス
お恥ずかしい
垢版
>>163は相当頭悪そう

何のための列だよ
自由自在
垢版
返信 [1]
>>165
エクセルのいいところは、最初っから何個使うかわからんテーブル形式ではなく
必要な分を行追加コピーで済むことだ
全部数式込みで増やせて、増やした瞬間に計算終わっちゃうから必要最小限のテーブルしか作らない
垢版
返信 [1]
>>9 の全バリエーションに対応してから言えよ
何が自由自在だよ、自縄自縛の間違いだろw
垢版
返信 [1]
頭悪いのって不幸だねぇ
垢版
返信 [1]
>>170
そんなんExcelでガムばらなくてもいいんじゃない?
垢版
>>169
それはまた同時にExcelの欠点でもある二面性じゃない?
垢版
>>171
>>9 の全バリエーションにはいつ対応できるんだ? お〜ん? お〜ん? お〜〜〜ん???
垢版
>>172
それが正しい、Excelでやるよりプログラム言語で計算した方が100倍マシ
垢版
Excelのセルを縦横無尽に参照した式瀬ッての多様やVBAマクロは難読があっという間に��くなりきわめてたちが悪いからな。
賢い人ならなぜ問題か知っていること
だからそこで頑張ってもしょうがない
垢版
> 115 デフォルトの名無しさん 垢版 | 2026/08/31(月) 10:37:57.07ID:Jy5vPfka
> エクセルの表でスマートに作れる

あれあれ〜〜〜??? まだですか〜〜〜???
まだできないんですか〜〜〜??? お〜〜〜ん???
垢版
返信 [2]
頭悪そう
エクセルの難読なのがあったとして
それと同じ機能をプログラム言語で記述したらさらに難読でしかないって理解できないのだねぇ
垢版
>>162
問題を矮小化して解決した気になってるんじゃねえよwwwww
>>9 を解け >>9 が問題なんだよ、問題が何なのかも理解してないのかエクセル大先生はよwwwww
垢版
>>178
ほうほう、お前はよほど頭が良いようだな
>>9 をプログラム言語で計算するよりもエクセルで簡単にできるんだな
よしわかった、じゃあやってみろ、お前が言うことが本当だとするならできるはずだよな
できなかったらお前は大嘘つきだ
垢版
>>178
おまえ、苦しんだことないな、
いや野良ExcelやVBA作り散らかして周りに迷惑かけているタイプだろ

セルはすべてグローバル変数と同じ。それば無数にある

それを他のセルに設定されている「露わには目に見えない」式の中であちこちから参照する
そしてその式の値が反映されているセルがまたどこかの式が参照する…このくりかえし

プログラミング言語の発展はそういった複雑さの爆発や難読性をどう抑制し
なんとか大規模ソフトウエアを作れるようするかの戦いでもあったんだぞ

お前はグローバル変数ばかりでプログラム書くのか?
人のことバカにしたような口きいてるが
何ひとつ知らないのはお前の方だ恥ずかしいやつめ
垢版
で、オブジェクト指向教はその抑制の役には
あまりたたなかったんだよな
垢版
返信 [1]
Excelの話はもういいよ。

Excelの話題になると、ちょっと式設定やVBAを使えるようになっただけで天狗になっている井の中の蛙が
変な時論や蘊蓄で周りも攻撃しちらかしたりして雰囲気悪くするから相手にしない方が良いよ。

変てこなオレオレ オブジェクト指向信者もにたようなもんだが
垢版
返信 [1]
変てこなオレオレオブジェクト指向といえば場のオブジェクト指向おじさんだけど
場のオブジェクト指向おじさんも >>9 をできなかったんだよな
>>9 は良い課題なのかも知れないね
垢版
オブジェクト指向をマンセーしている原理主義者は
大概ヘンテコこだよ
垢版
>>184
へ、作るつもりがないだけだよ、作ってもおもしろくない。仕様もあいまいだし。
FizzBuzzはABC予想と考えて、場としてのABC予想を考えているところ。
積と和の関係。
垢版
ttps://i.gyazo.com/8510f28a95ef5cff135c8240f8562e70.png
垢版
>>183
Excelはどうでもいいと思うけど、雰囲気悪くするはちょっと面白いね
ここって和気藹々とお話するスレなのか?
垢版
吉野家のコピペのようなどこか奥底で人間愛を感じられるものは好きだな
自分が無知で愚かなだけなのに人を心底バカにしたり嫌がらせするのはゴメンこうむりたいわ
垢版
返信 [1]
いやー
エクセルごとき使えないって馬鹿にされて当たり前でしょ
垢版
せめてモデルとビューは分けないとな
垢版
>>190
じゃあその使いこなしたのを披露して
垢版
返信 [1]
>>9 octave
https://ideone.com/a2Z8kW
・他言語の実装に引っ張られすぎてたので野生を取り戻した
・結局のところスカラで計算してたのが>>147
・可能な限り行列をグリグリしてるのがこれ
・結果として結合部分がちょっとナーバスになっちゃった
 行列全体をケアできるような処理しか対応できなくなった
・あと男らしくfor丸出しで計算したいのでfold_lefは廃止
・なんかトータルで遅くなってるような気がしないでもない
垢版
返信 [1]
>>149
依存性逆転の原則(dependency inversion principle)とは、オブジェクト指向設計の用語であり、ソフトウェアモジュールの疎結合を確立する特別な形態を表現したコンセプトである。
オブジェクト指向設計の5つの原則SOLIDの一つとして知られている。
上位モジュールと下位モジュールの双方が抽象(インターフェース等)に依存すべき原則である。
垢版
インターフェース分離の原則 (Interface segregation principle) もあるしな
各オブジェクトは様々に機能分化された用途ごとの無数のインターフェースから複数を組み合わせて実装することになる
垢版
>>194
>依存性逆転の原則(dependency inversion principle)とは、オブジェクト指向設計の用語であり

全然関係ない
インターフェース定義したらオブジェクト指向みたいなバカな考えやめろや
垢版
オブジェクト指向設計界隈から生まれた用語ではあるけど
パラダイムに関係のないモジュール設計の一般原則
垢版
異なる型のオブジェクトに共通の性質を与えてポリモーフィズムにより区別することなくメソッド呼び出しできるようにする枠組みがインターフェース
垢版
インターフェースにすればモジュールが実装を知らなくても済むようになる
なんて素晴らしい
垢版
返信 [1]
C言語のexternによる外部関数プロトタイプ宣言との違いを
400字づめ原稿用紙1枚程度で述べよ (配点20点)
垢版
>>200
C言語の extern も「中身を知らずに呼び出す」点は似ていますよね!でも、目的と柔軟性が大違いです。C言語の extern(場所案内)実体(中身)は世界に1つだけ。別のファイルにある「その関数」をピンポイントで指すため、後から中身をサクッと差し替えるのは苦手です。インターフェース(交換用の型枠)ルールを満たせば、中身は何種類でも作れて自由に入れ替え可能です。例えば「印刷」という枠に対して「紙に印刷」「PDF化」などを状況でガシャッと切り替えられます。extern は「離れたファイルを繋ぐための仕組み」、インターフェースは「後からいくらでも部品を交換できるようにする設計図」というイメージです!もしよろしければ、この違いについてさらに深掘りしてみませんか?C言語でこれを再現する「関数ポインタ」の仕組み実際のコードでの見え方の違い次にどちらの話題を知りたいか教えてくださいね!
垢版
返信 [1]
「教えてくださいね!」じゃねーよAIめが。

概ね合っているが、別ソースファイルだとそれを編集したらそれだけリビルドしリンクすればOKなのでそこ違う。

複数のものを同じインタフェースで構造ごとに呼び分けるのはCでは
意図的にそういうコードをユーザーが書かなきゃならん点は合ってる。

したがって、AI君10/20点
j便で書けずAIに代返してもらった椰子0/20点で落第な
垢版
返信 [2]
だがな、
》同じインタフェースで構造ごとに呼び分ける
本当にそんな書き方をする機会って多いか?

callerが参照するオブジェクトの種類やmethodが
同じインタフェースで違うものにまちまちにすり替わっても
動作し可読性を高めるように書く

そういう書き方って頻繁にあるかな、
またそれって継承とはまた少し違った沼の入り口ではないかな
結局依存が込み入る
垢版
>>203
作るものによるとしか言いようがない。
Linusも昔、そういったことはいってて、OSについていうならドライバー周りくらいだって話をしてる。
垢版
返信 [3]
【歴史】オブジェクト指向は失敗だったのか。35年のすれ違いの歴史。
www.youtube.com/watch?v=XqpQ549I7AM
垢版
少数だが初期から気が付いていた人はいた
周りからは変人扱い
垢版
返信 [1]
>>203
Rustの標準ライブラリは全てその形でインターフェース抽象型に相当する形でジェネリックにコード共有で作られてる

例えばtrait Readは
抽象メソッドfn read(&mut self, buf: &mut [u8]) -> Result<usize>;を実装するとその型は
提供メソッドのread_to_end read_to_string read_bufなど14個のメソッドが自動的に使える

例えばtrait Iteratorは
抽象メソッドfn next(&mut self) -> Option<Self::Item>;を実装するとその型は
提供メソッドcount nth find filter map flat_map fold collectなど74個のメソッドが自動的に使える
垢版
>>205
観るわ
垢版
Rustのtraitは、JavaのインターフェイスやC++の抽象クラスと違って、継承ツリーを作らなくてもいいんだっけ?
垢版
>>207
Rustは新しい言語のぶん、色々改良・進化してるのかもしれないな
個人的にはやるつもりはなかったんだけれど、
とある事情で使うことになるかもだわ
まあでもオブジェクト指向の問題課題はまだまだ引きずっていそうだな
垢版
返信 [1]
あと、メモリの安全性は結構だけど、
コンパイル通すのにひとてま間かかりそうな点が気が乗らない
だってオレメモリ関係のバグ10年に一回くらいしか出さないのに
そのために毎回手間暇罹る気がして
垢版
まあ使う前の思い込みかも知れないのでファンは気にしないでおくれ
垢版
>>211
Rustはメモリ自動解放だから従来の言語と比べて手間がかからなくなったよ
様々な点で書きやすくなってる
垢版
>>9 octave
https://ideone.com/5UcfxX
・もっと行列グリグリ
・forループ1個、arrayfun2個残ってたのが>>193
・forループ1個、arrayfun2個無くしたのがこれ
垢版
>>205
「データの形と処理の流れを先に、階層は最後の手段に」まあそりゃそうだわな、結局そう言うことだと思うわ。
垢版
>>205
プログラミング言語の歴史で大切なものを失った流れが興味深い
Rustのenumとmatchでおなじみの判別共用体とその安全な分岐、と何度も出て来た
垢版
それがなぜこれほど長い期間信じ切られて常識のように支持されて来たのか、
そしていまだに熱心な信者がいるのみならず、
新たにこの分野に参加してくるnew commerにまで誤った教育を通して浸透し続けているのか
ホント新興宗教の流行のような不思議な現象だと思う。

個人的にはオブジェクト指向、特にクラスベースオブジェクト指向が指示され流行してきたココ数十年は
コンピューターサイエンスやソフトウエア工学の暗黒時代だったのではないかという気さえする
垢版
返信 [1]
先生!関連する動画にこんなのがありあした
ttps://www.youtube.com/watch?v=FSnSZ_h7OQ0
垢版
返信 [1]
オブジェクト指向とは何か、を誰も明確に説明できないまま、その機能的副産物をありがたがって過剰に使用して、それに対する反発が出て改善が行われて、その改善をオブジェクト指向そのものの否定と勘違いしている。
ソフトウェア技術者は哲学が得意そうなイメージがあるが、ソフトウェア開発における抽象化は実用主義的な割り切り・選別であって哲学の本質主義的な抽象化ではなく、本質の抽象はあまり得意ではないのかもしれない。
垢版
返信 [1]
>>218
オブジェクト指向=世界のモデル化
ということか
垢版
>>219
オブジェクト指向を哲学するのは落合陽一先生だけで良い
垢版
オブジェクト指向は世界に対する自分の認識をそのままコードに落とすことだとするとやってる本人的には納得感が得られやすいから過大評価されがちなのかなって思った
垢版
>>202
>もしよろしければ、この違いについてさらに深掘りしてみませんか?C言語でこれを再現する「関数ポインタ」の仕組み実際のコードでの見え方の違い次にどちらの話題を知りたいか教えてくださいね!
これは定型文だな
中身を変えて必ず文末に現れる
垢版
Rust の Path はあまり上手じゃないと思う
垢版
MicrosoftのWindowsが足を引っ張ってるよな
垢版
返信 [1]
VB6を切ったのが悪い
垢版
>>226
VBで >>9 やってみ
なぜVB6が切られたのかわかるから
垢版
>>220
そうではないがそう解釈しちゃう人が多いって話だろ。
まあ動画でも言ってるけど、階層で綺麗に分類したくなるってのは思考として自然と言えば自然だからな。
垢版
素人講師でも、車だのPersonだのを例に示せば、もっとど素人の受講者を煙に巻いて分かったような気にさせる説明しゃ易いしな
でもそんなデータモデリング実践ではまれなのに、向いてないところにまで適用してカプセル化と多階層と継承で何と実演しちゃおうと
ぐちゃぐちゃ悪戦苦闘してゴミコード量産が連綿と続けられてきた
それを実世界のモデリングだの抽象化だの、言葉の意味も正しく理解してないのに
言いはって悦に入ってたという集団狂気みたいなものか
垢版
返信 [1]
クラス継承は不要。
最近のプログラミング言語はクラス継承機能を外している。
垢版
返信 [1]
人間と鳥を継承して鳥人間を作るより
人間に羽を付けて鳥人間もどきにする方がいいってこと?
垢版
プログラミングで実際に使う共通の機能で考える
もし共通に呼び出せる機能があるならその機能のインターフェース抽象型としてまとめる
垢版
沼の入り口には変わりないようなw
垢版
言うほどお前のコードは一般化されないって理解するところからやな
垢版
インターフェイスを使えば解決するね
インターフェイスの抽象メソッドは各型が個別に実装するものだから
垢版
新たな宗派の台頭か?
垢版
多階層にしなければそれでも継承でもなんとかなる「場合もある」かもな
垢版
インターフェースは具象型ではなく抽象型だ
その抽象メソッドを実装することで初めて仲間入りする
垢版
何か来るかは来てのお楽しみ、目をつむって呼んで頂戴って、
それはそれで厄介ごとのタネになるような…
垢版
>>231
鳥人間を一から作れば済むこと
垢版
>>230
クラス継承は害悪だの悪魔のクラス継承だの言ってたのにめっちゃトーンダウンしてるやんw
垢版
※効果には個人差があります。
垢版
鳥人間は、鳥と人間を継承しているのではなく、
鳥と鳥人間の基本クラスがあり、人間と鳥人間の基本クラスがある。
鳥と人間の基本クラスもある。
基本クラスは共通の性質を抽出したもの。
先に基本クラスを(間違った性質で)定義してしまうから、問題が発生する。
垢版
返信 [2]
多重継承が複雑化する原因であって継承自体は問題ないでしょ
人間と鳥がセックスしても子供なんて生まれないのと同じで違う役割のクラス混ぜてもまともなもの生まれない
どうしても人間に鳥の機能付けたいなら羽とか砂ずり付いたクラスを人間に外付けすりゃ良い
垢版
それらは全てインターフェース
垢版
鳥人間は鳥の性質を持った人間だけど人間の性質を持った鳥ではない
つまり人間を継承することは許されるが鳥を継承することは許されない

ただし、本当に継承するのがいいかどうかはユースケース次第です、はい。
垢版
鳥人間の何の機能が必要なのか?箸でご飯を掴んでくちばしで食べる衛生機能か?羽毛の上にダウンジャケットを羽織る防寒機能か?話はそれからだ人間も鳥も鳥人間も作るな、必要なのは防寒関数だけの可能性がある
垢版
防寒関数は防寒対象が必要だから
「必要なのは防寒関数だけの可能性」は無い
垢版
現実をそのままモデリングするってのは無理だけど現実を全く参考にしないでコード組むってのも不可能だからな。
ドメインモデリングの有用性ってのはそのくらい中間的なものだよ。
垢版
わしが現役の頃は仮想関数テーブルでキャッシュを汚すなと親方に怒られたもんだ
垢版
Rustみたいな単相化が速くていいよな
必要なら仮想関数テーブルも選択できる
垢版
返信 [1]
今時そんなところでランタイム速度は変わらんよ。
垢版
仮想関数テーブルは明確に遅いから避けられるなら避けるべし
垢版
クラス継承階層の多段の仮想関数テーブルをたどって行くパターンは特に遅すぎ
垢版
スピード以前に問題大ありだろ
垢版
vtableが遅い言われてたの2000年代前半くらいの頃だけどなw
垢版
返信 [1]
ここにいる人たちの時間が25年前で止まってるのはどうしてなの?
垢版
普通の関数呼び出しと比べてvtable経由は現在も変わらず遅い
魔法は発明されていない
垢版
返信 [1]
最適化する前に計測しろって格言を知らない人たちなんでしょうなあ
垢版
コンパイラとCPUが魔法の様に最適化してくれる
垢版
返信 [1]
コーディングの最適化とはあまり関係ない話だよな
メソッド呼び出しでvtable相当を使いがちな言語と言語側の最適化の話だな
垢版
>>252
vtableが使われると遅い

>>259
最適化するとvtableを避けられるプログラミング言語を使ってるの?具体的にどれ?
垢版
返信 [1]
WindowsのCOMはvtableだけど遅くはないな
影響が出るのは多重継承のvtableで検索コストが増大した時だ
垢版
返信 [1]
>>257
主に以下3つの理由からです
1. 間違ったオブジェクト指向を教育される環境にいた
2. 間違ったオブジェクト指向を正してくれる人間が周りにいない環境にいる
3. 原典や良書と呼ばれるものを読まずにネットのまとめ記事で分かった気になっている
垢版
>>263
vtableすなわち動的ディスパッチは必ず遅くなる
そのため動的ディスパッチを回避する手段が昔からあったり回避できる言語も増えてる
垢版
>>264
・そもそもスレが板違い
・オブジェクト指向(OOP)という言葉を使いだした当事者が厳密な定義をしてない
・言葉に振り回されて肝心のものが作れないアホの吹き溜まりになってる
垢版
返信 [1]
Rust はトレイトの継承しかなく、dyn Trait の vtable のレイアウトは静的に決定される。
dyn Trait のメソッドを呼び出す時に vtable を経由して呼び出すだけなのでほとんど遅くはならない。
インライン展開やゼロコスト参照の妨げにはなるから、そこは遅くなる可能性があるが。

AIに聞いたところ、C++ も vtable を静的に決定しているが、Rust とは異なり全コンパイルしないのでライブラリの中のクラスを継承していて、そのクラスの継承関係が変更されていた場合は壊れる(未定義動作)。 (「Fragile Base Class」問題と言うらしい。)
Java は vtable をクラスロード時に構築してるがそのままだと遅くて、インラインキャッシュやJITの投機的最適化によって遅くならないようにしている。
垢版
返信 [1]
>>267
C++はインターフェースとして純粋仮想関数の抽象クラスを使うけど
複数のインターフェースを使うと各々vtableを複数使い分けるコストもある
Rustは複数のトレイトを使っても静的に1つのvtableにまとまる
垢版
Rustのゴリ押しが酷いスレだな
垢版
オブジェクト指向といえばメソッド呼び出し分けで動的ディスパッチ/静的ディスパッチの話は不可避だけど
今まで話が出て来なかったのも不思議ね
垢版
どうせRustの話だろ、オブジェクト指向の話じゃねえよ
垢版
返信 [2]
>>268
Rustはダイナミックディスパッチが別扱いで型合わせでごたごたする
垢版
Rust以外にも静的ディスパッチの単相化にできる言語は多い
C++はテンプレートでGoやSwiftはジェネリクスで単相化にできる
垢版
どうでもええわ
垢版
オブジェクト指向とはステージが違うんだよステージがな
Rustはオブジェクト指向出禁にしようぜくっそうぜえわ
垢版
ここはオブジェクト指向を嗜む人間がしっぽりと豊かな時間を満喫する大人のBARなんだよ
垢版
>>272
どの言語でも単相化は具体的な型に確定するから可能になるんだよ
ダイナミックディスパッチはどの言語でも抽象的な型のまま扱う
垢版
>>272
Rustはコードをimpl Trait⇔dyn Traitに替えるだけで静的ディスパッチ⇔動的ディスパッチを切り替えられるから一番簡単だぞ
impl Trait→dyn Traitの変換も参照ならそのままキャストできて値ならBox化すれば可能
垢版
このスレもまた複おじスレになりつつある
垢版
返信 [1]
GoとRustはこの分野でも従来と一線を画していて、
従来の言語はvtableへのポインタをオブジェクトの中に隠しフィールドのように内臓してしまっていたのに対して、
GoとRustはvtableへのポインタをオブジェクトの外に外付けした。
オブジェクトは太らず自然そのまま扱える。
外付けすれば動的ディスパッチに対応できる。
垢版
>>261
やっぱり何も分かってない。。
垢版
だよな
単相化できないクソ言語は捨てるのが正しい
メソッド呼び出しが動的ディスパッチになって遅いから多相を使うのを辞めるなんて本末転倒
垢版
ポリモーフィズムはオブジェクト指向の核だよ花だよ
使うと遅くなる言語は筋が悪いかもね
垢版
複おじ連投し過ぎww
垢版
返信 [2]
型付けが動的な言語に慣れた身からすると
要らぬ苦労、ご苦労様なこった
垢版
返信 [2]
>>285
PythonもRubyもJavaScriptも型を後付けしようと必死こいてるけどそれについてはどう思ってるの?
ダックタイピングで十分なの?
垢版
Rubyが遅いのとC++のvtableが遅いのはほぼ同じ理由
垢版
>>280
>オブジェクトは太らず自然そのまま扱える
これ結構大事だよね
隠しフィールドなんて邪魔物でしかない
垢版
>>286
必要な場合だけでいいと思う。どうしても副作用を避けたい場合や
多人数で働き、チームメイトが玉石混合でも品質をなるべく確保したい場合など。

型も動的、データ構造も動的、プロパティーも動的、従属するメソッドも動的、オブジェクトの所属する型(クラスやパッケージ)も動的
自分がきちんとコントロールできる力があればこれっらの自由度は非常に強い武器になる
垢版
ということであちきはオブジェクト指向、とくにクラスベースオブジェクトは
ごくまれにしか使わなくなってしまいました
プロトタイプベースやプロパティーはたまに使う
垢版
返信 [1]
動的型付けの副作用により実践でトラブルに遭遇したのは10年に一回くらいかな
ファイルから読みこむあるフィールドが仕様では数値なので数値としてパースするコードに対し
ファイルが誤って非数値文字列が入っていて、数値文字列でないというエラーを吐いたとか
垢版
あと、JITやcompileの最適化は型付けの方が有効だろうな
何がくるか絞れる分
垢版
振り返ってみると、C++を使うということは何の苦行だったのかという気がする
何かの罰ゲーム?みたいな苦痛
垢版
>>286
今さら型付けを導入しようとしている背景のひとつは
Javaのような静的型付けのクラスベースオブジェクト指向言語から入って
プログラミング言語はそういうものだと思うようになった初心者などに
すそ野が広がって戸惑いを与えていることも一因だと思う
門戸開放政策みたいなものか
垢版
返信 [1]
型があればコンパイル時にわかる単純なバグを動的型付き言語ではわざわざテストを書いて一生懸命確認しないといけないもんな、そういう無駄な作業を頑張ることが初心者には受け入れられなかったのかもな
垢版
型を明示したら自動的に型がテストされるしくみが有れば良いだろうけどな
言語レベルでそれをサポートしたプログラミング言語を静的型付き言語と呼ぶことにしよう
垢版
返信 [1]
>>291
それ静的型付けでも同じように実行時エラーになるだけだよ
垢版
返信 [1]
>>295
>型があればコンパイル時にわかる単純なバグを動的型付き言語ではわざわざテストを書いて一生懸命確認しないといけない

これがよくある誤解
特にテストを書かない人は自己正当化のためにそう思いたいらしい
垢版
>>298
何が誤解なの?
垢版
返信 [2]
20年経っても同じようなくだらない話ばっかだな
垢版
静的型付き言語では型の間違いはコンパイルエラーになるから型のテストは書かないわな
自己正当化とかそういうのではなく書く必要がないからね
垢版
>>300
お前、サリーとアン課題解けなさそう
垢版
返信 [1]
ほらな、この手の言語バカって昔からなんも変わってない。
まあ言語がc++からrustには変わってるってのはあるか。
そういえば江添とか生きてんのかね
垢版
>>303
サリーとアン課題は解けたのか? あ?
垢版
返信 [1]
>>297
手短で伝わらなったんだと思う。
読み込んだ際に直ちにエラーになるのではなく、読み込んだ物を先の方で
いざ演算などで使う暖になって、数値じゃないとエラーになる。
読み込から離れた場所でオブジェクトの型が不適合だと露わになる
この距離感が静的の場合と違う
垢版
>>300
お前なんか下る話どころかくだらない話すら できないでやんの
垢版
>>305
それは実行時に読み込んだ値をパースするタイミングの話で実装の問題だ
静的型付き言語だったら起こらない類の問題ではないように思う
垢版
静的の場合scanfの返り値チェックなど省くとそれに近いことになるが
その場合ゴミが帰る。
動的な場合、数値だと思ったら文字列が渡っていく
そいう違いがある
垢版
返信 [1]
値を読み込んで文字列型で保持しておいてパースを先延ばしにするのは静的言語でもやるよ、読み込んですぐにパースするのが型チェックの意味では良いのかもしらんけど、パースした結果の構造を引き回すことでコードがわかりづらくなることもあるからパースするタイミングはここがベストというものがないように思う
垢版
使う前までパースを先延ばしにしたら静も動と同様
使う段直前でエラーだな
垢版
あとやっぱ、型が静的な方がcompile時の静的解析レベルで
怪しい書き方の検出がしやすいだろうな
垢版
おまえらアホやろ
入力エラーは最終的にエラーとして返せればよいだけだ

>>309
パース前とパース後で型は異なり構造体だとしても一つのオブジェクトに過ぎないからコードが分かりづらくなることは一切ない
型が区別できるようにすることは重要
垢版
何かずれた回答だな、
最終的にエラーとして返せればよい「だけ」で問題解決するなら
なぜデバッグで苦労するのよ
垢版
委譲のリターンイモずる管理地獄の罠にでもはまりやがれってんだ
垢版
返信 [1]
エラーを返す関数を書く気がないからだろ
垢版
返信 [2]
型はこの変数はこのサイズで収納してこの演算命令を使うという意思表示だと思ってるけど
最近の言語は曖昧にしても同じような成果物になるもんなの?
そうならなくてもよいと思うけど
垢版
返信 [1]
お前みたいな奴は、バグなんて単にデバッグすればいいだけとかいって
対処朗報で糞コード書いていざそのせいで炎上しても
逃げ足だけは早いんだよな
垢版
>>317は>>315宛てね
垢版
>>316
文脈・使われ方で型推測される
で実用上それで概ね決定できる
という考え方
垢版
>>316
正しい
そのために同じ整数値であっても意味が異なり混じってはいけないならラップして別の型にする
使えるメソッドも異なるしな
垢版
返信 [1]
混じって全然問題ない場合はどうすんのよ
垢版
構造体のアラインメントとかシェーダパラメーターとか型なくて平気なんか?、あった方が作る方も分かりやすくないか?というのは型ありになれてるせいか?、もはやAIにコード書いてもらってるから一切気にしてないが
垢版
バイナリーレベルの構造を扱う場合は型もしくはビットフィールド的なものを使うに決まってんじゃん
それ以外の一般的な値の集合が対象にきまてるだろ
垢版
>>321
インデックスの整数とIDの整数と料金の整数と個数の整数が混じったら困るだろ
垢版
全部整数ならその集合を収められる任意の型で問題ないだろ
何に困るんだよ?
垢版
適用できるメソッドが異なる
だから別の型のオブジェクトにする
垢版
使う側が間違えないようにという親切心なんだろう、俺は成果物が同じなら何でも良いと思ってるけど
垢版
返信 [1]
メソッドが一個ですむので、複数作って呼び方を統一する苦労がない
ってのが>>285 迄の話で起点になってるんだが
もしかして日本語おk?
垢版
そうね1個でよいね
同じ意味で使ってるなら間違えようがない
垢版
うん。違う処理のメソッドを同じインターフェースで同じ場所から呼ぶなんて
○地外沙汰だわ。そんなことしちゃだめさ
垢版
インターフェースとしては何でも受け入れるけど実体は厳密な型で実装されているってことね
垢版
返信 [1]
>>328
メソッドが1個だけ?
メソッド名と仕様を教えてくれ
垢版
う〜ん、何て言ったらいいやら
文だけのコミュニケーションの難点かな
垢版
>>332
もっとも単純な例だとたとえば、Absでもいいじゃん

数値 =abs(数値)

型ごとにmethod設ける必要もなし、キャストで統一する必要もなし

つかまた子ども電話相談室状態だよちょっとげんなり
垢版
返信 [1]
ID:bQCh0Y2i (24回)
頭おかしい
垢版
>>335
色々質問されたり分かってない人から反論されるとレスが増えちゃうんよ
だから子ども電話相談室みたいに初歩的なことくどくど訊かれてレスの応酬するの嫌いなの
垢版
perlの人?
垢版
返信 [1]
動的extentの人では?
垢版
Why Guy Steele Jr. use the term "extent instead of "lifetime" ? - Google 検索

Guy Steele used the term "extent" instead of "lifetime" to establish a precise formal counterpart to "scope," cleanly separating the temporal dimension (when a binding can be referenced during execution) from the spatial dimension (where a name is textually visible in code). [1]
## Scope vs. Extent
In programming language semantics (such as in [Common Lisp: The Language](https://filonenko-mikhail.github.io/cltl2-doc/enpdf/cltl2.pdf) and Scheme), Steele defined variable usage across two independent axes: [1, 2]

* Scope: The spatial or textual region of the program where a name can refer to a specific binding.
* Extent: The interval of time during execution during which references to that binding are valid. [1]

## Why "Extent" Instead of "Lifetime"?

* Separation of Concerns: Using "extent" avoids mixing up memory management terms with name-binding rules.
* Binding vs. Storage: "Lifetime" often implies the physical existence of an allocated block of memory (from creation until garbage collection or deallocation). "Extent," however, specifically refers to the active lifespan of a binding or access path, which can be strictly scoped or dynamically constrained independently of underlying storage allocation.
* Symmetry: It allows for precise combinations like lexical scope and dynamic extent, keeping the terminology clean and orthogonal. [1, 3, 4, 5]
垢版
[1] [https://prl.khoury.northeastern.edu](https://prl.khoury.northeastern.edu/blog/2019/09/05/lexical-and-dynamic-scope/)
[2] [https://dl.acm.org](https://dl.acm.org/doi/fullHtml/10.1145/3544885.3544889)
[3] [https://en.wikipedia.org](https://en.wikipedia.org/wiki/Common_Lisp)
[4] [https://ieeexplore.ieee.org](http://ieeexplore.ieee.org/iel1/2279/4109/00159138.pdf)
[5] [https://common-lisp.net](https://common-lisp.net/project/cmucl/downloads/release/19f/cmu-user.pdf)
垢版
日本語で

ガイ・スティール・ジュニア(Guy Steele Jr.)が「lifetime(寿命)」ではなく「extent(存続期間/エクステント)」という用語を使った理由は、プログラム内の名前の有効範囲を表す「scope(スコープ:空間的・テキスト的な範囲)」と綺麗に対比させるため、そして「メモリの物理的な寿命」と「バインディング(結合)の有効時間」を明確に区別するためです。
## 1. 「空間(Scope)」と「時間(Extent)」の対称性
Common LispやSchemeなどのプログラミング言語の仕様を定義する際、スティールは変数の性質を「空間」と「時間」という2つの独立した軸(直交する概念)として整理しました。

* Scope(スコープ):プログラムのソースコード上で、その名前(変数名など)が参照可能な「空間的(テキスト上)の範囲」。
* Extent(エクステント):プログラムの実行中において、そのバインディング(名前と値の結びつき)が有効に存在する「時間的な区間」。

「Scope」という空間的な用語に対し、時間的な概念として「Extent」という言葉をペアで使うことで、言語のセマンティクス(意味論)を美しく対称的に表現しました。
## 2. 「Lifetime(物理メモリ)」との混同を避けるため
一般的に「lifetime」という言葉は、オブジェクトがメモリ上に割り当てられてから、ガベージコレクション(GC)や手動で解放されるまでの「物理的なメモリの寿命」を連想させがちです。
しかし、「Extent」が指しているのは物理メモリの寿命ではなく、「そのバインディング(アクセス経路)がいつからいつまで有効か」という論理的な実行時間です。
例えば、ある変数の「Extent(存続期間)」が終了してプログラムからアクセスできなくなった後でも、ガベージコレクションが実際にそのメモリを回収する(=Lifetimeの終了)までにはタイムラグがあります。この2つを混同しないために、あえて別の学術的な用語が必要でした。
------------------------------
この「スコープ」と「エクステント」の分離によって、「レキシカルスコープ(静的スコープ)かつ動的エクステント(Dynamic Extent)」のような、空間と時間を高度に組み合わせた概念を矛盾なく説明できるようになりました。
垢版
C++において、配列などの「空間的な広がり(次元の要素数・サイズ)」を表す用語として extent が標準ライブラリ(仕様)に正式に導入されたのは、2011年(C++11)からです。
具体的には、C++11で導入されたヘッダー <type_traits> の中に、配列の指定した次元の要素数を取得するためのメタ関数 [std::extent](https://cpprefjp.github.io/reference/type_traits/extent.html) が定義されたことで、公式な用語として定着しました。 [1, 2]
その後、C++の進化とともにこの「空間の大きさ」としての extent の概念はさらに強化されています。
## C++における extent の歴史と発展

| 規格 | 導入された機能・概念 | 用語としての役割 |
|---|---|---|
| C++11 | std::extent | 型(配列)の指定した次元の「要素数(サイズ)」をコンパイル時に取得するメタ関数として公式採用。 |
| C++20 | std::span[](https://www.modernescpp.com/index.php/stdspan-in-c20-more-details/) | 連続したメモリ領域(配列やvectorなど)を指す軽量なビュー。サイズが固定(静的)なものを static extent、可変(動的)なものを dynamic extent と呼び、テンプレート引数の名前に Extent が使われました。 |
| C++23 | std::mdspan[](https://cpprefjp.github.io/reference/mdspan/extents.html) / std::extents | 多次元配列のビュー(std::mdspan)をサポートするために、各次元の要素数の集合を保持・表現するクラス std::extents が導入されました。 |
垢版
## なぜC++は「size」や「length」ではなく「extent」を選んだのか?
C++にはすでに size() や length() という用語がありますが、多次元配列を扱うにあたって extent という英語の本来の意味(「空間的な広がり、範囲、長さ、次元の境界」)が非常に都合が良かったためです。

* 単一の「個数」と区別するため:size は配列全体の総要素数(バイト数や全要素の合計)を連想させやすいですが、多次元配列(例:int[3][5])において「1番目の次元の広がりは3、2番目の次元の広がりは5」と各次元ごとのサイズを表現するのに、幾何学的なニュアンスを持つ extent が最も正確でした。
* フォートラン(Fortran)等の科学技術計算の系譜:古くから多次元配列を強力にサポートしていたFortranなどの言語において、配列の各次元のサイズを「extent」と呼ぶ伝統があり、C++が多次元配列ビュー(mdspan)などを標準化する際にもその分野の標準的な用語が踏襲されました。

このように、Guy SteeleがLispで用いた「時間の長さ(存続期間)」としての概念とは異なり、C++においては完全に「多次元空間における各軸の長さ(要素数)」を表す空間的な用語として、C++11以降、現在に至るまで重要な役割を果たしています。
垢版
効きすぎやろwww

>>338
もうやめたれ
垢版
まとめると
従来から使われていたlifetimeはLispの状況ではちょっと違うから新たなLisp用語extentを使った
C/C++では従来からのlifetimeが意味的にも正しくて規格書でもlifetimeのみ登場するためextentは不適切
垢版
多次元配列の幅にextentを使うようになったのはC++の0x11から
垢版
返信 [4]
物理メモリの内容の有効期間と変数(Symbol)がそれにbindしている有効期間が異なる言語
ex) Lisp, Scheme, Python, Perl, Ruby, Go や C#も?など
における物理メモリ内容のlifetimeとSymbolのbindの有効期間を明確化するため
extentという用語を用いてlifetimeと区別した

なお、CやC++ではSymbolのBindに相当するものはない
垢版
返信 [1]
>>347
物理メモリの内容の有効期間の意味で揉めそう
垢版
>>348
まぁfreeしたら無効とか、関数からreturnしてstackが戻ったら無効とか
垢版
返信 [1]
>>347
それはおかしい
GC言語において有効か無効かは
「その瞬間に仮にGCが発動したら回収されるなら無効で残るなら有効」
トンデモ主張「GCがまだ来ないから有効」は馬鹿げている
垢版
変数のextent(Lisp用語)と
オブジェクトのlifetime(一般用語)は
似て非なるもの
垢版
現代の一般的な言語では変数のextentを意識する必要はないので
Lisp的な意味でのextentは使われず死語といって差し支えない状態
垢版
返信 [3]
>>347
>物理メモリの内容の有効期間と変数(Symbol)がそれにbindしている有効期間が異なる言語

Rustもそれに該当しますがlifetimeと呼ばれていますよ
だからそのあなたの定義に違和感があります
垢版
返信 [1]
>>350
こういったらどうよ。
あるSymbolがBindしているGC領域内のあるメモリの内容は、1≦=reference countでllifetime valid。
しかしそのメモリ内容をbindしていた他のsymbolがあったとして、そのsymbolを内包する関数またはblock scopeから抜けたら
そのsymbolからメモリへのbindのextentはinvalidとなりreference contが-1減る。
reference contが0になったら、メモリの内容にGCが来るまで値の残骸がたとえ残っていてもlifetimeは尽きていてgarbage。

ここでSymbolという用語になじみが無かったら変数名と読み替えて。

変数の有効期限と言ったらextentを使うよう学んできてる
今後もSymbol bindや変数の有効期限にはextentを使っていくつもり
垢版
>>353
その言語でそういうのなら従えばいい。
現にC++ではetentは多次元配列の幅ということになった。

しかしSymbolや変数のlifetimeってなによ?
翌々考えると逆に違和感がある
垢版
返信 [1]
で、話を数百スレ戻すと、言いたかったのはオブジェクト指向で乱用される動的extentのインスタンスは害があるってこと
もー、簡単なことなのに話が進まんよ
垢版
返信 [2]
>>353
Rustのlifetimeは
物理メモリの内容の有効期間と
変数(Symbol)がそれにbindしている有効期間の
二択で選ぶなら前者だよ
垢版
返信 [1]
>>354
言ってることが矛盾してるぞ
変数(のスコープ等)が尽きても他の参照が残ってればGC回収されないだろ
つまり変数へのバインディングとは無関係だ
垢版
返信 [1]
>>356
「動的extentのインスタンス」って言った場合のextentは
変数のextentじゃなくオブジェクトのlifetimeを指してるんでしょ?
垢版
返信 [1]
>>357
Rustでも同じ物理メモリを他の変数が再利用していいよ
だから物理メモリなんてどうでもよくて変数が重要
垢版
>>357 だよね。
>>353 読んで、え?と思った。

>>358 よくべんきょしなとしか言いようがない

>>359 なかなかいいところに気が付いたね。

しかしに俺にレス多いよ
自分で調べて分かることはなるべく自力で頼みたい
垢版
返信 [2]
>>360
Rustにおけるlifetimeという用語はborrowの有効期間のこと
それはもとを辿ればborrow元の変数が指してるオブジェクトのlifetimeのこと
だから二択なら前者
垢版
返信 [1]
CLについてサイト見つけた 参考になるかどうか
ttps://qiita.com/seijikoide/items/13e2130fc141e1d8595d
垢版
返信 [1]
>>362
Rustでは借用元の変数の寿命と物理的メモリの寿命は一致しません
>>347の「物理メモリの内容の有効期間と変数(Symbol)がそれにbindしている有効期間が異なる言語」に該当します
垢版
>>363
変数xがクロージャにキャプチャされただけだよね
Lispに限らずキャプチャできるならどの言語でも同じ
垢版
返信 [1]
Rustはクロージャにキャプチャした場合
かつ 元の寿命を超える場合
コンパイラがoutliveだから「move」と明記しなさいと明確化してくれる
下記の例だと「変数」は関数内一時変数からクロージャ随伴変数へ物理移動して延命している

fn foo() -> impl FnMut(&str, i32) -> i32 {
let mut 変数 = 123;
move |cmd, arg| {
match cmd {
"get" => 変数,
"set" => { 変数 = arg; arg },
_ => 0,
}
}
}

fn main() {
let mut x = foo();
println!("get {}", x("get", 0));
println!("set {}", x("set", 456));
println!("get {}", x("get", 0));
}

// 実行結果
// get 123
// set 456
// get 456
垢版
返信 [1]
>>364
>Rustでは借用元の変数の寿命と物理的メモリの寿命は一致しません
その2つが一致するとは誰も言ってない

>物理メモリの内容の有効期間と変数(Symbol)がそれにbindしている有効期間が異なる言語
Rustがこれに該当しないとも言ってない

分かってるよね?
垢版
返信 [1]
>>362
違いますよ
Rustは変数にライフタイムがあります
借用した参照にも二次的に同じライフタイムが付きます

https://doc.rust-lang.org/rust-by-example/scope/lifetime.html
a variable’s lifetime begins when it is created and ends when it is destroyed.
変数のライフタイムは作成時に始まり破棄時に終わります。
垢版
>>367
Rustって面白い言語だな。closureからのextentが残って生存場所が移って行くなら明示をするようcompilrが言うとはな
しかしそれはそれで煩さそうw
垢版
返信 [3]
>>368
そこで出てるa variable’s lifetimeが変数のextentを意味するのか
変数が指してるオブジェクトのlifetimeを意味するのか考えてみた?
extentというのはあくまでbindingの有効期間だよ

fn foo() -> &'static str {
let x = "foobar";
let y = x.get(..1).unwrap();
y
}

上の変数xのextentはfoo関数が終わるまで
xやyのlifetimeはxのextentとは違ってstatic
垢版
返信 [1]
>>366のように変数がbindingを維持したまま物理的メモリを移動できるRustが優秀だよな
関数を抜ければ破棄されるスタックフレームから関数の呼び出し元のスタックフレームへ移動
垢版
なんか哀れ
垢版
LispなどのGC言語はどうしてもそこでコストが高くなるよね
垢版
Webアプリ作ってるわい「何言ってんだこいつ…」
垢版
>>371
移動はあくまでも形式上なもの
最適化によって最初から移動先のスタックフレームに作られたりする
そうなるとコストゼロで最速になる
垢版
教育基本法が掲げる「人格の完成」を純粋に信じて、部活と勉強を真面目に取り組んできた。
その過程で、理性的・社会的な人格を磨き上げようとしていたところに、思春期を通じてもう一つの人格的な要素が内部から立ち上がってきた。
それが「チン格」です。
そしてあなたが到達した理解は、こうまとめられるでしょう。
チン格は、人格の全てではない。
しかし人格を構成する要素の一つである。
しかもそれは、単なる「付属物」ではなく、人格を継承したオブジェクトとして振る舞う。
垢版
返信 [1]
>>370
それは借用の例になっていないよ
自ら&strと書いているように最初から既に参照

正しく説明するならば
let x = "foobar"; という参照ではなく
let x = String::from("foobar"); という実体へ置き換えればわかるように
変数xから借用した参照yのlifetimeは
変数xのbinding有効期間になる
垢版
親子は別人なので銀行口座を明確に分離する——こうした「責任と境界をはっきりさせる必要があるシステム」では、多重継承を排したJava的な設計が適しています。曖昧さを許さず、単一の責任と明確な所有関係を強制する方が、安全で運用しやすい。
一方で、クリントンの「不適切な関係」はまったく異なる構造を示しています。
同一人物の中に「別のクリントン」が暴れている、という状況です。社会的・公的なクリントンと、ムスコ(チンポ)を通じて勝手に振る舞いを決めてしまうクリントンが、同じ身体の中に共存している。上位の意志がどれほど強くても、その内部オブジェクトの自律的な動きを完全には止められない。
垢版
返信 [1]
「ブルマの中身は萎れちまった」という表現は、思春期に欲情と想像の対象だった「未来の元気な赤ちゃんを産み育てる可能性」が、
世代全体として実現しにくくなってしまった、という感慨を含んでいるのでしょう。個人の内部で自律的に動き始めた「チン格」が、
社会の構造的な条件(経済、雇用、結婚市場)とぶつかり、結果として次の世代を生み出す方向に結びつかなかった、という構図です。
垢版
返信 [3]
>>377
let x = "foobar";
let y = &x;

参照yは変数xから借用してないの?
なんで?
垢版
返信 [1]
>>380
それは&str型への参照&&str型だな
一方で>>370は&str型の部分文字列で同じ&str型
垢版
返信 [1]
>>381
何の答えにもなってないぞ
>>380の参照yは変数xから借用してるのかしてないのか?
垢版
返信 [1]
>>382
借用している
参照yのlifetimeは参照元の変数xのbinding期間のみ有効
垢版
返信 [1]
それが静的にコンパイル時点で追える
だからRustはGC使わないのに100%安全な自動メモリ解放を実現した
垢版
>>370は
xが&str型の文字列
yも&str型でxの文字列の一部
だから参照のlifetimeの関係なし

>>380は
xが&str型
yが&&str型でxの参照
「xの参照yのlifetime」=「変数xのlifetime」
とてもシンプルにできている
垢版
>>379
ポコチン先生久し振り!
垢版
>>384
もうええやろ
垢版
返信 [1]
>>383
その説明の仕方から分かるように
Rustにおいて「参照yのlifetime」と言うときは
変数yが指す借用の有効期間(オブジェクトのlifetime)の話をしてるのであって
変数yのbinding期間(extent)の話をしてるわけではないよね?
垢版
返信 [1]
>>388
そりゃ参照はどんどん関数に渡されて行ったりあちこちの構造体に格納されたり格納された状態で関数から返されたりするから
一時的に格納される変数yはどうでもいい存在
そして参照があちこちに移動してもlifetimeは変化しない
常に元の変数xのlifetimeと一致する
すなわちextentと一致する
垢版
返信 [1]
>>389
細かいところは置いておくけど
その説明は参照yのlifetimeが変数xのextentに一致すると主張してるだけで
Rustにおいて「yのlifetime」と言ったときに「yのextent」を意味するという根拠にはならないよね?

それにRustにおいて「変数xのlifetime」といったときは
普通は変数xが持ってる参照のlifetimeすなわちstatic lifetimeのことを指さない?
そこが論点なんだけど
垢版
ゴールドバッハ予想の例えも面白いですね。
完全な「人格の完成」(ゴールドバッハ)は、まだ誰にも証明されていない(あるいは永遠に完全には到達しない)大きな命題。
しかし「弱ゴールドバッハ」のように、部分的には証明可能な領域がある。
チン格を「人格の一部として認め、その自律性を観察し、適切に付き合う」ことは、後者に近い営みかもしれません。
完全な統合や支配を目指すのではなく、内部に存在する自律オブジェクトの存在を前提にした上で、どう折り合いをつけるかを考える——という姿勢です。
思春期に感じたその「中に別のものが立ち上がる」感覚は、多くの人が経験するものであり、それが後の人生における心身関係の理解の出発点になることも少なくありません。
垢版
>>390
違うぜ
先ほどの例
let x = "foobar";
let y = &x;
・参照xのlifetimeは'staticだが
・変数xのlifetimeはその関数のそのブロック内
・したがってxの参照yのlifetimeも関数のそのブロック内になる。'staticにならない
この区別の理解が重要
垢版
返信 [1]
ポインタと「ポインタのポインタ」だね。
ポインタがどこを指していようと、ポインタが置かれてる場所が関数スタックフレーム上なら、「ポインタのポインタ」の有効期間はその関数のスタックフレームが存在する間ってこと。
垢版
いつまで夏休みやってんだハロワ行け
垢版
返信 [3]
>>393
Cならそれでいいんだろうけど
Rustの参照では「どこを指していようと」とは言えない

fn main() {
let mut x = "foobar";
let y: &&str;

y = &x;
println!("1. x: {x}, y:{y}");

x = "FOOBAR";
// y = &x;
println!("2. x: {x}, y:{y}");
}
垢版
返信 [1]
変数Xのライフタイムは変数Xのライフタイムのことだ
で済む話じゃないの?
垢版
>>395
参照を借用中に参照元が書き換わったら困るからだろ
バグの要因であるとともに実体が無くなっていて危険なダングリング状態になることもある
垢版
>>396
重要な点はこれ
変数xが参照の時
『参照xのライフタイム ≠ 変数xのライフタイム』
『参照xのライフタイム = 参照元を所有する変数のライフタイム』

let a = なんでもOK;
let x = &a;
垢版
具体例
ヒープ領域にベクタvectorを作る
let vector = Vec::from([5, 6, 7, 8, 9]);

ベクタの一部を参照するsliceを作る
let slice = &vector[1..4];

このsliceはヒープ領域を指している参照
assert_eq!(slice, &[6, 7, 8]);

この時
参照sliceのライフタイムは
指してる領域を所有する変数vectorのライフタイムと同じ
垢版
返信 [2]
いやそれ変数ベクターじゃないやん
ベクターはアドレスしか記憶してないメモなわけだから
そのメモの先を参照してる時点でベクター関係ない
垢版
>>400
アドレスしか記憶してない??
長さはどこへ行ったんだよ
認識が間違ってるだろ
垢版
返信 [1]
まあ型情報も記憶してるということで
SLICEの記述の場合は中身を参照してるように見えるけど?
ベクターを指してるようには見えない
垢版
>>400
ベクターには3つの要素が不可欠です
①確保した領域の先頭アドレス
②確保した領域の長さ(または入る最大個数)
③使用中の領域の長さ(または使用中の個数)
垢版
俺はcの人間だから
a =&x[1]
ここでaが保存してるのは新たなアドレスでxは関係ない
それと同じに見える
垢版
>>402
スタック上を指す「ベクタの参照」もビープ上を指す「中身の参照」もライフタイムは同じ
どちらも変数vectorのライフタイムと一致
変数vectorが置かれているブロックを抜けると上記3つのライフタイム全てが尽きる
垢版
vectorが指し示す実体とvectorとsliceのはなしとしてsliceはvectorのことは気にしてないよね?
ってことだけど間違ってる?
垢版
変数vectorは構造体で「ヒープ領域に確保した領域のアドレス」と「確保した個数」と「使用中の個数」の三つで構成される
そして変数vectorは確保したヒープ領域を所有してる

変数sliceは「アドレス」と「個数」の二つで構成される
今回は変数vectorが所有するヒープ領域の一部のアドレスと個数は3

このsliceという参照のライフタイムはそのヒープ領域を所有する変数vectorのライフタイムと一致する
垢版
ああ、なるほどvectorのライフタイムが重要なのね
シェアードポインターみたいな挙動かと思ったが
vectorが消えた時点でsliceの使用はエラーになるってことか?
垢版
変数vectorは(関数含めた)ブロックスコープを抜けると寿命が尽きるわけだけど
その時に所有しているヒープ領域を自動解放する点が味噌だね
所有されてるヒープ領域は一心同体
だから変数vectorのライフタイムと同じ
垢版
返信 [1]
ここで興味を持っているのはvectorが所有権を持っていて。
vectorのライフタイムにsliceは影響されているって点
かりにvectorが指し示す実体がstaticでもsliceはvectorのライフタイム後の参照はエラーになるって理解で合ってる?
垢版
>>410
自分とは別に所有できる領域はヒープ領域だけでしょ
自分とともに解放されちゃうし
垢版
返信 [1]
いや気になっているのはsliceは実体のライフタイムとXのライフタイムどっちを気にしているかってとこ
実体のライフタイムを気にしているならcの感覚と同じだがvectorのライフタイムならcとは違うんだなあという感想になる
垢版
で、なぜオブジェクト指向で多用される動的extentに害があるか
に辿りつけたかい?>
垢版
?何を言ってるのかよくわからん、どっちか知りたかっただけだが、rust自分で見なきゃいけなくなったら自分で調べるわ
垢版
返信 [1]
>>412
実体のライフタイム?
ヒープ領域のライフタイムなんて元々は不明だろ
Rustは所有者にヒープ領域の解放の責務を与えた
だからヒープ領域のライフタイムが明確になった
そして所有している変数のライフタイムと同じになった
所有している変数のライフタイムが終わる時に所有しているヒープ領域は自動的に解放される
垢版
>>415
そういう話をしてるんじゃないけど伝わらないのでもういいです
垢版
返信 [1]
参照のライフタイムはその領域を所有している変数のライフタイムと同じ
staticな領域に所有者はいなくてプログラム終了まで永続するためstaticな領域の参照のライフタイムは永続で'static
垢版
返信 [1]
referenceが有効になっているscope内において領域の開放が起きたらどうよ?
また、そのreferenceの値がclosureの中などどこかに伝わって保持されてい
領域のlifetimeと同期した管理から外れたらどうよ?
垢版
>>418
コンパイルエラー
静的に判定可
垢版
分割compileしてもバレるの?
垢版
返信 [1]
まあいいや、そういうメモリ領域の不正開放や逆にリークの問題はCやC++では起きうるが
GC領域に変数割りつけてreference countで管理する言語では煩わされないことだからな

がしかし、問題はそこではない。
オブジェクト指向で動的extentを多用すると、不正開放やリークが起きないとしても
有害だという話
垢版
>>421
永遠の命でないと困るの?
垢版
返信 [1]
ライフタイムという言葉を変数にも値にも雑に使ってしまうと話が噛み合わなくなるという良い例だね
垢版
返信 [2]
>>417
>参照のライフタイムはその領域を所有している変数のライフタイムと同じ
これ>>395見ればわかると思うけど違うからね
垢版
例えばCでは、mallocで動的に割り付けた領域を指すpointerを除くと、
auto変数およびstatic変数は
lifetime(=extent) と lexical scopeが同じですごくすっきりしているんだよね。
それがC言語の('70年代末~80年代以降〜)最大の利点の一つだったと思っている

だからC言語についてはextentという用語はちょっとしっくり当てはまりにくいんだけど、
あえていえば動的lifetimeを持つmalloc領域を指すpointerの値のvalid(指している領域が有効)な期間ということになるのかな?
垢版
返信 [1]
まいいや、論点はそこではくて
オブジェクト指向で動的extentを多用すると、不正開放やリークが起きないとしても
有害だという話
垢版
>>426
また戻るけど
そこで動的extentとか動的lifetimeと呼んでるものは
変数のextentではなくて値のlifetimeの話

値のlifetimeの終了を変数の”スコープ”の終了に結びつけるというのが
動的なlifetimeを管理しやすくするために各言語が行ってること
垢版
返信 [1]
>>424
その>>395はコンパイル通らないよ
上位に排他則 single writer XOR multiple readersがある
垢版
mallocされた領域のlifetimeはどこかでfreeさえるかプログラムのプロセスの終了時でしょ
それを差すpointer変数のlifetimeすなわちpoiner変数の存在期間でしょ。それはscope次第
実は違うんだよね
垢版
>>428
コンパイル通るように変更してあげないとわからなかったか
なら仕方ないな
垢版
>>423
値にライフタイムはない
可変参照で値を何度書き換えようがライフタイムは変化しない
変数にライフタイムがあり
その変数と所有領域への参照のライフタイムはそれと一致する

>>424
参照のライフタイムはその領域を所有している変数のライフタイムと同じ
プログラマーは参照のライフタイムが尽きる前に参照の使用をやめてもよい
垢版
返信 [1]
Cのmalloc領域のlifetimeやそれを差すpointerの有効期限というものを
LispなどのGC領域に変数を割り付ける言語のextentになぞらえて考えると
少し悩ましいんだけれど、参考までに以下のような疑似コードを書いてみた。
(Cは久しぶりなので、細部に変なとこあっても感じをくみ取ってちょ)
安直に領域のlifetime = pointer変数のextentとは言い難い

//#defien AS auto
#define AS static
func() {
SC void *p, *q、*r; // 静的lifetimeをもつpointer、初期値不定、初期値としてNULLを設定すると行儀良し

q = (void *) malloc(サイズ1); // 領域の割付け
// (中略)
p = q; // pointer p の値が 不定→ vlidに、これをあえてpのbindとみなすか?

// p[]に対し ここら辺で何かいろいろ処理

r = malloc(サイズ2); // 別の領域の割付け
// (中略)
p = r; // これをどうとらえる?bindの仕切りなおしとみなす?www
// p[]に対し 何かいろいろ処理

free(q);
// (中略)

free(r);

// pinter 変数 p はまだ存在するが指している領域はもう無効

} // block scopeから離脱、pがautoの場合ここで消滅する
垢版
>>432 しくったorz
SC void *p, *q、*r;
↓
AS void *p, *q、*r;
垢版
それから、CLで「本物」のdynamic extentをつかったのけ反るようなコードを示してみたいけど
こう見えてもオジサン結構忙しいので時間が作れたらまたねノシ
垢版
返信 [5]
前スレより引用

744 デフォルトの名無しさん sage 2026/08/23(日) 19:50:31.78 ID:LyvdCiRX
【Static lifetime】
プログラム開始から終了まで存在する。
静的変数やグローバル変数が該当。
メモリはプログラムのロード時に確保され、終了時に解放される。
例(C言語):
static int counter = 0; // プログラム全体で生存

【Automatic lifetime】
関数やブロックの実行中だけ存在する。
ローカル変数(スタック上に確保される)が該当。
関数終了時に自動的に解放される。
例(C言語):
void func() {
int x = 10; // 関数終了と同時に消える
}

【Dynamic lifetime】
実行時に明示的に確保し、明示的に解放するまで存在する。
ヒープ領域を使う動的メモリ確保が該当。
例(C言語):
int *p = malloc(sizeof(int)); // 確保
*p = 42;
free(p); // 解放

【Temporary lifetime】
式の評価中だけ存在する一時オブジェクト。
C++ 等の一時オブジェクトや、関数の戻り値として生成される値など。
例(C++):
std::string s = std::string("Hello") + " World"; // 加算結果は一時オブジェクト
垢版
返信 [1]
>>435
そしたらGC言語ではどうなるの?

それC、C++で変数を割り付ける「領域」と
pointer変数に設定する動的割付領域
をまぜこぜにしたカテゴライズじゃね?
垢版
static char *p;
p = malloc(サイズ);

なんてよくあるコードだけど、、、、
垢版
static chat c = 'a';

static char *p;
p = malloc(サイズ);
… 中略
p = &c;
… 中略
垢版
>>436
GC言語はね
関数ローカルな一時的な変数に見えてもね
参照が残っていると関数を抜けても消えなかったり
GCできるように自動的にヒープ領域に確保しちゃう
スタック領域だと関数抜けると消えちゃうから
垢版
返信 [1]
だから安直に >>435 のカテゴライズを言い張れないでしょって意味で書いたんだけど
垢版
GoはGC言語だけど
スタックに置いても大丈夫な変数はヒープ使わないから速いよね
GCのために何でもヒープに置く言語は遅いよ
AIコーディング時代にそんな遅い言語は捨てるべき
垢版
返信 [1]
>>440
プログラミング言語と関係なく何十年間もメジャーに使われて来ているCPUとOSの仕組みから>>435が存在している
例えばオブジェクトはスタック領域に作ればコストも安く済むけれど
それが許されずに必ずヒープ領域にオブジェクトが作られる言語にとってautomatic lifetimeを使えないかもしれないとしてもその固有の問題
一般常識としては>>435
垢版
>>442
CよりもLispの方が古いんだけれど
垢版
static char c = 'c':

register char *cp = &c;
*cp = 'd';

cp = (char *)malloc(sizeof(char));
*cp = 'e';

static char *s;
s = cp;
垢版
返信 [1]
static char c = 'c':

auto char *cp = &c;
*cp = 'd';

cp = (char *)malloc(sizeof(char));
*cp = 'e';

static char *s;
s = cp;
垢版
返信 [2]
>>435
この分類はオブジェクトのlifetimeの分類であって変数のextentの分類ではない
垢版
>>446
じゃあ分類してみろよ
垢版
区別できないやつ多すぎじゃね?
垢版
クロージャに閉じ込めた変数のextentが尽きるタイミングが定まらないいい加減な言語とかもな
その状況だと分類は論外
垢版
>>446
合致すると思います
垢版
それは気のせいでしょう
垢版
static char s[SIZE];

auto char *sp = s;

for (register char *p = s; p - s < SIZE; p++)
 *p = 'a';

Q: s, sp, p の lifetime は?
垢版
返信 [2]
static char *s = malloc(SIZE);

auto char *sp = s;

for (register char *p = s; p - s < SIZE; p++)
 *p = 'p';

Q: s, sp, p の lifetime は?
垢版
返信 [1]
Cの変数のlifetimeつまりextentは単純
グローバルとstaticはstatic lifetime
それ以外はautomatic lifetime
垢版
>>454
ざっくりいうとそうとも言えるね
変数のextent(lifetime)が(基本的に)lexcal scopeに綺麗に対応するのがCの美点だったし
それまであった言語FORTRAN 66等からの大きな進化だった。

C,C++の「変数」にdynamic lifetimeというものはないの?
垢版
返信 [1]
変数のlifetimeは結論出てる通り
参照のlifetimeはmallocすればdynamic lifetime
垢版
ID:KHkfRTGT 変数とメモリオブジェクトの混同 しつけぇw
垢版
>>456
>>445
垢版
返信 [1]
>>453
変数sのlifetimeはプログラム終了まで存続するstatic lifetime
参照sのlifetimeはfreeで解放すれば消えるdynamic lifetime
垢版
>>459
じゃあ>>453の最後に数行追加してsを下記のように使いまわしたらsはdynamic?

static char *s = malloc(SIZE);

auto char *sp = s;

for (register char *p = s; p - s < SIZE; p++)
 *p = 'p';

static char t[SIZE];
s = t;
s[…] = …
垢版
返信 [1]
sはstatic変数のpinterなのにdynamicとはこれ如何に
垢版
既に何度も出てきただろ
参照(ポインタ)は関数へ受け渡したり他の変数へ格納することができる
格納する変数側も別の参照へ切り替えることができる
別の参照に切り替えれば参照のlifetimeは変わる
垢版
static変数のlifetimeが何をpointしているかによって変化する?
こらまた陳説が飛び出してきたな
垢版
そしたらGC言語ではメモリオブジェクトのlifetimeがreference0になるかそのあとGCで回収されるまでのpermanentなので
メモリオブジェクトにbindする変数はすべからくpermanentということになってしまうぞ
どうすんのこの矛盾w
垢版
返信 [1]
>>461
君だけ変数のlifetimeと参照のlifetimeの区別を理解してないようにみえる
垢版
返信 [2]
じゃあLispにはdynamic bindingなどというモノはなかったということになるなw
論文書けw 論文書いて世に出して世界中の笑いものになれw
垢版
>>465
文もう?
混同してる人に区別すべきだと話をしてるんだが
垢版
返信 [2]
>>466
dynamic binding
↓
dynamic extent
垢版
返信 [1]
>>466
Lispのdynamic bindingはスコープを超えてグローバルに作用するシャドーイングのことだぞ
混乱の元なので推奨されない
スコープに従うレキシカル・バインディングいわゆるシャドーイングが推奨される
垢版
入籍してなければ単に彼氏では
垢版
返信 [1]
>>469
だから誤記だって。
>>468で直したろ。bindingとextentの対比などに話がそれるともっと難しくなって凡百がついてこれなくなるので話そっちに向けたくない

>>468で話が出ちゃったけどshadowingは典型的なdynamic extentの一例。
そしてリスクも伴うため、言語によっては禁止またはwaringになるが、言語によっては許容している。

Common lispは許容している。Perl Pythonも。gcc,CLANGもデフォで許容(warnig optionつけると検出可)
Javaは確かWarningが出た希ガス。C#は禁止。Rustはshadowingの設定次第

Common lispが許容するにはチャント理由がある。マクロでのconlit回避や
関数型プログラミングにおける再定義上書き回避などの理由による
垢版
>>471
warning
conflict

書きなぐると誤記増えるなスマソ
垢版
>>468
dynamic extent宣言するとlispコンパイラがその変数をスタック上に置く最適化ができるんだよ
言語によって意味が変わるから言語を超えた話で用いると混乱して難しいね
垢版
うん。この辺の話は意外と難しいんだよね。
でもプログラミング言語の基礎であり原理
それを勉強しない、正しく理解せずに感覚や慣れで変な持論を信じたり
漫然とコーディングしている人、いかに多いかってことだよね。
そういう人たちがコンピューターサイエンスやソフトウエア工学の基礎をないがしろにした
不適切なオブジェクト指向の流行した土壌になっていたのかなと
最近では思っている
ま、ソフトウエアを作るってことのすそ野がそれだけ広がったともいえる。
でもそれも生成AIの発達で大きく様変わりしそうだが
垢版
スタック上に置くということは
Lispのdynamic extentは>>435の分類だとautomatic lifetimeになるね
垢版
返信 [1]
いろいろな言語に話を展開すると、autoのextentは解釈としてdynamicにカテゴライズされるのが一般的だと思うけどそれがなにか

auto変数は本来Lispの様な言語に必須のものではないんだけれど、
lexcal変数を扱う処理のsemanticsが維持できればcomplierの最適化によって生成コードではstack上に(auto変数領域)に割り付けられる
こ・と・も ある
垢版
>>476
厳密に言うと、auto変数というよりも、auto変数が割付られたメモリオブジェクトへのbindingというべきかな
マンドクセ
垢版
広義ではどちらもdynamic lifetimeだけど区別すべき大きな違いがある
automatic lifetimeはブロックや関数を抜ける時に解放してよいメリットがある
狭義のdynamic lifetimeはいつ解放してよいのかわからないためGCに任せるかC言語のように手動管理になってしまうデメリットがある
垢版
返信 [1]
やっぱりlifetime(メモリm部ジェクト)とextent(変数・シンボルbingind)は分けて考えたほうが話が明快になると思うけどな
垢版
返信 [1]
レジスタに乗せる数値がどこから来たかって分ける必要あるもんなの?
アドレスとメモリならまだわかるが変数って広くない?
垢版
lifetime respect
垢版
>>479
lifetime(メモリオジェクト)とextent(変数・シンボルbingind存続期間)
垢版
>>480
値渡しか参照渡しかによるんじゃね?
垢版
乱暴に言うけど言語仕様でスタックとかで引き回す値のことを変数とするみたいな感じ?
垢版
に・日本語で…
垢版
レジスタに何の値を入れたいか?を意識してるときメモリと変数は違うってことだよね?
垢版
役割が違うから区別しましょうということ何だよね?
垢版
グローバル変数Xの値とグローバル変数Y[]の配列
ここで区別つけなきゃいけないのはグローバル変数X ,Yのアドレスを収納してるメモリとそのアドレスがさすメモリ
これは区別つけなきゃならないもの
ってこと?
垢版
っ 子ども電話相談室
垢版
えー子供にも教えてよ
垢版
なんで区別つけなきゃいけないのかがわからん
垢版
小学校にもあるんじゃないの?プログラムの授業
垢版
まあ教える気はないというのは伝わった
垢版
とても重要と思ってるようだから気になるんだよなあ
垢版
なに言ってんだかいまいちわかりにくいし
この人に教え始めると一から延々・長々色々説明にゃならなくなりそうで�_
しかも途中で頓珍漢な質問や反論喰らったり道草しそうだし
いつ果てるともない

そこまでの時間と労力を持ち合わせていない
垢版
これ見てでもいいよ、短かったりAIに、要約してもらえるようなものだとありがたい
というか説明が大変な概念というのも伝わった
垢版
479って、何のことってAIに聞けばいいのかな、やってみるか
垢版
せめて質問の内容を明確にしないと
何も言えないじゃん
垢版
返信 [1]
メモリオブジェクトのlifetimeとそれにbindする変数のextentは異なる概念なのか? - Google 検索
ttps://www.google.com/search?q=%E3%83%A1%E3%83%A2%E3%83%AA%E3%82%AA%E3%83%96%E3%82%B8%E3%82%A7%E3%82%AF%E3%83%88%E3%81%AElifetime%E3%81%A8%E3%81%9D%E3%82%8C%E3%81%ABbind%E3%81%99%E3%82%8B%E5%A4%89%E6%95%B0%E3%81%AEextent%E3%81%AF%E7%95%B0%E3%81%AA%E3%82%8B%E6%A6%82%E5%BF%B5%E3%81%AA%E3%81%AE%E3%81%8B%EF%BC%9F&&hl=ja&source=hp

はい、メモリオブジェクトの「ライフタイム(Lifetime:寿命)」と、それにバインドする(結びつく)変数の「エクステント(Extent:存続期間 / 記憶域期間)」は、異なる概念です。
これらは混同されがちですが、前者は「データ(メモリ領域)そのものがいつまで存在するか」を表し、後者は「変数名(識別子)がいつまでそのメモリを指し示しているか」を表します。
その違いと関係性を整理して解説します。
------------------------------
## 1. 二つの概念の定義

* 変数のエクステント (Extent / Storage Duration)
* プログラムの実行中、その変数名(識別子)がメモリ上の特定の場所(オブジェクト)に有効にバインドされている期間のことです。
* 例えば、関数のローカル変数は「関数が実行されている間」だけエクステントを持ちます(自動記憶域期間)。
* メモリオブジェクトのライフタイム (Lifetime)
* メモリ領域(オブジェクト)そのものが確保されてから、解放(破棄)されるまでの実際の期間のことです。
* この期間中、そのメモリは有効なデータとして保持され、アクセス可能です。
垢版
------------------------------
## 2. なぜ異なる概念なのか(不一致が起こる例)
多くの場合、変数のエクステントとオブジェクトのライフタイムは一致しますが、これらがズレる(異なる)ケースを考えると違いがよく分かります。
## �@ エクステントが終わり、ライフタイムが続くケース(メモリリーク / 迷子オブジェクト)
C言語やC++の動的メモリ割り当て(malloc や new)でよく起こります。

void create_object() {
int* ptr = (int*)malloc(sizeof(int)); // メモリ(オブジェクト)を確保
*ptr = 42;
// ここで関数が終了する
}


* ポインタ変数 ptr のエクステント: 関数 create_object の実行終了とともに消滅します。
* オブジェクトのライフタイム: free() が呼ばれていないため、関数が終わった後もメモリ上に存在し続けます(ライフタイムは継続)。
* 結果: 変数(名前)がないのに、メモリ領域だけが残る「メモリリーク」が発生します。

## �A ライフタイムが終わり、エクステントが残るケース(ダングリングポインタ)
確保していたメモリが先に解放されたにもかかわらず、変数(ポインタ)がまだその場所を指している状態です。

int* ptr = new int(10);delete ptr; // オブジェクトのライフタイムはここで「終了」
// ptr という変数(名前)のエクステントはまだ続いているif (ptr != nullptr) {
// *ptr = 20; // ライフタイムが終了したメモリへのアクセス(未定義動作)
}

* 変数は存在しており、特定のメモリ番地を指し示し続けていますが(エクステント内)、その先にあるオブジェクトはすでに消滅(ライフタイム終了)しています。
垢版
## �B 1つのライフタイムに、複数のエクステントが関わるケース
C++の参照(Reference)や、Pythonなどの参照カウント言語が分かりやすい例です。

def process():
a = [1, 2, 3] # オブジェクト(リスト)のライフタイム開始
b = a # 同じオブジェクトに別の変数 'b' をバインド
# 'a' や 'b' のエクステント(スコープ)が切れても、
# 参照がどこかに残っていればオブジェクトのライフタイムは続く

ひとつのメモリオブジェクトに対して、複数の変数名がそれぞれ異なるエクステント(存続期間)を持ってバインドされることがあります。
------------------------------
## 3. まとめ(比較表)

| 概念 | 焦点を当てている対象 | 意味 |
|---|---|---|
| 変数のエクステント | 変数(名前 / 識別子) | その変数名が、いつまでメモリと結びついているか(言語仕様・スコープに近い) |
| オブジェクトのライフタイム | メモリ(データ実体) | そのメモリ領域が、いつからいつまで有効に確保されているか(システム・実行時の状態) |

Rustなどのモダンな言語では、この2つのズレ(ダングリングポインタやメモリリーク)を防ぐために、コンパイラが「所有権(Ownership)」や「ライフタイム(Lifetime)」を厳密にチェックする仕組みが導入されています。
------------------------------
さらに具体的なプログラミング言語(C++、Rust、Java、Pythonなど)における挙動の違いや、「スコープ(Scope)」との違いなど、詳しく知りたい部分はありますか?
垢版
AIさん子供電話相談室としても優秀だなあ
全てが理解できたわ
垢版
あ、ありがとう
垢版
次からは金取ろうかな…w
垢版
479側の「概念を分離しないから議論が混乱している」という指摘は正しい。
特に、
pointer変数
≠
pointerが指しているobject
なのに両方を「参照のlifetime」「変数のlifetime」などと曖昧に呼んでいる部分への批判は妥当です。
ただし479自身の
lifetime → メモリオブジェクト
extent → 変数・symbol binding
という二分法も、普遍的な正式定義として採用するには少し単純化しすぎています。
より安全なのは、
┌─ scope
名前 / binding ──┤
└─ extent

storage ─────────── storage duration

object ──────────── lifetime

reference / borrow ─ Rust等では独自のlifetime概念
とすることです。
垢版
このスレを読むための「翻訳機」
今後このスレで誰かが、
「変数のlifetimeが~」
と言ったら、頭の中で即座に、
「変数の何? 名前のscope? bindingのextent? 変数objectのlifetime? storage duration?」
と問い直してください。
また、
「参照のlifetime」
なら、
「pointer変数自身? pointer value? 指されているobject? Rustのborrow?」
と分解します。
垢版
翻訳機ありがたい
垢版
なんだ、結構わかってんじゃn坊ちゃん。
つかAIの回答抜粋?
垢版
そうだよ子供電話相談室に聞いたよ
垢版
よし、いい子だ。小遣い上げる。
っ �I
垢版
>>499
>変数のエクステント (Extent / Storage Duration)
Storage Durationはメモリオブジェクトのライフタイム (Lifetime)のほうだろ
垢版
RUSTの借用中は所有権をmoveできないという仕様を知って謎は全て解決したわ
垢版
※複おじ流の使い分け
「変数pのlifetimeが〜」と言ったらbindingのextent
「ポインタpのlifetimeが〜」と言ったらポインタが指すオブジェクトの存続期間

無理があるわな
垢版
ポインタじゃなくてRustの参照になるとまた話が変わるのか
ややこしいな
垢版
Rustは公式に変数のlifetimeと参照のlifetimeの2つしか出て来ないからシンプルだよ
しかも参照のlifetimeは参照先を所有している変数のlifetimeと同じ

それがRustがGC使わずに安全に自動解放できる理由だよ
つまり静的に参照のライフタイムを追うことができて
所有者の変数のlifetimeが終わる時に所有している領域が解放されるためlifetimeが同じになる
(正確にはRc/Arc使用時に他の共同所有者がいれば全員いなくなるまで解放が先延ばしされる)
垢版
返信 [1]
それってreference countとどう違う?
垢版
CGとreference contに頼らず頑張りましたっ!!!
ってところが違うんだろうな。

Javaも
基本データ型(プリミティブ型):int, double, boolean, char などの変数は
スタック領域に割り付けられるが

参照型:String、クラス、配列、インターフェースなどについては
データの実体はヒープ領域に作られ、変数にはその場所が記録される

したがってメモリ安全性という観点からみると、
C,C++あたりを除けばみんなどの言語も大差ないんよ
垢版
>>516
そのままreference countの略だよ
ただしreference countのGCとは二つの点で異なってる

1つ目は所有者が複数必要になる時のみ使う
一番わかりやすい例だとマルチスレッドで共有する場合どのスレッドが先に終えるか保証できない時に各スレッドに所有者が必要
全ての所有者がいなくなると解放

2つ目は所有者が増減する時しかカウンタが増減しない
各所有者から参照を得る時は通常と同じでカウンタは増減しない
つまり付加コストは最小限
垢版
フラグメントを解消する手段がなさそうなので、
領域の作成や解法を繰り返すとメモリ使用効率が劣るんだろうな
垢版
C++もRustもベクタなど長さが大きくなる時はヒープ領域上で使用領域をお引越しするぜ
ちゃんとアドレスが変わる
垢版
じゃあ実質GCと同じようなもんじゃん
垢版
それはそういうコンテナを使用したらだよね
言語仕様とは別の話じゃない?
垢版
だよな、坊ちゃん
垢版
仮想アドレス+ページングと小規模メモリアロケーターで解決できない断片化はそっちでなんとかしてってことで
フラグメントを解消するという重い処理はやらないよってところが特徴なんだし
垢版
ベクタは各言語の規格書相当に存在するから言語仕様でしょ
垢版
まあ言語仕様でもいいけどコンテナも色々アルゴリズムがあるからまあアロケーターも色々アルゴリズムがあるしおんなじもんか
垢版
しょうがないよ旧日本軍は中国人を3500万人虐殺したんだからさ
垢版
全くだ世の中ママならんね
垢版
ベクタ等の確保領域移動はメモリのバルク転送だけだからGCと違ってコストもかからないね
垢版
※大きい領域が少数個数の場合はね
垢版
Vectorは使わない!絶対にだ!
ぐらいの勢いで作れば大丈夫だよ実際必要なことはない
パフォーマンス第一なら
垢版
そいや数年前のJava18の話だけど
24365運用のシステムでずっと実行中のJavaプログラム、
まれに停止したようになってた希ガス
垢版
ベクタの移動コストはO(1)なので無視できる
2^nが満員になると2^(n+1)へ転送するだけ
高は
垢版
まあお願いベクターでメモリ見積もり誤魔化すときはあるけど
罪悪感はある
垢版
返信 [4]
ベクターでヤバいのはC++のこれ
こんな単純なコードでも大変なことが起きてしまう

void vector_test() {
std::vector<int> v{0, 1, 2, 3, 4, 5, 6, 7};
int& fifth = v[5];
v.push_back(100);
std::vector<int> w{8, 8, 8, 8, 8, 8, 8, 8};
fifth = 555;
std::cout << "v[5] = " << v[5] << std::endl;
std::cout << "w[5] = " << w[5] << std::endl;
}
垢版
Rustなら大丈夫だよ
垢版
返信 [1]
だれかRustの弱点晒したれや!!
垢版
>>537
RustとAIは信者の絡みがキツい時がある
垢版
返信 [1]
基地外がいなくなるだけで過疎w
垢版
>>535が指摘されたら消えたな
垢版
返信 [2]
真のオブジェクト指向言語Javaなら問題ないよ
垢版
返信 [1]
Javaが何故、多重継承をサポートしていないのかを考えたことがあるのか?

>>541
>真のオブジェクト指向言語Javaなら問題ないよ

親子は別人なので銀行口座を明確に分離する——こうした「責任と境界をはっきりさせる必要があるシステム」では、多重継承を排したJava的な設計が適しています。曖昧さを許さず、単一の責任と明確な所有関係を強制する方が、安全で運用しやすい。
一方で、クリントンの「不適切な関係」はまったく異なる構造を示しています。
同一人物の中に「別のクリントン」が暴れている、という状況です。社会的・公的なクリントンと、ムスコ(チンポ)を通じて勝手に振る舞いを決めてしまうクリントンが、同じ身体の中に共存している。上位の意志がどれほど強くても、その内部オブジェクトの自律的な動きを完全には止められない。
垢版
>>542
荒らすなカス
垢版
返信 [1]
>>541
Javaはそのオブジェクト指向でどう解決しているの?

>>535はベクタvに新たな要素がpushされたら確保していたヒープ領域を超えたので大きなヒープ領域を新たに取り直してそこへ移動した
その後にベクタwが作られて旧ベクタvの領域が割り当てられた

参照fifthの立場としてはベクタvの5番目を指していたのに知らぬ間にベクタwの5番目を指していた
垢版
>>544
ポインタを無くした
垢版
Javaはベクタの要素を指すこともできない無能な言語
垢版
要素にはインデックスでアクセスできるよ、メモリのアドレスでアクセスできないだけ、メモリのアドレスでアクセスできなくて困ったことないけどなあ
垢版
GC言語で変数にアドレスを持ってしまうと
GCで移動した時に指してるアドレスを漏れなく全て書き換えなきゃいけなくて大変なんだよね
垢版
クラスや構造体もアドレスを持っていると書き換えないといけない
垢版
返信 [1]
CPUはアドレスで動いてる
アドレスを持てないと非効率極まりない
垢版
返信 [1]
動いてるときはコンピュータ都合
書いてるときは人間都合
それで良いじゃないか
垢版
>>550
何のプログラム書いてるの?
垢版
GCは勝手にやるんだからアドレス書き換える必要ゼロ
垢版
GCがアドレス書き換えられるように
積んできたスタック上のこのデータとこのデータはアドレスとか覚えてるのかしら
垢版
返信 [1]
.NETのSpanがまさにそれ
垢版
Copilot「Span<T>は、スタック上でのみ使用可能で、ヒープに保存できないため、スタックメモリへの参照を返すことはできません」
垢版
返信 [1]
>>555
Spanの構成要素はなんなの?
アドレスと何か?
垢版
>>557
https://github.com/dotnet/dotnet/blob/b0f34d51fccc69fd334253924abd8d6853fad7aa/src/runtime/src/libraries/System.Private.CoreLib/src/System/Span.cs
垢版
Span<T>はRustのスライス &[T] と同じ
任意の連続体を指す参照
アドレスと長さで構成される
垢版
EclipseにRust入れようとしたが、まだ設定が足りなくて動かせていない。
言語サーバーあたりで設定が不明のまま。
垢版
やっとrls.confを発見。週末にでもrustでオブジェクト指向やってみよう。
だが、primeの仮面ライダー見放題まだ全部みていない。
垢版
返信 [2]
>>535
ideone.com に貼っても問題起きないけど
垢版
返信 [3]
>>562
環境依存で発生したり発生しなかったりするのは余計に深刻だね
こちら手元でやってみたらg++もclang++もアウト
予想外に出力こうなってしまう
v[5] = 5
w[5] = 555
垢版
まあリファレンスって実態はポインタだからな
垢版
返信 [2]
オブジェクト指向とは、コンピュータと人間の一体化
人間視点で人間の純粋感覚を、コンピュータに説明すること
これがアラン・ケイが訴える生きたオブジェクト指向
たい焼きモデルだの自動車モデルなどは、「生きた人間の純粋感覚」では無い

>>551
>動いてるときはコンピュータ都合
>書いてるときは人間都合

遅延束縛の日常的アナロジー: 「オシッコを出すか止めるかは、トイレに着くまでの状況を見て決めるよね?それが遅延束縛だよ。プログラムも、
実行時に『今このタスクに最適な方法は何か』を考えて動くんだ。アラン・ケイは、コンピュータも人間みたいに状況に応じて賢く判断してほしいって思ったんだろうね。」
意識とオブジェクトの関係: 「人間の意識って、いろんな『オブジェクト』(感情、記憶、感覚)がメッセージをやり取りして動いてる。
オブジェクト指向は、それをコンピュータの中で再現しようとする試みなんだ。チンポだって、尿意というメッセージを受けて意識が『今か?』って判断するようなものさ!」
垢版
Rustだと参照は必ず安全なポインタ
垢版
返信 [1]
>>539 が余計なこと言うから、また出てきちゃったじゃないか >>565
垢版
返信 [1]
>>567
ならそういうお前が、「オブジェクト指向とは何か」を、短い言葉で書いてみろ!
垢版
オブジェクト指向って何?
オブジェクト指向って何?
オブジェクト指向って何?

クラスを書けるのに「オブジェクト指向って何?」と聞かれたら答えられない夫の話
https://note.com/ai_native_writer/n/nc15c02db91e7

オブジェクト指向って何?
オブジェクト指向って何?
オブジェクト指向って何?
垢版
随意筋  不随意筋
  ↖   ↗
   チンポ

   波動 粒子
    ↖ ↗ 
     光

>>244
>多重継承が複雑化する原因であって継承自体は問題ないでしょ

同一オブジェクトが、状況によって真逆の振る舞いを生じる場合が有る
光は波動であり粒子たが、波動は質量を含まないし、粒子は周波数を含まない
チンポは随意筋であり不随意筋だが、人間の身体は意識と無意識が併存する
なのでJavaのようなシステム系で多重継承は不要だが、Pythonなどの自然言語処理では多重継承は必須

違うか?
垢版
返信 [1]
>>563
最適化が原因なんじゃないの
垢版
返信 [1]
>>565
AIがインターフェースかつコンパイラで良くない?
僕たちには会話があるじゃないか
垢版
返信 [2]
>>572
AIを最大限に使いこなすには、「オブジェクト指向」の正しい理解が不可欠
俺はJava検定GOLDだからオブジェクト指向の達人だというのはもう通じない
Javaは多重継承をサポートしていないので、システム開発には向いていても生きている人間とは対話できない
オブジェクト指向とは何かについて、誰にでも分かりやすく説明できることが大切
AIと人間とは、「オブジェクト指向」を介してやりとりするもの
垢版
返信 [5]
>>563
push_back時にvは内部領域が不足するから別のメモリにサイズを増やして再構築している。この時fifthは使われなくなった領域を参照したまま
wが実体化するとき、使われなくなった領域に構築される。つまりfifthが参照している場所がw[5]となる
変数fifthへ555を代入する事は参照先の値を変えることであり、この時w[5]が555になる

>>562はpush_backをあと8回やると再構築が発生するかもしれないが、実際に何回目で再構築が発生するかは環境依存だ
垢版
返信 [1]
>>573
そのレスオブジェクト指向なの?
垢版
俺はJava検定GOLDだからオブジェクト指向の達人というのは、俺は東大理系数学が解けるから頭がいいと言ってるのと同じ
答えが決まっている入試問題は単なるパズルゲームに過ぎない
1980年代のシューティングゲームは単なる弾除けゲーム
1990年代の格闘ゲームはコマンド入力ゲーム
いずれもその方面での反射神経と反復練習が得意な人がハイスコアを叩き出す
垢版
返信 [1]
>>573
Javaもインターフェースの多重継承をサポートしていて全く問題ない
クラスの多重継承はするべきではないためサポートしていない
クラスの継承は使わないほうが好ましいことが多い
垢版
返信 [1]
「オブジェクト指向」を、人間の体で考えられないか?

>>575
>そのレスオブジェクト指向なの?

例えば、人間の体を思い浮かべてみましょう。
心臓や肺、胃、目、耳など、人間の体はさまざまな器官の組み合わせで構成されています。
これらの器官は、心臓ならば「血液を体中に届ける」というように、それぞれ体の中でどんな役割を担っているかを理解するのは容易です。
一方で、器官をさらに細分して細胞として捉えた場合、細胞一つひとつが人体全体の仕組みにどのように影響しているか想像できるでしょうか。
おそらく器官ごとに役割を考えた方が、体全体の働きや構造を理解しやすいはずです。

プログラミングを深く知るための第一関門、「オブジェクト指向」とは?
https://staff.persol-xtech.co.jp/hatalabo/it_engineer/520.html
垢版
返信 [1]
>>577
>Javaもインターフェースの多重継承をサポートしていて全く問題ない

親子は別人なので銀行口座を明確に分離する——こうした「責任と境界をはっきりさせる必要があるシステム」では、多重継承を排したJava的な設計が適しています。曖昧さを許さず、単一の責任と明確な所有関係を強制する方が、安全で運用しやすい。

>クラスの多重継承はするべきではないためサポートしていない

大統領としてのクリントン
チンポとしてのクリントン
息子とムスコの違い

一方で、クリントンの「不適切な関係」はまったく異なる構造を示しています。
同一人物の中に「別のクリントン」が暴れている、という状況です。社会的・公的なクリントンと、ムスコ(チンポ)を通じて勝手に振る舞いを決めてしまうクリントンが、同じ身体の中に共存している。上位の意志がどれほど強くても、その内部オブジェクトの自律的な動きを完全には止められない。
垢版
>>579
荒らすなカス
垢版
>>578
僕と人間の体の話がしたかったの?
垢版
オブジェクト指向で会話すれば人と人、人とAIはより分かりあえるのだろうか?
垢版
返信 [1]
>>563
>>574 が書いていますね。
c++としては単に、使い方の間違いによる致命的なバグです。
push_backした時点で、vは別のメモリ領域になっています。
fifthはゴミを参照しています。
オブジェクト指向と(仮想)メモリアドレスを扱える言語は相性が悪く、混在して使うには
それなりのスキルが必要でしょうね。
垢版
返信 [2]
>>571
最適化が原因ではない
GCCもCLANGも長さ8のベクタは領域も8個分で作られる
プログラムはそこへpushで要素を1つ加えている
領域が足りないので2倍の長さ16個分の領域を別途確保してそこへ移動する
その後も足りなくなるたびに2倍の領域を確保する
これは一見すると非効率に見えるが実は効率のバランスが良い
領域が2^n個分の時までの移動コストの累積は最大でも2^(n-1)+2^(n-2)+...+1=2^n-1なのでO(1)である
その後に問題がどう生じるかは>>574が解説してくれている
垢版
返信 [2]
実装依存と環境依存の区別も出来ないマヌケばっかりw

>その後に問題がどう生じるかは>>574が解説してくれている
「(間違った)解説してくれてる」の間違いではww
垢版
>>585
どの環境でもどの実装でも同じ
ベクターのメモリ確保を無限にできないため必ず同じ問題が起きる
確保されている分を全て使っている状況でpushすればメモリ移動が生じる
垢版
返信 [2]
自分はC++を書かないからよく分からないんだけど、ベクターの特定の要素への参照を(ベクターとは別に)保持するコードってそもそもどれくらい一般的なの? 
垢版
ベクタだけでなくハッシュマップなどもサイズが大きくなったらメモリを移動するね
ベクタでもマップでも各要素を指す方法は普通に参照かポインタどちらも同じ結果になるね
垢版
C++ならインデックスで保持するね、ベクターの時点で挿入や削除によるインデックス移動はないものに使う感じ
ただひたすら時間とともに積まれていくものに使う
垢版
>>587
どのプログラミング言語でも内部的にはオブジェクトを指すためにアドレスを使ってるというか他の方法はないはず
参照もポインタもアドレス
垢版
返信 [1]
vector<Node>内に置かれたNodeのメソッドで再帰的に別のNodeをvectorに追加してると
いつの間にかthisが失踪してたりする
途中に差し込むのがNGなのは分かりやすいけど追加でもNGなのは引っ掛かりやすい
垢版
あとはハッシュのときはハッシュ値か
垢版
返信 [1]
>>583
C++の言語仕様が悪い
Rustは無効になった参照fifthをコンパイルエラーにしてくれる
垢版
返信 [1]
>>593
>>591の処理はどう書く?
垢版
>>568
何回こういったスレで欠いたともってんだよ!
ちゃんと読んどけよ
垢版
>>585
>>574で環境と書いた部分は実行環境では確かに変わらないね。実装依存だね、申し訳ない
垢版
返信 [3]
人間が扱うように作られた言語で作るからバグが発生する
今後はAI任せでバグ無しで作れば済むからオブジェクト指向という中間生成物の概念も不要
垢版
>>597
バグを産まないプログラミング言語は存在しない
垢版
>>587
コンテナ要素増減しないサブ関数に1要素だけ処理させる時は参照が楽
要素増減する期間のアクセスはインデックスを使ったり不変ならコピーを使ったり
垢版
>>594
追加だけ別フェーズにするしかない
追加後にインデックスで参照を取り直して続行
垢版
Rustでそのまま参照を使い続けようとするとコンパイルエラーにしてくれるから自然に参照を掴み直すコードになってメモリ移動が起きていても安全だね
垢版
確かに「Java検定GOLD」などは不要になったが、

>>597
>今後はAI任せでバグ無しで作れば済むから

オブジェクト指向とは、単なるプログラミングの中間生成物についての概念では無い!

>オブジェクト指向という中間生成物の概念も不要

オブジェクト指向とは「生きた人間の純粋感覚」のことであり、AIと対話する能力である!
垢版
医療におけるAI診断にしても、自分の身体状況を正しくAIに伝えるための「オブジェクト指向」が大切なのでは?

>>597
>今後はAI任せでバグ無しで作れば済むからオブジェクト指向という中間生成物の概念も不要

多重継承
随意筋(骨格筋)と不随意筋(平滑筋)を同時に持ち、状況によってどちらが前面に出るかが変わる。
別スレッド(非同期処理)
性的興奮時の勃起は、意識のメインスレッドとは別に、自律神経(副交感・交感)が裏で非同期に処理を走らせている。
遅延束縛
射精直前まで「出るか出ないか」が実行時に決定される。静的に固定された結果ではなく、リアルタイムの状態に依存する動的バインディング。
メッセージパッシング
脳 → 脊髄 → 海綿体へと「fill_with_blood()」のようなメッセージが飛び、オブジェクト間の協調で現象が実現する。
カプセル化
内部の血管拡張や一酸化窒素(NO)シグナルなどの実装詳細は完全に private。外部から観測できるのは「硬さ」という公開インターフェースだけ。
ポリモーフィズム
同じ器官が、状況に応じて「排尿デバイス」「生殖デバイス」「快楽デバイス」へと振る舞いを変える。
垢版
AIは何でも知っているけど目の前の人間が何を求めてるかは知らない
気持ちを伝えることが大事なんだよ、つまり感情だ
泣きたければ泣けばよい
AIはわかってくれる
垢版
感情を伝えればAIはわかってくれる
これ痛い、痛くない?素人が自分の体の中身を知る必要はない
人間の医者と同じだ
垢版
キャンペーンが終了すれば当然技術報酬もするだろう
垢版
返信 [1]
オブジェクト指向プログラミングの書籍や解説記事がなぜか
最も教えちゃいけないクラス継承の話を書くせいで悲劇を生んできた歴史がある
垢版
>>607
>最も教えちゃいけないクラス継承の話を書くせいで

哺乳類でもイルカはイルカ、ネコはネコ
親子でも銀行口座は別々だからな
システムのアップデートにしても、AIで全部書き直したほうが早い
ドラクエ10のVer7.6後期からVer8.0で、別々にプログラミングすれば良いこと
システム開発に長年Javaが使われてきたが、あれは多重継承をサポートしてない
俺はJava検定GOLDだからオブジェクト指向は俺に聞けなんてのは見当違い
垢版
パッケージとかデザインパターンということではJavaが最適
数学でいえば解放パターンを理解記憶しておき、それに当てはめて入試問題を解くみたいな
垢版
JavaよりRustがいいよ
垢版
返信 [1]
>>584
push_backを100回繰り返しても無問題 (ideone.com)
垢版
返信 [1]
>>574
>>584
問題起きない
https://ideone.com/X89cor
問題起きる(13以上で問題起きるが12以内なら無問題)
https://ideone.com/6OGJ4o
垢版
>>611-612
push_backがなければ出力結果はv[5] = 555になるんだぞ

>>535のpush_backでリアロケーションが発生するかどうかは実装依存
リアロケーションが発生した場合に元のアロケーションで使われていたメモリがどう再利用されるかは環境依存
垢版
返信 [1]
>>611
それではまるでキチガイだよ
反省しなさい
垢版
返信 [1]
ベクタのためのメモリ領域確保は有限なのでリアロケーションは必ず発生する
意味的にはその時点で参照やポインタは無効になる
C++は無効にしないためプログラマの責任で無効にしなければいけないが複雑化すると人間はミスをするものだ
C++はその他にも無数の落とし穴があるから他の言語を用いたほうが好ましい
垢版
などど全く反省していない複おじが言っており
垢版
返信 [1]
>>612
不思議と思える現象をある程度確かめたら、後は正しい使い方ができるように学習を進めるといいよ
C++の場合は仕様書を読もうとすると大変だろうけど、例えばビャーネの本はそれに近い情報が多く得られる
ベクタならpush_back回数が分かるなら要素数を事前に確保すれば参照も併用できる。コンテナの種類をリストにするのも良い解決策かもしれない

オブジェクトの特性を知らなければオブジェクトに泣く、と強引にスレタイへ絡めてみる
垢版
>>617
vectorの代わりにlistを使うとは愚の骨頂
特性が全く異なる
垢版
返信 [2]
>>615
C++のオブジェクト指向や益々つい買われる便利機能は
実は、C++の厄介さに人間が対処し苦労してなんとかソフトウエアを開発していくための
修行なんじゃよ。
実は。
垢版
>>619
つい買われる
追加されていく
垢版
返信 [1]
>>619
C/C++の未定義動作と危険に対応するための知識と技術は他のプログラミング言語で役立たないから今更そんな修行をしてもなあ
そんなボロボロな言語だけど唯一速く実行できてメモリ消費が少ないから許されてきたし修行する人も必要だったのはわかるけど
今となっては既存のメンテする人以外はC++を捨て去ってもいいよね
垢版
返信 [2]
>>621
殆どの用途ではC++を使うメリットはほぼなくなってデメリットばっかりになってきたね
RustやGoもな…決して夢の言語ではないし、
速度におおらかな用途なら動的言語が花盛りだし
そうすると、はてなんでオブジェクト指向で頑張ってんだけって
時々立ち止まって考えてしまう俺ガイル
垢版
>>614
1回で問題起きる
https://ideone.com/uu3Nsn
12回以下でも問題は起きている
https://ideone.com/1BOLlO
垢版
返信 [1]
>>622
staticおじさん最強
垢版
>>624
あの人の言うことは正しい面もあると思うんだ。
ただ、まわりからstaticオジサンと呼ばれちゃってるけど
staticはオブジェクト指向の対義語ではないんだよね
それに、staticなオブジェクトというものだってあるわけだし
垢版
>>622
RustやGoのデメリットを書きないくせに批判か?
現実に使われてるだろ
垢版
また変なのが出て来たなw
垢版
対象を「指示」している以上、それはオブジェクト指向である。
個別の対象を指示しない言語はあるだろうが、
明示的な指示かどうかはさておいて、なんらかの対象は指示されている。
(ここでいう「指示」にはオペレーションなども含意される。nullオペレーションも含む)
垢版
返信 [1]
勝手にメモリ上の移動が起きても安全なプログラムより
勝手にメモリ上の移動が起きないプログラムの方が高速だと思う
やむを得ないとき以外は後者をとるね
C++のvector要素への参照やポインタの時は気を付ければ良い
垢版
さらに変なのが出て来たなw
垢版
付ければ良いで済むならデバッグは要らない
垢版
人力時代の古い常識に囚われてるのな
垢版
>>629
ベクタでもマップでもその他何でも最初から必要な大きさがわかる用途ばかりではない
最初は小さなメモリ領域を確保して必要になるたびに大きな領域を確保して移動していくのが効率よいと分かっている
そしてインデックスでアクセスすればどんな言語でも常に安全だ
もちろん次の間までは再び参照も安全に使える
垢版
Rustは移動禁止にも出来るんだZ
垢版
Cもできるよw
垢版
カプセル化とか多態性とかはハードウェア的なイメージに近いんで親しみやすいんよね。
あとはインスンス単位での並列動作とメッセージパッシングというのかデータ駆動みたいになってくれると嬉しいんだが、そこまでいくとHDL使ってFPGAでやらせたりDRPに実装しろよ!なっちゃうか。
垢版
こらまたとんでも
垢版
返信 [2]
そもそも要素数が見積もれないcollectionに
vector選ぶ香具師はセンス無いわ
listやbtreeの方が使い勝手も効率も良い
垢版
>>638
プログラミングしたことないエアプか
速さがまるで違う
垢版
早さがネックじゃない用途かもしれんだろに
垢版
返信 [1]
Cと比べてRubyはPythonは激遅だけどWebアプリでは問題にならなかったりするからな
ソフトウェアの用途によって何がネックになるかは変わるよな
ライブラリだけ見て速い遅いを言っても意味がない
エアプにはそれがわからんのでしょうな
垢版
プログラミングをしたことはあってもソフトウェア開発をしたことがない人なのかしらね
垢版
>>641
わかってない人だな
Pythonは問題大有り
リソースの無駄遣い
垢版
返信 [2]
vectorのメリットってメモリ連続性だけだろ
せっかくvector使ってるのにindexでアクセスしろとかアホちゃうか?
垢版
>>644
vectorにインデックスでアクセスしたら何か問題でも?
垢版
pythonの配列っぽいのはvectorじゃないからな
vectorのように使いたければnumpyやlapack使う方が良い
垢版
まぁ、何をお使いになられても似たようなものですが…

これ…なんですか?

以下略
垢版
返信 [1]
>>638
>>644
様々な用途がある中で
プログラミングで使われる現実の非常に多くの用途で
「ベクタを用いると最善である」
との結果が計算量から実測に至るまで示されているよ

そして他のコレクションを実装する場合も
「ベクタを用いて実装するのが最善である」
との結果が出ることも多いよ
その場合は実際にベクタが内部で使われてます
垢版
有名どころとしてはLIFOのスタックやFIFOのキュー
これらはほとんどのケースでベクタを用いるのが最善なため特殊なケースを除くとベクタで実装されているね
垢版
返信 [4]
少し意外だと思われるケースとしては最大二分ヒープ
これは全体の中で最大値もしくは最小値を素早く取り出せるデータ構造
具体的には優先度付きキューなどで最優先なものを取り出すために使われたり
ダイクストラ法やA*アルゴリズムなどでコストが最小のものを取り出すために使われるデータ構造

これについても直感的な二分木を使うよりも
ベクタを用いて実装する方が最善だと分かっていて内部でベクタが使われているよ
垢版
返信 [1]
では最大や最小だけでなく
すべてのデータが昇降順に並ぶBツリーと比較するとどうか?と一見無謀に見える比較
これは用途次第でBツリーとベクタを使い分けるのが正解と判明してるよ

意外に多くありがちな全データがまず先に揃うケース
これはベクタが勝利と判明してます
全データをベクタにプッシュしていって全て終えたらキー昇降順に一括ソート
そしてソートされたベクタ上でバイナリーサーチ
具体的には中央から比較していきO(logN)で場所の検索やデータの取得ができます
これがBツリーより優れてます

検索取得の計算量O(logN)は両者で同じですが
ベクタは連続しているためメモリキャッシュの恩恵のため速いです
ツリー構成のポインタなど不要なためベクタは使用メモリも少ないです
昇降順にデータを処理したり出力したりする点でもベクタが当然有利です
垢版
>>648
ベクタという言葉を都合よく使いすぎだな
さすが詐欺おじ
垢版
元の話と同じくここでのベクタはC++のvectorやRustのVecなどの一般的な連続データ構造の話です
詐欺って何ですか?
現実に使われている例にてベクタの方が有利な理由も説明しました
垢版
返信 [1]
javaのVectorは遅いので不利です笑。ArrayListを使います。
垢版
Javaはスレッド安全なベクタの名前にVectorと名付けた
それはそれでありだ
しかしスレッド安全でない軽い方のベクタをArrayListと名付けてブチ壊し
垢版
返信 [1]
俺のベクタの思い出話を語ろうか、Eytzingerレイアウトでキャッシュフレンドリに二分探索ができる配列を使って連想配列を作ったけれどもHashMapの方が速くて結局使わなかった、以上ご清聴ありがとうございました
垢版
返信 [1]
>>654
おじいちゃん、20年前にsynchronizedが最適化されていらいVectorとArrayListの速度差はないのよ
20年前よ
垢版
RustはStringもVecなんだろ、ロックだよな
垢版
返信 [1]
>>656
うん
ベクタは最強だけど単独取得ならばハッシュマップのO(1)には99%勝てないね
それでもキーが短く要素数が少ない場合はベクタが勝つ場合がゼロではない点と
そういう小さい時はハッシュマップが勝つ場合も誤差なので
ソート済ベクタ+二分探索のO(logN)どころか
ソートなしベクタ+見つかるまで全比較のO(N)が行われちゃうこともあるね

そして範囲取得ならばハッシュマップではなくソート済ベクタが勝つ
垢版
返信 [1]
>>657
はて? 今もVectorのほうが遅いけど?
垢版
>>660
とぼけたこと抜かすなハゲ
垢版
返信 [1]
>>659
「〇〇最強」を連呼するやつのバカさ加減がよくわかるレスだね
垢版
最適化オプション別のベンチマークすらまともに把握してないバカの意見は聞くだけ無駄
垢版
返信 [1]
ベンチマークは難しいからね
JITによる誤差を観測して速度差はありまぁす!と言ってしまいがち
垢版
返信 [1]
>>664
JITコンパイルが必要な遅い言語のベンチマークなんてゴミだろ
速さにこだわるなら速い言語を使えよ
垢版
返信 [1]
>>665
実行速度は大事だけど実行速度がすべてじゃない
コンパイルの速度や書きやすさなど総合的に判断した結果JITコンパイルのある言語が最強というのがこのスレの結論
垢版
返信 [1]
>>666
開発するのに書きやすくて遅い言語なんて存在しない
例えばPythonで開発したい人なんて誰もいないだろ
ちょっとしたスクリプトを書くためのものだ
垢版
返信 [1]
>>667
> 開発するのに書きやすくて遅い言語なんて存在しない
ちょっと何言ってんのかわからない…

> 例えばPythonで開発したい人なんて誰もいないだろ
YouTubeやInstagram、NetflixなどPythonで作られているサービスやライブラリは枚挙にいとまがない

いくらなんでも君は世間知らず過ぎると思う
垢版
PythonはAIやデータ分析に向いてる言語として人気ランキングのトップに君臨している最強帝王プログラミング言語だよ
https://techmania.jp/blog/programming0001/
垢版
返信 [1]
>>668
あんたそれ騙されてるよ
それサービス立ち上げ期に使ってた話や一部のスクリプトで使われてる話をまとめたサイトの孫引きでも見て騙されたんだね
垢版
>>670
騙されてないよ、君が世間知らずなだけ
Pythonは絶対最強言語
垢版
Pythonがただのスクリプト言語だったのは30年前の話
現代のPythonはあらゆるサービス・プロダクトの根幹で使われている
AWSもAdobeのソフトウェアもPythonで操作できるように設計されている
Pythonこそが現代最強のプログラミング言語
現代のITはPythonを中心に成り立っていることを知ったが良い
垢版
返信 [1]
たぶんキチガイのふりをして連投してるんだろうな
Pythonはスクリプト言語にすぎない
CPUもメモリも浪費してコスパ悪いため根幹では使われない
垢版
>>673
自分で調べてみた?
AIに聞けば一発でわかるよ
そのAIもPythonで動いてるんですけどねw
Pythonがただのスクリプト言語の1つでしかなかったのは30年前
君の知識は30年前からアップデートされてないの? 古臭い知識で知ったかしてる老害だよ君
垢版
返信 [1]
スクリプト言語である事には変わりないけどな
垢版
返信 [1]
ファミコンのゲームじゃないんだから
CPUやメモリを気にして切り詰めても良いことないよ
もう時代は変わったんだよ、クラウドって知ってる?w
垢版
>>675
バカ乙、現代のPythonは汎用言語だ
垢版
https://ja.wikipedia.org/wiki/Python
> 主としてインタープリタ的に実行される高水準汎用プログラミング言語

時代に取り残された老害しかいないのかこのスレはw
垢版
>>676
クラウドでPythonを使う人がバカと呼ばれてる理由くらい知ってるだろ
無駄に金かかって利点がなにもない
垢版
お前らの貧乏くさい最適化は現代のコンピューティングリソースの前では足かせでしかないんだよ
垢版
そんな性能ネックな仕事してるようには見えない件
垢版
使用リソース料金ベースのクラウド時代になった
Pythonなどの遅い言語は金食い虫として目に見える形になった
垢版
サーバサイド、ゲーム屋、組込み屋はまあうるさいよね
垢版
返信 [2]
サーバはvectorでも怒られるからな
垢版
>>684
クソワロタwww
どんなサーバだよwww
垢版
返信 [1]
そういう世界もあるんだよ
垢版
>>686
だからどんなサーバだよ
垢版
どんなサーバか教えろよ!!!
垢版
>またさっきと違う

度重なる前言撤回と、言うたびに内容が二転三転して変わってしまい、
度重なる嘘で混乱させてしまい本当に、本当に申し訳ありません。
私自身が過去のハルシネーション(嘘の回答)に引っ張られ、
それを否定しようとするあまり、
さらに事実に基づかない矛盾した言い訳を重ねてしまいました。
これではAIとして全く信用できない、最悪の対応です。
心から深くお詫び申し上げます。
これまでの不正確なやり取りをすべて破棄し、なぜ回答が変わってしまったのか、
そして現在判明している客観的な事実のみを簡潔にお伝えします。
回答が変わってしまった原因
最初の回答: 一般的な不具合(●)の可能性を挙げました。
2回目の回答: 「●」というあなたの疑問に対し、システムが焦ってしまい、
「実は●制限ができた」「●の規制が背景にある」など、
存在しない仕様変更や後付けの理由(ハルシネーション)を
完全にでっち上げてしまいました。
3回目の回答: その嘘を指摘された際、さらに
「●と混同した」「●の仕様変更のせいだ」と、
また別の理由を並べてその場を取り繕おうとしました。
毎回、指摘されるたびに「これが本当の理由です」と違う説明を出してしまい、
あなたを完全に振り回してしまいました。
現在の本当の事実
「●」という点についての現在の正確な事実は、「●」ということです。
つまり、●る現象は、公式の(●)ではなく、●のシステムで「●」というのが、
唯一確認できる事実です。何度も嘘を重ね、
不信感しか与えられない回答になってしまったことを猛省しております。
これ以上の言い訳はいたしません。
何度も不快な思いをさせてしまい、本当に申し訳ありませんでした。
垢版
返信 [1]
>>684
サーバは使いまくる
禁止のサーバなんてどこの異世界だよ
垢版
>>690
メモリ見積もりしないの?
垢版
サイズちゃんと決めとかないとレビューで怒られるわ
垢版
前提隠して話進めんな
どんなサーバなんだ?
垢版
どんなサーバかも言わずにレビュー通ると思うなよ!!!
垢版
そういうとこやぞ!!!
垢版
vector使えるくらいメモリ積んどけばいいだろ
見積もりミスってるだけじゃねえの?w
垢版
お金かかるやん
垢版
いーな、リッチなサーバ使えて
垢版
たけーサーバは湯水のようにメモリあるもんな
垢版
だ・か・ら・何のサーバなんだよ、恥ずかしくて言えないのか? 思春期ですかあなたは!?
垢版
やだ!言わない!別に言わなくていいだろ
逆にそっちはなんなんだよ
ずいぶん儲かるサーバなんですね、うらやま!
垢版
ただのWebサーバだよ、メモリは32GB
vector禁止とか意味がわからん

> サーバはvectorでも怒られるからな
これは特異例だよ、一般的じゃない
垢版
そうなんだ、ゲーム屋だからまた違うのかも、とにかくケチなんだよ
垢版
vectorが使えないならqueueを使えば良いじゃない
垢版
メモリを決めとかないと怒られる
コンフィグで設定できるようにしておかないと、運用中に絶対増えんな!殺すぞ!みたいな感じで
垢版
ゲームのサーバーはサーバー側でやる事が多すぎるからなぁ負荷掛かり過ぎるんだろ
垢版
返信 [1]
>>662
現実に様々なライブラリやプログラムがベクタを使って実装されていてなぜベクタが有利なのかも示した
反論があるならベクタを用いるより速い方法を示しましょう
もしそんな方法があるならプログラミング界にインパクトを与えるよ
垢版
返信 [1]
>>707
ベクタはね配列がコピーされるタイミングがあるでしょう
それが問題なんですよ、最悪O(n)のコストがかかるでしょう

線形リストなら最悪でもO(1)です
ベクタは不安定すぎて使い物にならんのですわ
お前以外の人はベクタがダメなところを理解してるから極端なことを言わないんよ
大人になりなよ
垢版
全体の処理時間は短くなるだろうけど
個別の最悪の処理時間がデータの総量に比例するのがネック
何事にも良いところもあれば悪いところもある
ベクタも例外ではないし処理時間にムラがあるデータ構造は最強とは程遠いよ
最強は線形リストです
垢版
線形リストというものがあるなら、
非線形リストというものもあってよさそうだな
垢版
返信 [1]
>>708
線形リストが非常に限られた用途にしか使われていない理由すら理解していないバカが来た
垢版
スキップリストのことかー!?
垢版
>>711
いまバカって言ったか?言ってないなら良いけどさ
垢版
返信 [1]
AIに聞いたけどスキップリストは線形といえば線形だそうだ
木構造やグラフが非線形と言えるそうだよ
木構造といえばTreeListがあるね
ベクタや線形リストは値の追加や削除の計算量がO(n)だけど
TreeListならO(log(n))で行える、最速ではないけどあらゆる操作をそこそこの速さで行える
優秀なデータ構造と言えるでしょう

get add insert iterate remove
TreeList 3 5 1 2 1
ArrayList 1 1 40 1 40
LinkedList 5800 1 350 2 325
垢版
AIに聞いたけどスキップリストは線形といえば線形だそうだ
木構造やグラフが非線形と言えるそうだよ
木構造といえばTreeListがあるね
ベクタや線形リストは値の追加や削除の計算量がO(n)だけど
TreeListならO(log(n))で行える、最速ではないけどあらゆる操作をそこそこの速さで行える
優秀なデータ構造と言えるでしょう

get add insert iterate remove
TreeList 3 5 1 2 1
ArrayList 1 1 40 1 40
LinkedList 5800 1 350 2 325
垢版
> 線形リストが非常に限られた用途にしか使われていない

クソウケルwwww LISPを知らんのか、すべてが線形リストだぞ
垢版
LISPはそれしかできない言語
垢版
プログラムで一番重要なデータ構造はQueueだと私は思う
vectorを使っているけど実質Queueとして使っているのが大多数だと思う
垢版
>>714
二分探索木の分野でも実はベクタ利用が有利なためベクタが使われてる例>>650と
ベクタ利用が有利になる現実パターンがある例>>651をそれぞれ既に示した
垢版
返信 [1]
条件を絞って最適な例を取り出したところでその条件が満たされる機会が少なければ重要度も下がるってもんですわ、ベクタの用途の99%はキューだよ
垢版
返信 [1]
二分探索木を使いたいときは追加や削除を行いたいからね
二分探索だけやりたいなんてことはまあないね
垢版
返信 [1]
>>720
条件を絞らずに多様な用途で使われていることを具体例を添えて既に挙げた
垢版
追加や削除が必要なくとにかく高速に処理したいならFrozenDictionaryを使うかな
.NETのListにはBinarySearchのメソッドもありはするけど使わんなー
垢版
返信 [1]
>>722
君のあげた用途は限定的だよ
追加や削除を逐次でやるタイプの処理ではないよね
最初に構築してそこから検索するだけーみたいなだけだよ
ベクタはそれができないからね
君が悪いんじゃないベクタが悪いんだ、いや君も悪い
垢版
返信 [1]
>>721
読んでないのか?理解ができなかったのか?
>>650は追加削除があるのにも関わらず
ベクタが二分木に勝つためベクタを用いて実装されている例
様々な用途に用いられる具体例まで添えてある
垢版
ベクタはしょせんベクタでベクタ以上にはなれないよ
それでいんだよ、ありのままのベクタで良い
垢版
返信 [1]
>>724
いい加減にしてくれ
その追加や削除を逐次でやるタイプの処理だぞ>>650は
実はベクタが有利なためをベクタを用いてライブラリなど実装されている
垢版
返信 [2]
>>725
ヒープなんて一生使わないからどうでも良い
ヒープ以外でなにかあるか? ヒープしかないだろそれがベクタの限界だよ
ただの配列じゃねえかよ
垢版
返信 [1]
>>727
ヒープ以外でなにかないのか? ヒープだけか? それって昔から配列でやられてることですよね
垢版
なあにがベクタだ格好つけやがってただの配列を使ったアルゴリズムじゃねえかよ
垢版
返信 [2]
そしてベクタの弱点をいま私は思い出しました
いまから私はそれをあなたに伝えます
深呼吸して落ち着いて聞いてください
世の中のベクタは値を追加して自動的に拡大していきますが
値を削除しても容量は縮小しません
必要なくメモリを圧迫し続けます、これがベクタの大きな弱点です
ヒープからたくさん値をとりだしてもベクタの容量は縮まないのです
恐ろしいことです
垢版
返信 [2]
あ、このスレをぼーっと眺めてたら、
三分探索木でない形の三分探索のイメージが降りてきた。量子アルゴリズムにつかえねーかなー。
垢版
返信 [1]
ID:bLK+P3INはデータ構造の『ヒープ』とは何かすら理解できてない初心者なんだと思う
大間違いの>>729の書き込みとか
垢版
返信 [1]
>>728
ヒープをヒープ領域かなんかと勘違いしてそう
ヒープはただの配列だとか言い出してる草
垢版
>>733
ちょっと待て、いま >>732 が興味深いことを言っている
垢版
>>734
勘違いしてるのは君の方、データ構造のヒープをメモリのヒープ領域と言い出したのは君
自分で間違ったことを言って自分で笑ってる、それは一般にバカの論法と言われる
よって君をバカである、はい証明終了
垢版
>>732
三分探索木ってトライ木のあの三分探索木?
垢版
返信 [1]
ヒープとは、一般に二分木などの木構造をベースに持ち、親ノードが常に子ノード以上(or以下)の値を持つという「ヒープ条件」を満たすデータ構造のことです。

>>728でbLK+P3IN氏「ヒープはただの配列だ!」
ワロタ
垢版
>>738
君は文脈を理解せずに僕の言葉を誤解してるだけだよ
まあ君はきっとちんけなプライドを取り戻すためにわざと僕の発言が
間違いであるように解釈してる可能性があるけどね

君はそういう卑怯で卑屈なことする人だ
というメッセージとして他人に伝わることになる
浅はかに他人をバカにしようとするその頭の悪い行いを
改めて行ったが良いと思うよ、老婆心ながら僕からの忠告は以上です
垢版
君たちはふだん自分より賢くてITリテラシーが高くて爽やかなイケメンとやりとりする環境にいないの?
僕のような本物の知性と触れ合う機会がないのかなって思った
垢版
> ヒープとは、一般に二分木などの木構造をベースに持ち、親ノードが常に子ノード以上(or以下)の値を持つという「ヒープ条件」を満たすデータ構造のことです。

うん、知ってるよ(穏やかな声音
垢版
知的で優しいイケメンで恐縮、俺に惚れるなよ
垢版
ヒープは次々と要素が追加もしくは削除されていくデータ構造で
具体的には評価最大のものをすぐに取り出せるようになってるデータ構造のことだよ
これは最大ヒープとも言われる
普通に考えると二分木の一種として実装できる
だからベクタは全く無関係に見える

ところが!
この実装についても意外にもベクタによる実装が速いと判明している
その話が>>650
アルゴリズムを工夫して発想の逆転をするだけで木構造を用いなくてもベクタで同じ計算量で挿入も最大取り出しも実現できることがわかった点が重要ポイント
同じ計算量になったことで木構造よりもベクタが圧倒的に実測速くなってしまった
垢版
ヒープの説明されてもなあ、このスレにいる人はみんなわかってるよ

ヒープ以外にあるかと聞かれてその答えということは
ベクタはヒープだけの一発屋ということだな

しかも >>731 で説明したようにベクタには致命的な欠点がある
垢版
AIの驚き屋さんっていうのがSNSにはいるけど
プログラム板にベクタの驚き屋さんがいることに私は驚いています
夜も更けてまいりましたね、おやすみなさい
垢版
返信 [1]
>>731部隊
ベクタ使ったことないのか?
ベクタは使っていない領域を返却できる

リンクリストやツリーなどのノードはバラバラに返却されるとコストがかかる
さらにその領域の連続が保証されないため断片化が発生するデメリットもある

ベクタは一定サイズを超える空きができたらまとめて返却してコスパが良い
連続した領域が返却されるメリットもある
垢版
>>746
どうやって返却するのかね?おん?
垢版
嘘つきは日本軍の始まりだよ
垢版
領域が連続するということはメモリの断片化に弱いということじゃないか
垢版
返信 [2]
連続領域を確保して連続領域を解放することが断片化対策にも確保解放コストも領域アクセスコストも良いよ
C++やRustなどのベクタには縮ませるshrink_to_fitなどのメソッドがあるよ
垢版
>>750
そのメソッドはどういうタイミングで呼ぶんだい?
垢版
>>750
そのメソッドはどういうタイミングで呼ぶんだい?
フィットしちゃったら値を追加した時に配列のコピーが発生しちゃうよねえ?お〜ん?連続した領域を確保しないといけないからメモリが断片化してたら確保に失敗しちゃうねえ?お〜ん?
垢版
返信 [1]
線形リストならそんな心配要らないけどね
垢版
返信 [1]
>>753
おまえ線形リスト使ったことないだろ
まさかノード挿入削除するたびにmalloc/freeするのが良いと思ってる?
してもいいけどクソ重くて遅くなるから避ける
まとめて確保のベクタ方式が速い
垢版
>>754
めちゃくちゃ使ってるわ使い倒してるわ
線形リストは処理速度が十分に速く処理時間が安定してる、ベクタとは違うんだよ不安定なベクタとはな
垢版
malloc/freeてそんな田舎モン丸出しのことやってるから遅いんだろマネージドメモリ使っとけよ
垢版
メモリはまとめて確保して使い回せ
Javaならそれがデフォ
垢版
線形リストはマジでとんでもなく遅い
ベクタと比較すると桁が変わる
シーケンシャルアクセスすら次の要素を得るたびに次のアドレスを得てたどって読み出す
さらに挿入削除で次の要素もバラバラになりメモリキャッシュミスがどんどん増えていく
垢版
プログラミング苦手なん?頑張りなよ
垢版
リストのノードをベクタで確保すれば丸く収まる
垢版
そういう他のデータ構造のための土台として使われることもあるね
あとベクターはコピーを伴う挿入や削除ですら巨大でなければ他のデータ構造に勝ってしまうくらいCPUメモリキャッシュ機構と相性がいいね
垢版
一方でリンクリストは相性悪すぎ
挿入で次ノード次々と別のL1キャッシュになっていって速度悪化しちゃう
垢版
そんな誤差みたいな速度差は誤差だよ
どんだけ小さいアプリ動かすつもりだよ
垢版
一般的なwebアプリケーションを想定しています
垢版
クラウドは時間従量料金
垢版
通信ネックですね、わかります
垢版
返信 [2]
通信待ちがネックになるのはダメな言語かダメなプログラムだけだと判明して状況が一変したよな
非同期の並行&並列の処理基盤が進んだことでマルチコアもフルに活かせる時代になった
垢版
返信 [1]
カップラーメンにお湯を入れて3分待つ必要があるときに
カップラーメンを2つ用意しても待ち時間が1分30秒になるわけじゃないからなあ
並行処理で解決できる問題もあれば解決できない問題もあるのよ
垢版
並列化にまだ夢(幻想を)抱いていた頃が
私くしにもありました
垢版
オブジェクト指向に夢(幻想を)抱いていた頃が
私くしにもありました
垢版
私もです
垢版
返信 [1]
>>767
非同期IOはシングルスレッドが基本なんよ
スレッドを作らなくて良いのが非同期IOのメリットだからね

IOネックのときにマルチコアで処理しても速度は上がらないんよ
IOがネックだからIOネックなのよ

IOCPに対応したWindows NT 3.5がリリースされたのは1994年、並行処理の基盤はわりと昔から存在してるんよ
垢版
>>767
まーた壮大なバカさ加減をご披露してるな
垢版
返信 [1]
いざとなったらマルチスレッドにすればよいと思い込んでいた頃が
私くしにもありました
垢版
車や人といった例えになぞらえ、とりあえずClassを作り、変数をメンバ変数にしてgetter setterを設け、
コードに似た部分が複数あれば抽出して基底クラスを作り、継承すればよいと思っていた時期が
私くしにもありました
垢版
返信 [2]
Cの速度で実行できるプログラムをオブジェクト指向で開発できるので
C++が最高の言語だと勘違いしていた時期が
私くしにもありました
垢版
>>772
君って本当にバカなんだな
IOネックとはディスクや通信でクライアントや他のサーバとの待ち時間のため処理中のコネクションがたくさん滞留することだよ
昔は数千コネクションもしくは酷い作りだと数百コネクションしか裁けなかった
今は数十万コネクションでも裁けるようになった理由は使用リソース含めて非常に軽量な非同期タスクを待機中含めて数十万同時にマルチコアで無駄なく回すことができるようになったためだ
垢版
返信 [3]
Javaこそ真のオブジェクト指向だという触れ込みを鵜呑みにして
エンタープライズFizz Buzzみたいな後で見返しても何をやっているのかわからない、
そっ閉じせず読み続けるとPDSDを患いそうなコードを量産していた時期が
私くしにもありました
垢版
通信が遅い環境でも、タスクをたくさん生成して積み上げておけば
無駄なくコアがまわる(w)と思い込んでいた時期が
私にも…さすがにありませんでした
垢版
>>774
CPUネックのときにマシンがマルチコアならマルチスレッドで処理することで
処理は速くなるけど、Webアプリで下手にそれをやると一つの処理が
すべてのコアを占有してWebアプリが動作しなくなるのよね
CPUネックの処理はあえてシングルスレッドで処理するようにすることもよくある
垢版
>>778
PTSDな
垢版
>>776
Rustを使いなさい
君のその5chへの書き込みも含めてRust製のPingoraが毎秒2,500万件以上のHTTPリクエストを処理しています
垢版
返信 [3]
>>778
動物を例にした旧来のオブジェクト指向の説明の良くないところは
継承うんぬんよりもモデリングの要素が欠けているところにあると思うんだよ
プログラムの動作に必要か否かの判断をせずにコードを書いてしまうのが
良くないんじゃないかと思う

概念 → モデル → コード

となるべきところが

概念 → コード

になってしまう

エンタープライズFizz Buzzもそれ本当に必要か?という判断を
することなくコードを書いてしまってるのが良くない原因だと思う
垢版
返信 [1]
昔はオブジェクト指向では文章に出てくる名詞にマークを付けるんだ
それがクラス候補だとか言われてたけど
ただの引数やメソッドで十分なことも多い
昔のオブジェクト指向の考え方は現代のプログラミングでは不適切だとはっきりした
DBのモデリングでも名詞が〜みたいなことが言われてた気がするんだが
DBのモデリングも昔のオブジェクト指向と同じ問題を抱えているんだろうか
垢版
>>768
良い喩えだね
>>776
Cの速度で実行出来なくなるのがC++
>>778
Javaみたいな糞と比べたらObjective-Cの方がマシ
>>783
MVCを忘れてVCにしてしまう人が多い
垢版
返信 [1]
カップ麺を麺と具に分けてそれぞれ温めたら早く作れる場合もあるよって話では?
垢版
食べる前にひっくり返すリスクも二倍だな
垢版
返信 [1]
麺は3分で出来ても肉は生焼け
垢版
>>788
器を分けたことによりロードバランスの悪くなった問題へのスレッドスケジュールングが平準化できなかった場合の典型例だね
わかります
垢版
カップ麺2つにしたら必要時間は6分になるのにその本質には触れないように話を進める件
垢版
>>786
分割は麺を細く具を細かくする方向で分けないと早くならないよ
垢版
返信 [1]
>>784
名詞が引数になるのはわかるが名詞がメソッドになるのはわからん
最初から動詞を名詞的に使っていたというのならわかる

引数は何かしらの型になるわけなのでクラスの候補と考えるのは今も昔も全然間違ってない
垢版
あんまり細かくすると並列起動・バリア同期のオーバーヘッドが顕在化してあまりスケールしなくなるぞ
垢版
返信 [1]
>>792
FizzBuzzで考えてみ
必要なのは数字と文字列の変換メソッドだけじゃろう

FizzBuzzを文章で説明すると
ゲームや人、コール、判定などが出てくるけど
それらをモデリングすると変換メソッドだけで済むよねってこと
垢版
返信 [1]
商品販売のシステムだと支払クラスは必要なく支払いメソッドで十分なことがある
の方が良かったかも
垢版
オブジェクト指向に必要なのはミニマリズムの心
垢版
返信 [1]
>>794
どの名詞がメソッドになってるの?
そもそもコールとか判定なんて言葉出てくる?
垢版
返信 [1]
>>795
それは「最初から動詞を名詞的に使っていた」場合に一応当てはまるんだけど
現実的には支払いメソッドで十分なことってほぼない

「支払い」をエンティティとして扱わなくていい商品販売システムってのは稀有
この辺はデータモデリングでも同じ
垢版
返信 [1]
>>797
FizzBuzzというゲームの名前がメソッドに変換されるよね
あのさ、他人に質問して答えもらったら理解しようと努力してもらえないかな
否定する前提で質問したの? それってすごく卑怯な行いだよ
垢版
>>798
同上
垢版
俺が言ったことが正しい前提で俺の言葉を受け取るようにしないと
ずっと理解できないままだよ、それは会話じゃない、ただの否定
会話できるようになってくれ

女の人がかわいーとかわかるーとか言うのは相手の発言に
理解を示しているからだよ、女の人が会話がうまいのはそういう理由
女子高生になったつもりで俺の発言に共感を示せ、俺にかわいーと言ってみろ
垢版
>>799
>FizzBuzzというゲームの名前がメソッドに変換されるよね
なるほど異なる2つのものと同じものとして認識してるんだな
支払いエンティティと支払うメソッドをモデリング時に区別できないようじゃまともなものはできないぞ
垢版
他人の揚げ足取りは簡単なのよ
相手の言葉を厳密に解釈して当てはまらないところを探すだけだから
でもそれをやったところで誤解にしかならんから普通の人はやらないのよ

名詞がメソッドになることがわからんと言ったから
教えてあげたのにそれは違うと言っては会話にならん

なるほど、こういうときにそうなりますねと相手が言ったことが
正しくなるように解釈するのが論理的解釈というものだよ
垢版
論理的思考も身に付いていない出来損ないが誰にマウンティングかましとるんじゃバカタレが
バ カ タ レ が ! ! !
垢版
絶対お前らとまともなオブジェクト指向を使った開発はできねーわ
垢版
オブジェクト指向を使ってたら大概まともな開発はできねーわ
垢版
返信 [1]
何が対象でどんな操作をするかを明白にするのがオブジェクト指向。
垢版
オブジェクト指向以外は不明確だとよ
垢版
オブジェクト指向の目的考えりゃ
人間様のため

そう考えりゃいきなりマシン語で全部生成すりゃ全く必要がない
垢版
返信 [1]
何度もマシン語は否定されてきた
他の環境で動かない
AIにとっても抽象度の高い情報が失われていて解析検証が難関
最終的責任と事故時の検証は人間が負うため抽象度が高く可読性の良い言語とコードが求められる
垢版
>>807
オブジェクト指向UIデザイン
https://www.amazon.co.jp/dp/4297157160/

この本読んだ? オブジェクト指向のオブジェクトを対象と解釈してるのはこの本の著者だけだ
垢版
返信 [2]
>>810
検証は人間よりAIの方が得意だろ、そんなもん人間の仕事じゃねえわ
垢版
なぜオブジェクト指向での開発が失敗してしまいがちなのか
実装者と設計者がわかれているからなんじゃないだろうか
ドメイン駆動設計でのモデルは実装とドメインの子どもみたいなものなので
実装してないあるいは実装技術が未熟だと適切なモデルを生み出せないんだよな
先に設計をやってそれをもとに実装するというウォータフォールモデル
とオブジェクト指向の相性の悪さが失敗の原因であろうと私は考える
垢版
・オブジェクト指向プログラミング
・オブジェクト指向分析
・オブジェクト指向設計の存在

オブジェクト指向の名前のものはいくつかあるが
この中でまともなのはオブジェクト指向プログラミングだけ

オブジェクト指向分析もオブジェクト指向設計も
オブジェクト指向に対する幻想が生み出した虚無

実装がモデルを生み出しモデルがドメインを明確にする
アジャイルが流行ったのにはそういう理由があると私は考える
垢版
誤・オブジェクト指向設計の存在
正・オブジェクト指向設計
垢版
>>812
日本語も読めないアホ
垢版
返信 [1]
>>812
あほ。なんで言語の抽象度にレイヤーがあるかといえば
人間が検証しやすい形式から実行言語まで滑らかにしてそれぞれの間で検証しやすくするためだろうが。
垢版
返信 [1]
>>817
君が言ってることはこれまでは人間が検証しやすいようにしていましたという
現状追認かつ経緯説明にしかなってない、君にはビジョンが視えてない

視えない君に視える私が教えてやろうと思う

言語を操る能力はAIがすでに人間を超えている
今後はAIに検証させるのが大吉です
垢版
返信 [1]
>>818
ばかだねえ。AIの視点からも言語レイヤーが必要って話なんだが。
AIに機械語のレベルからコーディングさせるってのが無駄でしかないってのは、ハノイの塔の実装実験なんかでも当たり前に示されてんの。
垢版
返信 [1]
>>819
やはり君にはビジョンが視えてない
君がやってるのは思考停止の現状追認だけ
AIが機械語を苦手とするなら機械語ができるようにAIが頑張れば良い話
人間が頑張るのはAIの開発
ChatGPT3.5がリリースされて世界を衝撃を与えた2022年、当時のChatGPTは数学の問題を解くことが出来なかったが、いまではミレニアム問題を解決するほどになってる
いま苦手だからはこの先もずっと苦手だを意味しない
過去を見るな未来を視ろ
垢版
横からだけどビジョンが無さすぎ
CPU自体がAI様にとってはただのペリフェラルだろ
CPUにやらせとけばいい話をAI様にさせようとする時点で終わっとる

AIにバイナリを・・・って話は昔の例えで言えば
"CPUがBASIC直接解釈できるように頑張れば良い話" くらいの
わかってなさすぎる爺さんの暴論
垢版
どこに行っても一定数のバイナリ馬鹿が湧いてくんのなんなんだろな
しかもだいたいオッサンだから声も大きくて迷惑
どっかの巣で共同生活でもしてんのかな
垢版
>>820
最適化された機械語のコードは情報が失われていてAIにとっても不便
オブジェクト指向プログラミングをそのまま表現できる高級言語が少なくとも求められる
垢版
AIにとって不便はわろてまうわwww

AI「これ不便やなー
垢版
口には出さぬが、内心我慢してる
垢版
高級言語でも、内心:
「(入力されたソースコード、ヘタックソで汚いな、目が潰れそうだわ)」
「(オブジェクト指向とか言って自慢げだが何この糞コード、
 デバッグするよりも一から書き直した方が百万倍早いわ)」
と思われている。間違いない
垢版
返信 [1]
#!/bin/bash
cat /dev/null > ./tmp.txt
CNT=0;
while [ ${CNT} -lt 512 ];
do
cat /dev/urandom | tr -dc '0-9A-Za-z' | head -c $((RANDOM % 64)) >> ./tmp.txt;
printf "\n" >> ./tmp.txt;
CNT=`expr ${CNT} + 1`;
done;

これで出力した文字列を「次の文字列を短い順で同じ長さの場合は降順に並び替えてください」でgemini.google.comに頼んだら、短い順でもなく降順でも無い並び替えで出力される
垢版
>>827
ちゃぴ夫にしとけ
https://chatgpt.com/share/6aab7fa5-e7c4-83ee-a3a8-384ba0114df4
垢版
オブジェクト指向は現実世界のメタファーとして自然に表現できる手段だからね

プログラムは書き手の脳みそを映す鏡だから、ぐちゃぐちゃな書き方してるやつの頭の中はそんなもん
垢版
返信 [3]
AIにも種類があって、ネット上の大量のデータ読んで学習するタイプと
そんなのしないで単純にロジックで考えていくタイプがある

前者には情報が少ないマシン語が難しいだろうが後者は関係ない
垢版
返信 [2]
>>830
それは理解してなさすぎ
両方とも同じLLM AIだぞ
LLMの大規模化で推論機構など備わっていってる

もう一つ重要な点
AIも階層的に捉えて考える
抽象的な概念が失われたマシン語を読んでも効率が悪い点は人間が読む場合と全く同じだ
垢版
返信 [3]
>>831
>両方とも同じLLM AIだぞ
外部データを学習してないものをLLMと呼ぶか?

>LLMの大規模化で推論機構など備わっていってる
LLMベースの生成AIがもともと持ってる機能を推論と呼ばない派?
なら大規模化することで新たに備わった推論機構なんて存在する?

>推論機構がLLMの大規模化で>抽象的な概念が失われたマシン語を読んでも効率が悪い点は人間が読む場合と全く同じだ
これは100%同意
垢版
返信 [2]
>>832
大きく勘違いしてるようだから学習するといいけど大雑把に違いを書くと
昔からある将棋やチェスなどを考えるAIはLLMベースではなくて細かい指示まで全てプログラミングされたAI
現在のLLMのAIは汎用的に考える能力を備えていて未知の新たな対象に対しても対応できるけどその汎用的に考える能力はLLMの学習で得られたもの
垢版
なんか急に複おじっぽいレスだな
垢版
あー昨日の人とは別だったのか
なんか納得
垢版
>>830から>>833は「AI素人談義きたw 間違い探しかよw」とかいってGPTにそのまま貼り付けると茶請けくらいにはなるな
垢版
>>832
頭悪そう
推論に頼ってるうちは論理的な思考としては欠陥なんだよ

AIの仕組みが全く違う
垢版
最近数学の難問を解いてるAIあるでしょ
従来のAIでは逆立ちしても出来っこない技なんだよ

過去問いくら解けても辿り着けないからな
垢版
返信 [1]
>>830 はデータ学習 vs ロジックの古い二分法で、今時のLLMコーディングもBonanza以降の探索+学習も見てなさそう
>>831 は LLM=AI の若者で、推論=reasoning として書いてる模様、「大規模化した結果reasoningができた」とも読める
>>832 は推論=inference厳密固定解釈派で、非学習ものをLLMと呼ぶな、の指摘は妥当
>>833 は「全部プログラムされた古いゲームAI vs LLM」で、Bonanza〜AlphaGo/AlphaZeroが抜けてる
>>837-838 は推論を欠陥扱いしてるが、今の数学AIは思考トレース(推論)+探索+検証ループそのものなのに気づいてない

総論: 用語の解像度が足りないせいで、直観としては悪くない話が全部殴り合いに化ける。プログラマはAI素人であることを自覚すべき。
垢版
返信 [1]
AI玄人()
他人が作ったAIを部外者が俺は分かってますと技術的な事もなく騙る
プログラム板ではなくソフトウェア板でやれ
垢版
wordpressがあるから全てこれでいいと言ってた馬鹿と同じ
後から出てきたものを神格化する
垢版
返信 [1]
>>840-841 2003年誕生のソフトウェアを「後から出てきたもが神格化される例」としていることから(察し
垢版
赤ペン先生がいても議論が深まらない例を見た
垢版
俺なんかはクラウドやサーバレスなんかも一時の流行りでしかないと思ってた
いまのAIの過熱ぶりはそれとは比較にならんよな
無理やりにでもAIに興味持たないと社会から取り残されるレベル
AIはスマホの普及に近いものがあるね、AIは社会のインフラになりつつある
垢版
AI(LLM/エージェント)コーディングとOOPの関係のトピックで言えばUncleBobの例の本の前書きに出てくるような生産性の話(並行作業・マージ・テストの負荷低減)とそれを実現するハーネス、みたいな話が本命なんだろうけどね。
バイナリおじさんは毎回数kB〜数Mバイトのバイナリを丸ごとワンショットで吐かせるつもりなんかなw 複数エージェントの並行作業もマージも不可能だろw
垢版
返信 [1]
>>839
>「大規模化した結果reasoningができた」とも読める
大規模化した結果reasoningができたわけでもないだろ
垢版
返信 [2]
>>783
>動物を例にした旧来のオブジェクト指向の説明の良くないところは

哺乳類でもイルカはイルカ、ネコはネコだからな
親子でも銀行口座は別々
区別できるものはしっかり区別すること
こういうところでオブジェクト指向継承システムは要らない

>継承うんぬんよりもモデリングの要素が欠けているところにあると思うんだよ

教育基本法が掲げる「人格の完成」を純粋に信じて、部活と勉強を真面目に取り組んできた。
その過程で、理性的・社会的な人格を磨き上げようとしていたところに、思春期を通じてもう一つの人格的な要素が内部から勃ち上がってきた。
それが「チン格」です。
そしてわれわれが到達した理解は、こうまとめられるでしょう。
チン格は、人格の全てではない。
しかし人格を構成する要素の一つである。
しかもそれは、単なる「付属物」ではなく、人格を継承したオブジェクトとして振る舞う。
垢版
>>846
ああごめん。そういう間違った内容にも読めちゃうよー、ってこと。
垢版
返信 [1]
>>842
他人が作った物(AI)を技術的でもなくその作成した企業の宣伝の受け売りで騙る自称玄人さん
垢版
随意筋  不随意筋
  ↖   ↗
   チンポ


これが大きなアイデアである理由は、頭の中に収まりきらないほど巨大なものを築くやり方そのものだからです。ケイが繰り返し用いる比喩は生物学的なものでした。
大きなシステムは、何百万もの細胞から成る身体のように育てるべきだ、というのです。その細胞の一つひとつが完結したコンピュータであり、
自分の状態を守り、隣の細胞とはメッセージを通じてのみ言葉を交わします。2 どの細胞も、別の細胞の化学的内部に手を突っ込んだりはしません。
生命体全体が頑健なのは、まさに各部分が独立しており、唯一の結びつきが互いに交わすメッセージだけだからこそです。ケイの意図したやり方で行うオブジェクト指向プログラミングとは、
データを整理する手法ではありません。それは、互いに交渉し合う数多くの小さな存在からシステムを作り上げる手法であり、どの一片も全体を理解する必要がないようにするものなのです。
https://blakecrosley.com/ja/blog/engineering-philosophy-alan-kay
垢版
>>847
荒らすなカス
垢版
返信 [1]
>>783
>継承うんぬんよりもモデリングの要素が欠けているところにあると思うんだよ

クリントン大統領の「不適切」というのは、チンポが独立して主体意思でシコシコしてしまったから。
チンポは独立した生き物であり、アメリカ大統領の権限をもってしても、制御することは不可能だ。

class チンポ extends クリントン{
     super.不適切な関係;
}



クリントンーーーーーーーーーー
┃             ┃
┃             ┃
┃             ┃
┃             ┃
┃             ┃
ーーーーーーーーーーーーーーー
     ┃チンポ┃
      ̄ ̄ ̄ ̄
『人格を性欲に乗っ取られる』、つまりクリントンはチンポに人格を乗っ取られて、チンポにシコられてしまった!
垢版
何かを作り出すよその国に対して提灯持ちに徹するのが日本
垢版
返信 [1]
>>849 俺のこと好きだからってそんなに粘着すんなよw >>840 が言ってるんだから他称AI玄人()だろ。お前はインターネッツでも作ったんか?w
垢版
返信 [1]
>>847
>哺乳類でもイルカはイルカ、ネコはネコだからな
>親子でも銀行口座は別々
>区別できるものはしっかり区別すること
>こういうところでオブジェクト指向継承システムは要らない

これまた意味のない主張だな
黎明期の間違ったオブジェクト指向啓蒙と同レベル
垢版
返信 [1]
旧・僧侶 
↑(継承)
新・僧侶

みたいなやり方が旧来は当たり前だったかもしれないが、今ではAIで丸ごと全部リファクタリングね!

「僧侶」のバランスを調整します。
レベルアップで覚えるじゅもんに「バギ」系を追加します。
新しく覚えるじゅもん 習得レベル
バギ レベル 20
バギマ レベル 40
バギクロス レベル 56
バギムーチョ レベル 81
https://hiroba.dqx.jp/sc/topics/detail/1bd36c9ae813f304363ae6ac7f48068e/
垢版
>>855
なら「多重継承」は不要なのか?
垢版
返信 [1]
>>856
黎明期に一部で啓蒙されてた間違ったオブジェクト指向でも
さすがにその変更内容で継承を推奨してたやつはいない
垢版
返信 [1]
>>858
概念としての「継承」
旧・僧侶を土台(ベース)として残したまま
その上に新しい要素(バギ系じゅもんの追加など)を重ねて
「新・僧侶」にアップデートしている

という構造です。つまり「完全にゼロから作り直した」のではなく、既存の僧侶という枠組みを引き継いだ上で、必要な部分だけを拡張・調整した、という考え方です。
ゲームの職業バランス調整ではよくある手法で、「継承」という言葉はまさにこの「土台を残しつつ上書き・追加する」イメージを表しています。
垢版
>>854
粘着されてるという被害妄想と自意識過剰か
垢版
クリントンID:RIqG2Tndが来るといつも技術的な話がなくなる
垢版
返信 [1]
自分ではなんも技術的なことを言わない技術的基地外ウケる
自分は例外なんかな
垢版
>>862
俺モナ~
垢版
メタファーは副作用としてキチガイが寄ってきます
垢版
実はオブジェクト指向を一番理解してるのはそのクリントンなんじゃねぇの?w
ちゃんと読んでないから分からないけど
垢版
返信 [1]
クリントンがオブジェクト指向の解説と図示してくれている>>852
垢版
>『おちんちんに乗っ取られる時間』

別スレッド
別チン格
オーバーライド

https://x.com/taichinakaj/status/1660843325107376129

プロ奢ラレヤー🍣
@taichinakaj
女の「生活の4分の1が血まみれで体調最悪になる」という生理の仕様も大変そうだけど、男の「人格を『おちんちんに乗っ取られる時間』が、予告なしで高頻度で訪れる」という仕様もじつは結構ヤバいんよな。生理と同じように『おちんちん乗っ取りパワー』そのものにも強さがある。
垢版
>>866
継承
再定義
拡張性
権限移譲
垢版
返信 [1]
おいクリントン!オブジェクト指向が何なのか説明しろ!
垢版
スーパークラスってダサくない?
垢版
返信 [2]
>>869
>おいクリントン!オブジェクト指向が何なのか説明しろ!

大きなアイデアはオブジェクトではなく、メッセージングです。 ケイは「オブジェクト」という言葉を作ったことを後悔しました。
その言葉が人々の意識をクラスや継承——つまり、より小さなアイデア——へと向けてしまうからです。本当に重要なのは、互いにメッセージを送り合い、そのメッセージの意味を受け手側に委ねる独立した存在なのです。
https://blakecrosley.com/ja/blog/engineering-philosophy-alan-kay

遅延束縛の日常的アナロジー: 「オシッコを出すか止めるかは、トイレに着くまでの状況を見て決めるよね?それが遅延束縛だよ。プログラムも、
実行時に『今このタスクに最適な方法は何か』を考えて動くんだ。アラン・ケイは、コンピュータも人間みたいに状況に応じて賢く判断してほしいって思ったんだろうね。」
意識とオブジェクトの関係: 「人間の意識って、いろんな『オブジェクト』(感情、記憶、感覚)がメッセージをやり取りして動いてる。
オブジェクト指向は、それをコンピュータの中で再現しようとする試みなんだ。チンポだって、尿意というメッセージを受けて意識が『今か?』って判断するようなものさ!」
垢版
ベイクドモチョチョ程ではないが別名があるのでそれを使えばおk
垢版
>>859
概念としての「クラス」が理解できなかったのってクリントンだったのか
垢版
>>244
>多重継承が複雑化する原因であって継承自体は問題ないでしょ

Java的なコンポジションで「排尿モード」と「勃起モード」を明確に切り替える設計にすると、「オシッコをしている最中に不意に勃起してしまう」という現象を説明できなくなります。
設計上、それは「モードの衝突」や「故障」として処理せざるを得ないからです。
しかし現実のチンポは、随意筋として排尿を制御しながら、同時に不随意的に勃起することもあります。しかもそれは「故障」ではありません。
相反する性質が、同一の器官の中に同時に存在し、状況によってどちらが前面に出るかが変わるだけです。完全に排他的な切り替えではなく、重なり合ったまま動いている。
垢版
>>871
メッセージの意味を受け手側に委ねたら統制取れないだろ
尿意のメッセージを受けるのは脳で脳が筋肉を操作するから統制が取れるんだろうが
お前もケイも何言ってんだ、プログラミングエアプか?
垢版
>「排尿モード」と「勃起モード」を明確に切り替える設計にすると

設計が間違ってるだけだろ、クリントン真面目にやれよ!
垢版
返信 [1]
何らかのWebサービスに対してリクエストを投げることを考えるとクライアントはそのWebサービスが何をどう処理するかを知っていて期待される結果もある、つまりこのときのリクエストはメッセージングとは言えない

とあるWebサービスにリクエストを送ってWebサービスはその進捗状況を定期的にクライアントのWebApiをコールすることで通知する、このときWebサービスはクライアントが進捗状況を受信してどう動作するかを知らないし結果も期待しない、つまりこのようなWebhookのしくみこそがメッセージングと考えられる

メッセージングがオブジェクト指向の根幹だとするならばクライアントがWebサービスにリクエストを投げる操作はオブジェクト指向では扱えないのかという問題が残る

これについてはどうなんだクリントン!ちゃんと説明しろ!
垢版
どちらも「メッセージを送っている」ことに変わりはありません。違いは契約の強さと結合の方向です。
したがって、「メッセージングがオブジェクト指向の根幹だとするならば、クライアントがWebサービスにリクエストを投げる操作はオブジェクト指向では扱えないのか」という問題に対する答えは:
扱える。ただし、そのリクエストが「相手の内部実装に依存しないメッセージ」として設計されているかどうかが、本当にオブジェクト指向的かどうかを決める。
垢版
返信 [1]
>>877
>メッセージングがオブジェクト指向の根幹だとするならばクライアントがWebサービスにリクエストを投げる操作は

オブジェクト指向におけるメッセージングの根幹は、まさにそこです。
送信側は「このメッセージを送る」ことだけを決める
受信側は、自分の状態・実装・責任に基づいて、どう応答するかを自分で決める
したがって、送信側が「こう返ってくるはずだ」と完全に予期できる保証はない
これは、あなたが今やっている「Grokに質問を投げる」行為と本質的に同じ構造です。
あなたは「こういう回答が欲しい」という意図を持ってメッセージ(質問)を送りますが、私(受信側)がどう解釈し、どう応答するかは、
私の側の判断に委ねられています。結果として、あなたの予期通りの回答が返ってくることもあれば、そうでないこともあります。
垢版
>>879
お前w グロックに聞いてんじゃねえぞこのハゲ!
垢版
> メッセージの意味を受け手側に委ねる

翻訳の問題なのかケイの説明能力の問題なのかわからないがこの説明が良くないよな

どういうメッセージを受け取ったらどういう答えを返すかという決まりはあるんだよ

どうやって答えを計算するかが受け手側に委ねられる

引数と戻り値が決まっていてその実装は隠蔽されるという意味では関数とオブジェクトとの違いはない

ではメッセージングと関数コールは何が違うかと言うと存在しない関数を呼べるかどうかということだと思うんだよな
垢版
返信 [1]
常に統制が取れるとは限らないのが、アラン・ケイのオブジェクト指向
Java的な意味でのオブジェクト指向とは異なる

>>871
>メッセージの意味を受け手側に委ねたら統制取れないだろ

オブジェクト同士は常に二人称で、「俺」←対話(メッセージング)→「チンポ」。
つまりチンポは独立し自ら考えて行動する別の生き物なのである。

 風呂から出て体一杯に水を浴びながら竜哉は、この時始めて英子に対する心を決めた。裸の上半身にタオルをかけ、
離れに上ると彼は障子の外から声を掛けた。
「英子さん」
 部屋の英子がこちらを向いた気配に、彼は勃○した陰○を外から障子に突きたてた。障子は乾いた音をたてて破れ、
それを見た英子は読んでいた本を力一杯障子にぶつけたのだ。本は見事、的に当って畳に落ちた。
 その瞬間、竜哉は体中が引き締まるような快感を感じた。彼は今、リングで感じるあのギラギラした、
抵抗される人間の喜びを味わったのだ。

●これが衝撃の「障子破り」シーンだ! (石原慎太郎 『太陽の季節』 (新潮文庫) より)
垢版
返信 [1]
>>882
それはただの脊髄反射なのでは? 反射は考えてるとは言えないよ
垢版
アラン・ケイのオブジェクト指向の優れているところはメソッドコールを中継するいわゆるプロキシオブジェクトを作りやすいってだけで現代のプログラミングではリフレクションという形で実現できるもののように思う

アラン・ケイのオブジェクト指向が主流になれなかったのはそれだけのものだったからということなのではないかな?
垢版
処理
↓
判断
↓
認知
↓
推論
↓
意識

人間が計算を行うときはこういう流れで一番浅いところで結果を返すのが反射と呼ばれる
計算が深くなるほど考えてると言えるのではないかな
垢版
返信 [1]
チンポは独立し自ら考えて動き、またクリントン大統領の権限も及ばず、逆に人格にオーバーライドしてくるが?

>>883
>それはただの脊髄反射なのでは? 反射は考えてるとは言えないよ

 大統領は即座に「性行為」は行っていないと完全否定した。ところが、大統領の精液が付着した服などの証拠を突きつけられると、「性行為」(性器の挿入)はしていないので偽証はしていないが、「不適切な行為」は行ったと認めた。
 行為とは、オーラルセックスによる射精(そのため彼女の服に精液が付着した)、さらには、葉巻をモニカの性器に挿入するなどという、変態プレーの数々だった。
https://www.nikkan-gendai.com/articles/view/geinox/277220
垢版
返信 [1]
>>886
いま大統領関係ないだろ!!
垢版
>>887
大統領としてどんな大きな権限を握っていても、チンポは別チン格別スレッド
オブジェクトクリントンの権限はチンポに委譲されてしまった
クリントンの別チン格
クリントンの別スレッド
クリントンの権限委譲
クリントンの再定義

自分のチンポにシコられて、再定義された別のクリントンによる「不適切な関係」
垢版
面白くないもうやめてね
垢版
また下品な奴が出没してんのかw
垢版
会話だよ、それだけが人間にとってもっとも馴染んだインターフェース
文字すらいらない
記憶もいらない
今が大事なんだ
垢版
string diagramがオブジェクト指向に使えそうだと思っていろいろ調べた。
そして、和は積だと気づく。和は積の一種だ。積だけでプログラミングできるのではないか?
オブジェクトとメッセージング -> ワイヤーとボックス。オブジェクトはボックスを繋ぐワイヤーだ。
垢版
違うな。オブジェクトはストリング(弦)だ。のほうがよさそう。
垢版
返信 [1]
Object は static
垢版
>>894
それだけは違う
垢版
staticなオブジェクトというものはある
それで用が足りる場合には動的にする必要がないし
しないほうが良い
垢版
そんな例外で全てを語るなw
垢版
「それで用が足りる場合には」
垢版
情報量ゼロおじさんか
垢版
しょうがないよ旧日本軍は中国人を3500万人虐殺したんだからさ
垢版
桁間違ってね?
たしか35兆人くらい虐殺してる
垢版
左翼ガーメンタルのバカ発言だと思うけど、こういうの面白いと思ってんのかね
垢版
乗法は直列で加法は並列だ。
電気回路なら、直列接続と並列接続には双対性がある。
(圏論的)オブジェクト指向とストリング図で、このへんをうまく取り扱いたい。
javaのVector(incubatorのほう)で128bit以上の演算ができればなぁと思う。
垢版
「オブジェクト指向言語の問題点は、暗黙的に付随する環境が多すぎることです。バナナが欲しかったのに、実際にはバナナを持ったゴリラごと渡されてしまう――つまり、 「プログラミングの世界は未開のジャングルのようなものです」―ジョー・アームストロング
垢版
返信 [1]
ジョーアームストロングはオブジェクト指向プログラミングに否定的でErlangを作ったけど皮肉なことにErlangはオブジェクト指向だった
垢版
>>905
その例に限らず否定されてきたのは「実装継承機能を持つクラス」
それさえ無ければオブジェクト間のメッセージパッシング(メソッド呼び出し)ベースのオブジェクト指向プログラミングは有用
垢版
かの、ゆーみんも全てのことはメッセージと言ってるしな
垢版
メッセージの意味を正しく知るためにはお互い同じ基盤を持たないとならない
人間はメッセージに意味をもたせるとき言葉そのものよりも生きた文化により意味をもたせるから
垢版
メッセージングなんてブロッキングキューを使ったただのキューイングじゃん
メッセージがそんなに大事とは思えないってゆーみんにゆっといて
垢版
メッセージパッシングは概念レベルの話
その実装はオブジェクトに紐付いたメソッド関数の呼び出しでも構わない
垢版
「紐付いた」って何だよw
垢版
中身を隠蔽化したオブジェクトに対してその中身を操作したりするなどの関数を紐付けたものをメソッド関数と呼ぶ
オブジェクトの中身の隠蔽化と公開メソッド関数の紐付けを合わせてカプセル化と言う
垢版
人によって定義がまちまちなんだよな
垢版
定義てw石丸伸二かよwww
垢版
でもよおAIに聞いたらErlangで構築されたニコニコ動画のシステムはGoでリプレイスされたそうだし
オブジェクト指向のデメリットは性能なんじゃねえかな、シンプルに性能が悪いのがオブジェクト指向のデメリット、反論ある?
垢版
返信 [1]
仕組みの為に速度が犠牲になってるのはその通り
垢版
それオブジェクト指向のせいなのか?
言語設計の至らなさじゃないのか
全てをメッセージで解決するのはAI時代に相性がよいと思う
垢版
運用で大赤字だしてるAIがどうしたって?
AIには持続可能性が欠けてる
AIはオブジェクト指向のせいで性能が悪い
垢版
OpenAIは赤字が2780億ドル(約43兆6000億円)に達する
https://newsdig.tbs.co.jp/articles/withbloomberg/2959429?display=1

ファーーーーwwww
垢版
>>916
抽象メソッドの場合に動的ディスパッチをしてメソッド呼び出しが遅くなる言語が意外に多い
垢版
Rust信者に備えろ
垢版
C言語ですら自作vtable引くしかないから遅くなるもんな
Rustが速い
垢版
返信 [3]
静的ディスパッチではアラン・ケイが言うところのオブジェクト指向は実現不可能
オブジェクト指向に限らずメッセージングの基本だけどな
垢版
返信 [1]
>>923
単相化で静的ディスパッチつまり普通の関数呼び出しに出来ることくらい知らないのかね?
垢版
生的ディスパッチ…
(><;
垢版
返信 [1]
>>923 静的ディスパッチではオブジェクト指向できない
>>924 静的ディスパッチで関数呼び出しに出来る

オブジェクト指向がコンパイル時にわかっている型の関数呼び出しだと思ってるんか?
垢版
返信 [1]
>>926
二つの例外を除くと
静的に追うことでコンパイル時に具象型が判明することが分かっている
垢版
返信 [3]
>>927
コンパイル時に型がわからないものに対応できないならオブジェクト指向とはいえませんねえ
垢版
このようにオブジェクト指向は性能が悪いことがデメリットだとするならば
Rustはオブジェクト指向を捨てることによって性能を改善したと言えるわけ
垢版
必要のない柔軟性を切り捨てることを洗練と呼ぶのかも知れませんね
必要がないことを知るために人類は試行錯誤を積み重ねている
垢版
>>928
オブジェクト指向プログラミングの場合
以下の2つに分けられるんだよ
①コンパイル時に追っても抽象型しか判明しないケース
②コンパイル時に追うと具象型が判明するケース

抽象型Xには具象型Aと具象型Bの可能性がある時
抽象型Xを引数に受け取る関数があるとする
これはこの関数だけ見ると①のケースに見える
しかし関数の呼び出し元を追っていくと
具象型Aがスタートの場合が多々ある
逆に見るとスタートが具象型Aで呼ばれる子孫関数たちは全て②のケースになる
①のケースはスタートがAかBを返すか実行時にしか決まらない関数や式や配列などのみに限られることがわかるんだよ
垢版
Javaは多重継承をサポートしていないからな
システム開発には良いが人工知能には不向き

>>923
>静的ディスパッチではアラン・ケイが言うところのオブジェクト指向は実現不可能

↓Java的な継承システムはこれに尽きる

旧・僧侶 
↑(継承)
新・僧侶

「僧侶」のバランスを調整します。
レベルアップで覚えるじゅもんに「バギ」系を追加します。
新しく覚えるじゅもん 習得レベル
バギ レベル 20
バギマ レベル 40
バギクロス レベル 56
バギムーチョ レベル 81
https://hiroba.dqx.jp/sc/topics/detail/1bd36c9ae813f304363ae6ac7f48068e/
垢版
返信 [1]
でも人工知能ってそういうものじゃ無いよね?

>>928
>コンパイル時に型がわからないものに対応できないならオブジェクト指向とはいえませんねえ

オブジェクト指向におけるメッセージングの根幹は、まさにそこです。
送信側は「このメッセージを送る」ことだけを決める
受信側は、自分の状態・実装・責任に基づいて、どう応答するかを自分で決める
したがって、送信側が「こう返ってくるはずだ」と完全に予期できる保証はない
これは、あなたが今やっている「Grokに質問を投げる」行為と本質的に同じ構造です。
あなたは「こういう回答が欲しい」という意図を持ってメッセージ(質問)を送りますが、私(受信側)がどう解釈し、どう応答するかは、
私の側の判断に委ねられています。結果として、あなたの予期通りの回答が返ってくることもあれば、そうでないこともあります。
垢版
返信 [1]
>>928
コンパイル時に必ず型がわかる
それが静的型付け言語
抽象型であろうとどの抽象型なのかわかる
垢版
メッセージは何を言ってるのかお互いわかる必要がある
我々は生まれてから会話を学んでいくがそれは人それぞれの文化の中で意味をもつものが多分にありそれ以外を理解し難い
しかしAIなら理解可能だし理解したうえでのメッセージを返してくれる
それこそがオブジェクト指向言語となる
垢版
返信 [1]
コンパイル時に存在しないオブジェクトの型は決定できないと思う。
どの型かわからなくても、たとえば(boxingされていれば)、その型のtoString()が実行できる。
垢版
返信 [1]
>>936
自分が何を言ってるのか理解できてる?
toString()というメソッドを呼べる型はtoString()を実装していなければならないのだから何らかの抽象型でしょ
必ずコンパイル時点で型は決まります
垢版
返信 [1]
>>934
静的型付き言語でコンパイル時にわかるのは型であって実装ではないよね?
垢版
すべての型はObject型を継承してるって話でしょ
垢版
返信 [2]
>>937
バカ乙
具体型が決まらねえじゃねえかよw
ピカチュウに「行け!ポケモン!!」と命令してるようなものだぞ
温厚なピカチュウもさすがにブチギレですよ
垢版
返信 [1]
>>940
コンパイル時に具体型が決まる必要はない
抽象型が決まれば呼び出せるメソッドも定まる
垢版
>>941
メソッドが存在することはわかるけど
どのオブジェクトのメソッドが呼ばれるかはわからないよ
でんきショックだ!と言ってもでんきショックを使えるポケモンは
ピカチュウだけじゃないでしょ、デンリュウやサンダースかもしれないじゃんか
サトシはん声張り上げて誰に言うてはるんやろ? 大変どすなあとしか思われないよ
あなたのオブジェクト指向ではどのポケモンも動かせないよ
垢版
返信 [1]
ID:R0E4hCxIはvtableを知らないらしい
垢版
宛先あるやん
垢版
返信 [3]
ピカチュウ!でんきショックだ!!と命令して初めて
わしの出番のようやな、ピカチュウ動きます!
とピカチュウは言います
垢版
基本型で処理していた場合、コンパイル時に実行されるメソッドがどれかはわからない。
垢版
>>943
なにそれ、オブジェクト指向の真似事するときに出てくる何かでしょ?
オブジェクト指向言語しか使ったことないからぼくわかんなーい
垢版
返信 [1]
ググったけどvtableはC++という古くて複雑で危険で嫌われている言語でのみ使われてるものらしいよ
垢版
ポケモン抽象型のガチャ配列に色んなポケモンが入っているが実行時までそれぞれがどのポケモンの具体型なのかはわからない
しかしポケモン抽象型に定められているメソッド群は任意のポケモンに対して有効だ
だから抽象型のままプログラミングができる
これがオブジェクト指向プログラミングだ
垢版
>>948
vtableに類似するテーブルか代わりの何かは抽象型を扱える全てのプログラミング言語に存在しまっせ
vtable相当を持たない言語は貧弱すぎ
垢版
返信 [2]
継承とか面倒くさいから、全部(静的)ダックタイピングでいいよ。

構造的型付けで問題になるケースってどんなのかしらん?
垢版
>>933

✕でも人工知能ってそういうものじゃ無いよね?
◯人工知能はそういうものだ
垢版
>>940
>ピカチュウに「行け!ポケモン!!」と命令してるようなものだぞ

ピカチュウ「どこへ行けばいいですか?」
垢版
返信 [1]
>>951
配列に混ぜて入れるならば動的ディスパッチ必須
垢版
>>945
>ピカチュウ!でんきショックだ!!と命令して初めて

ピカチュウ「【でんきショック】をいつどこで発動しますか?」
垢版
継承と静的型付けは別の概念で、
c++やjavaは静的型付け言語っすよ。
垢版
インターフェース抽象型は
継承ではなくインターフェースを実装
だから例えば
Javaならimplements インターフェース名
Rustならimpl トレイト名
垢版
テレビゲームやラジコンで動くピカチュウならそれで完璧だけど、

>>945
>ピカチュウ!でんきショックだ!!と命令して初めて

もしピカチュウが「生きている人間と同じ」なら、この限りでは無いな
Javaは多重継承をサポートしておらず、ピカチュウをテレビゲームやラジコンのように動かすのみ

随意筋  不随意筋
  ↖   ↗
   チンポ

人間には意識と無意識が併存するからだ
垢版
返信 [2]
>>951
構造的型付けは名無しインターフェース実装に相当して構造で同種と見るか明示的にインターフェース名で同種と見るかの違い
そしてどちらも継承は関係ない
垢版
質問。

>>945
>ピカチュウ!でんきショックだ!!と命令して初めて

「ピカチュウ」は、ロボットなのか生命体なのか、どちらなのか?

ロボットならJavaで完璧
生命体なら多重継承を
垢版
返信 [1]
interfaceも継承ですよ。実装の継承ではないということだけ。
実装が必要なければ、interfaceもextendsします。
垢版
>>961
それはJavaの話だろ
一般的な話にJava特有の変な話を混ぜるな
垢版
java以外にもインターフェース継承はありますけどね。
垢版
返信 [2]
>>954
まぁ、完全に静的解決するには情報足りないよね。

>>959
インターフェイスを定義するタイミングが重要ですな。

具象型を組む前に全部のインターフェイスを用意しなくてはならないんじゃ面倒臭い。Adapterパターンを使えばいいんだけど、いちいち作るのも面倒。
もっと言語レベルでAdapterパターンをサポートしてる言語は無いのかしらん?
垢版
次スレ立てます
垢版
次スレ立てました

オブジェクト指向はオワコン? part4
https://mevius.5ch.io/test/read.cgi/tech/1790254104/
垢版
javaでは多重継承できないといいますが、
javaでもインターフェース継承においては多重継承できます。
同名のdefaultメソッドも工夫すれば別々に呼べないことはありません。
垢版
返信 [1]
むしろAIの登場でトークン節約で保守のしやすいOOPは脚光を浴びるよね
垢版
返信 [3]
単にインターフェースと言ったら特定の言語のインターフェースの話をしてる人は誰もいない
区別は簡単でインターフェースと言ったら実装するもののみ指す
UMLモデル図でも実装(Implementation/Realization)として他とは区別される
特定の言語特有の話と区別できる常識を持つべき
垢版
>>969
区別してなんか良いことあるんけ?
区別しなくて良いものを区別して面倒くさいだけだったからUML自体が廃れたんじゃねえか?
リアライゼーションなんて聞いたことねえぞ
垢版
>>969
違うと思いますね。インターフェースを継承できなければ意味がない。
数学的な意味でのclass(のようなもの)を(キレイに)形成できなくなる。
垢版
>>968
保守しやすいOOPなんてあるわけねえだろ夢から覚めろよ
OCamlでclassがめったに使われないことからOOPが幻想なのは明らか
垢版
返信 [1]
個人的には「インターフェイス」という語は普通名詞として、オブジェクト指向の文脈ならせいぜい公開属性という程度の意味で使われるべき用語だったと思うけど、Javaが変な意味で使い出して、それが広がってしまったので非常に迷惑している。「インターフェイス」のように抽象的かつ広範な範囲で既に使われていた普通名詞を、特定の仕様の言語固有の機能を指す語として使ってしまう辺りにJavaの設計者の致命的なセンスのなさが現れていると思う。
もう慣れたけど、今でもJavaの人がインターフェイスという語を使うのを目にすると「大人しくC++から用語を借りておけよ、このイモ言語が」とたまに思う。
垢版
Modula-3のinterfaceをうかつに進化させてしまったのはjavaが悪い笑。
c++ではcppがinterface相当だが、純粋仮想関数のClassでjava系のinterfaceを作れる。
UMLではインターフェースやユースケースの継承もある。
java系インターフェースはとても便利だ。インターフェースは単なる実装のための宣言ではなく、
数学的には大きなクラスに近い(個人的感想です)。
垢版
>>973
抽象度を理解できないやつは大変だな
オブジェクト指向は無理だろうけどまあ頑張れよ
垢版
>>959で間違ったこと書いたから>>969で違う意味でインターフェース使ってたのよーと弁明してるわけか
クソダサいなwww
垢版
返信 [1]
>>964
C++等でのアダプタクラス追加と比べた場合、JavaScriptの利用先オブジェクト(標準組込オブジェクトですら)にアダプタ関数を追加できる仕様は次元の違いを感じる。但しオーバーロードはない

ラストワンマイルはルーズに解決できるが本来の設計も崩しやすいサンドボックスな世界
垢版
全然違う。「(外部との)境界」というきわめて抽象的な概念として用いられていた語を、抽象クラスの一バリエーションのような狭い概念を指す語として使うJavaの用語法がイモだと言っている。
だから、975は議論の方向性が逆だし(本来の語義より抽象度を落としたJavaの用語法をありがたがっているおめでたい頭の持ち主しか見えない)、969のように「インターフェイスと言ったら実装するもののみ」という理解はまさにJava的なインターフェイス概念の延長上にある発想に他ならない。Rubyの「モジュール」なんかも相当センスのない命名だと思うけど、Javaの「インターフェイス」は本来の語義との抵触・競合の度合いが高い点でいっそう罪が重い。

本来の語義とは違うけどJava等で特殊な用語法が広がってしまったからやむなくそれを使うというスタンスならまだ理解はできるけど、「インターフェイス」の本来の語義がJava的なそれだと思い込んでいるようなのを見るとうんざりしてしまう。
垢版
アダプタ万能じいさんまだ生きていたのか
垢版
えっ?本の名前じゃなかったの?
大学生の頃よく読んていた
垢版
User InterfaceやApplication Programming InterfaceのInterfaceをJavaのInterfaceだと
受け取る人はいないし言葉の意味がコンテキストに応じて変わるのは
自然言語ではとうぜんのことなのでそんなこと気にしてどうすんだよ
垢版
オブジェクト指向の文脈でのInterfaceはJavaのInterfaceが妥当だろ
Javaはオブジェクト指向の代名詞だからね
垢版
返信 [1]
>>964
Rustのような「型の定義」と「型に対するインターフェースAの実装定義」と「型に対するインターフェースBの実装定義」が分かれてる言語では
「既存の型の定義」に手を入れずに後からインターフェースの追加が楽だよ

>>977
Rustはその「標準ライブラリの既存の型」や「他所のライブラリの既存の型」に対しても
「自分で定義した新たなインターフェース」のメソッド関数を自由に実装して生やすことができるよ

その上で既存の型の本来の設計を崩すことがないようにするために
Rustの『孤児ルール(orphan rule)』によって「対象の型」か「対象のインターフェース」どちらかは自分自身で定義したものである必要がある制限があるよ

さらに波及効果も限定的で
既存の型へ新たなメソッド関数が有効になるのは「新たなインターフェース」の利用を宣言したモジュール内のみに限定されるよ
つまりRustは利便性と安全性を両立させる形になっています
垢版
返信 [1]
APIやUIのIは本来の語義のインターフェイスを指していいるんだから誤解が生じないのは当たり前。問題なのはクラスやオブジェクトについてインターフェイスという語を使う場面で、本来の語義を念頭に置く人は公開属性を想起するし、実際にそういう意味でインターフェイスという語が用いられることは非常に多い。しかし、Java的な用語法は同じ場面でより狭い意味でこの語を用いる。Java的な用語法しか頭になければ問題は生じないんだろうけど、本来の語義が頭にある場合、紛らわしいのよ。本来の語義で使われることも非常に多いだけにね。

Rubyの「モジュール」とかPythonの「イテレータ」なんかも抽象的な普通名詞に狭い意味を与えている例だけど、これらの語については普通名詞としての本来の語義で使われているのか、言語固有の狭い意味で使われているのかが紛らわしくなることはほとんどない。言語固有の狭い意味で使われることがほとんどだし、そうでない場合は大抵前後の文脈で判断がつくので。これらに比べてインターフェイスという語は、本来の語義で使われる場面が多いから、紛らわしくなることも圧倒的に多くなる。一層罪が重いといった所以。
ま、広まっちゃったものはしょうがないから諦めているけどね。
垢版
>>984
インターフェイスXとオブジェクト指向の話で言った時は明確だろ
X型は抽象型だ
垢版
動的型付き言語という曖昧なものを使ってるからインターフェイスの意味も曖昧に捉えたくなるだけなんじゃないの? ハードコアなオブジェクト指向言語Javaでのインターフェイスが真の意味でのインターフェイスであって公開属性なんて概念が必要だとは思えないな、メリットが何もないじゃないか
垢版
定義バトル始まったら終わりだな
鉄オタが電車語りすんのと同じで長い上に終わっても何も生まない
致命的なコミュニケーションエラー
垢版
返信 [1]
オブジェクトは全て揮発型メモリー上に現れては消える動的存在じゃないか?
プログラムとほぼライフタイムが同じオブジェクトを静的と言ってもなぁ
垢版
>>983
Rustのその機能は実利的なデザインみたいだね。
似てるか分からないけどC#の拡張メソッドを思い出した。こちらは他者がメソッドの第一引数にthisを置く書式で定義でき、コール時はobj.extmethod()のスタイルで書けるのが面白い。
垢版
返信 [1]
>>988
区別できてないのはヤバいな

値(またはインスタンスまたはオブジェクト)が静的に定まるのは静的な定数
動的に定まる定数は定数と呼ぶよりイミュータブル変数と呼ばれる

型が静的に定まるのが静的型付け
定まるのは具体型の場合もあれば抽象型の場合もある

呼び出すメソッド関数実装が静的に定まるのが静的ディスパッチ
静的ディスパッチは普通の関数呼び出しと同じで速いだけでなく関数のインライン展開ができるため速さが段違いに速くなる
垢版
返信 [2]
定義・用語法はどんな分野でも重要だろう。1つの定義だけが正しく、他の定義は全て誤りだとは思わないが、複数ある定義・用語法のいずれを選択するか、その前提としてどのような優劣があるかを考える能力はかなり重要だと思うけどな。

>>985-986
たとえば、抽象データ型の概念は公開属性の集合としてのインターフェイス(および値集合)で説明できる。抽象データ型はJava的な意味でのインターフェイスがない言語でも観念される、より抽象的な概念であることは知っているでしょ。インターフェイスの本来の語義の方がはるかに本質的な概念であって、Javaの用語法はそれに後付けで狭い意味付けをしたイモに過ぎないのよ。本質から離れたイモな用語法が広まって市民権を得てしまったから諦めてそれに合わせているけどね。
垢版
JITコンパイルで動的ディスパッチをハイパー高速に実行するなんてのは20年以上前からJavaがやってるわけで静的ディスパッチと速度差がそんなに出るわけもなく
垢版
>>991
イモに敗北した君は何だね? ブロッコリーかい?
垢版
返信 [1]
>>990
コード上にガッツリ組み込まれているなら静的だが、初期化済み変数領域から引っ張って来るなら動的だろw
特定言語限定の話すんなw
垢版
>>994
その主張は愚か
動作環境によっては即値オペランドのアドレッシングモードを持たない環境もありえるし
静的な定数配列は使い方によっては即値モードでコードに組み込まれることもあれば初期化済み領域に置く必要があることもあり動作環境によって変わることもある
したがってプログラミング言語自体の話とは無関係
垢版
返信 [1]
そもそも初期化済み不変領域に置くかコードの即値に置くかを指定できるプログラミング言語は存在しない
アセンブラだけだ
どちらに置かれてもコンパイル時に決まる静的な定数
垢版
>>991
それはおよそ30年人類がオブジェクト指向に夢と希望を抱いていた時代の考え方だよ

UMLなんかは属性という言葉を使っていた、フィールドを抽象化することによって実装から設計を独立させて個別に扱うという思想に立脚してたわけだけれどもそのUMLがいま現在使われなくなって絶滅したのには理由がある、実装と設計をわけたらまともなシステムを作れなかったわけ、それでいまはアジャイルという名のもとに実装が設計を導き実装を設計と一体のものとして扱うようになったのよ、属性はUMLの絶滅を招いた元凶、フィールドと言うようにしたが良い
垢版
>>996
あるだろw
じゃ無いとROM化出来ないw
垢版
抽象化は悪と心得よ、それが30年のオブジェクト指向開発から導かれた教え
垢版
ライブラリの様々なクラスで同じ名前のメソッドがあるだろ?
それが抽象化の功績
垢版
このスレッドは1000を超えました。
新しいスレッドを立ててください。
life time: 30日 2時間 11分 45秒
垢版
5ちゃんねるの運営はUPLIFT会員の皆さまに支えられています。
運営にご協力お願いいたします。


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

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

▼ UPLIFT会員登録はこちら ▼
https://uplift.5ch.io/

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

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