障害者は目の保養になる
1 ：ルリ：
だってのたうちまわっておもしろいじゃん（ﾋﾟｭｱ
|
|
|
.
3 ：名無しさんの初恋：2001/07/15(日) 21:59
放置新聞
（ﾋﾟｭｱ ってなんだよ。
5 ：名無しさんの初恋：2001/07/15(日) 21:59
削除依頼しとくよ
6 ：名無しさんの初恋：2001/07/15(日) 22:01
うざいだけだ。なにが保養だ。迷惑きわまりない。
クソだな
健康板の癌投稿と同じか
健康板の癌投稿と同じか
8 ：ルリ：2001/07/15(日) 22:02
障害者を百人位まとめて燃やしてみたい(ﾋﾟｭｱ
.
ラヴィアンローズよ。
ガイジ、ヨーゴ、殺せ！
削除依頼しておきましたよ。
13 ：名無しさんの初恋：2001/07/15(日) 22:05
雨の中に障害者を置き去りにしたい(ﾜﾗ
CFoo::CFoo(CFoo x) というコピーコンストラクタを定義するとする。
コピーコンストラクタを呼び出すときに、さらにコピーが発生するので、
永久にコピーコンストラクタが呼び出され続けて暴走する。
従って CFoo::CFoo(CFoo &x) でなければならない。
なお CFoo::CFoo(CFoo *x) はオブジェクトのコピー時には
呼び出されないのであしからず。 ２：代入演算子（operator=）を作るのに必要。
１と同じ理由。 コピーコンストラクタと代入演算子は、基本的に全てのクラスに書いてくれ。
各必要がないときだけ、意図的に省くように。
理由は Effective C++ 参照。 ３：例外をcatchするのに必要。
throw をコピーで catch すると、例外オブジェクトのコピーコンストラクタ内で
さらに例外が発生してややこしくなる。ポインタで catch すると、開放されたゴミメモリをポイントすることになる。
例外ハンドラは参照で catch しないといけない。
こういう話を聞くたびに、delphiを思い出すんだよね。
C++でいう参照が無いのに、別に困っていない言語。
＃delphi以外の多くの言語でもソウだけど。
delphiとかに言わせれば、 1:コピーコンストラクタなんざ要らない。
2:代入演算子なんざ要らない。
1と2の理由は要するに、変数埋めこみObjectを許していないために
変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
食らわずに済むから、です。
3:newで作った例外Objectをcatch部で受けとって始末すればよい。
たしかC++って未だに(笑)例外専用クラスって無いんでしたよね。
＃つーか大元の基本クラスすらないんだっけか
となると、言語レベルで例外Objectの扱いにお約束を与えることも
できないわけで、それが面倒をもたらしている。
C++って、ある一部に拘ってしまったばっかりに、
他の全ての利便性を獲得できなくなってしまった
という風に思える。 1000行だとちゃんと2Mくらい増えるから当てになると思う。
>boolean[] isBold 2000行だったら無条件にboolean isBold[2000]ってするのか？
デフォルトではすべてのセルは同じセルスタイルオブジェクトを共有して
いるからそんなにメモリを食わないのだけど､配列になんかしたら常にメ
モリ食いになっちゃうじゃん。 第一isBoldとかはビットフラグだと思う。
>1と2の理由は要するに、変数埋めこみObjectを許していないために
>変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
デルの事は知らないけど､変数埋め込みがあろうがなかろうが宣言と
ともにnewが呼ばれるなら抱き合わせは発生するんじゃないの？
で、変数の宣言とともにnewが呼ばれることには非常に意味があると思う。
なぜなら変数の文法的スコープとともにデストラクタを呼べるから。
事前に言葉が抜けてるよ。 「独自仕様で勝手に拡張可能なら」代入演算子は要らないだろうな。
「過去の資産が不用なら」コピーコンストラクタは要らないだろうな。
C++は、普及のために多目的・標準化・資産継承・効率を選んだ言語だからね。
独自拡張で安易に組み込み型を増やした方が、特定目的のためなら使いやすいし、
特定環境でなら便利に使えるさ。 String型なんて無いからね。 代入したくもなるさ。
Complex型なんて無いからね。 足したくもなるさ。 え、特定OSで特定目的しか考えてないからComplexなんて要らないって？
そうだろうな。普通はFORTRAN資産の置き換えなんて考えないだろうな。
なら、Variant型なんて無いからね。 COMを呼びたくもなるさ。
コピーコンストラクタを呼び出すときに、さらにコピーが発生するので、
永久にコピーコンストラクタが呼び出され続けて暴走する。
従って CFoo::CFoo(CFoo &x) でなければならない。
なお CFoo::CFoo(CFoo *x) はオブジェクトのコピー時には
呼び出されないのであしからず。 ２：代入演算子（operator=）を作るのに必要。
１と同じ理由。 コピーコンストラクタと代入演算子は、基本的に全てのクラスに書いてくれ。
各必要がないときだけ、意図的に省くように。
理由は Effective C++ 参照。 ３：例外をcatchするのに必要。
throw をコピーで catch すると、例外オブジェクトのコピーコンストラクタ内で
さらに例外が発生してややこしくなる。ポインタで catch すると、開放されたゴミメモリをポイントすることになる。
例外ハンドラは参照で catch しないといけない。
こういう話を聞くたびに、delphiを思い出すんだよね。
C++でいう参照が無いのに、別に困っていない言語。
＃delphi以外の多くの言語でもソウだけど。
delphiとかに言わせれば、 1:コピーコンストラクタなんざ要らない。
2:代入演算子なんざ要らない。
1と2の理由は要するに、変数埋めこみObjectを許していないために
変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
食らわずに済むから、です。
3:newで作った例外Objectをcatch部で受けとって始末すればよい。
たしかC++って未だに(笑)例外専用クラスって無いんでしたよね。
＃つーか大元の基本クラスすらないんだっけか
となると、言語レベルで例外Objectの扱いにお約束を与えることも
できないわけで、それが面倒をもたらしている。
C++って、ある一部に拘ってしまったばっかりに、
他の全ての利便性を獲得できなくなってしまった
という風に思える。 1000行だとちゃんと2Mくらい増えるから当てになると思う。
>boolean[] isBold 2000行だったら無条件にboolean isBold[2000]ってするのか？
デフォルトではすべてのセルは同じセルスタイルオブジェクトを共有して
いるからそんなにメモリを食わないのだけど､配列になんかしたら常にメ
モリ食いになっちゃうじゃん。 第一isBoldとかはビットフラグだと思う。
>1と2の理由は要するに、変数埋めこみObjectを許していないために
>変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
デルの事は知らないけど､変数埋め込みがあろうがなかろうが宣言と
ともにnewが呼ばれるなら抱き合わせは発生するんじゃないの？
で、変数の宣言とともにnewが呼ばれることには非常に意味があると思う。
なぜなら変数の文法的スコープとともにデストラクタを呼べるから。
事前に言葉が抜けてるよ。 「独自仕様で勝手に拡張可能なら」代入演算子は要らないだろうな。
「過去の資産が不用なら」コピーコンストラクタは要らないだろうな。
C++は、普及のために多目的・標準化・資産継承・効率を選んだ言語だからね。
独自拡張で安易に組み込み型を増やした方が、特定目的のためなら使いやすいし、
特定環境でなら便利に使えるさ。 String型なんて無いからね。 代入したくもなるさ。
Complex型なんて無いからね。 足したくもなるさ。 え、特定OSで特定目的しか考えてないからComplexなんて要らないって？
そうだろうな。普通はFORTRAN資産の置き換えなんて考えないだろうな。
なら、Variant型なんて無いからね。 COMを呼びたくもなるさ。
CFoo::CFoo(CFoo x) というコピーコンストラクタを定義するとする。
コピーコンストラクタを呼び出すときに、さらにコピーが発生するので、
永久にコピーコンストラクタが呼び出され続けて暴走する。
従って CFoo::CFoo(CFoo &x) でなければならない。
なお CFoo::CFoo(CFoo *x) はオブジェクトのコピー時には
呼び出されないのであしからず。 ２：代入演算子（operator=）を作るのに必要。
１と同じ理由。 コピーコンストラクタと代入演算子は、基本的に全てのクラスに書いてくれ。
各必要がないときだけ、意図的に省くように。
理由は Effective C++ 参照。 ３：例外をcatchするのに必要。
throw をコピーで catch すると、例外オブジェクトのコピーコンストラクタ内で
さらに例外が発生してややこしくなる。ポインタで catch すると、開放されたゴミメモリをポイントすることになる。
例外ハンドラは参照で catch しないといけない。
こういう話を聞くたびに、delphiを思い出すんだよね。
C++でいう参照が無いのに、別に困っていない言語。
＃delphi以外の多くの言語でもソウだけど。
delphiとかに言わせれば、 1:コピーコンストラクタなんざ要らない。
2:代入演算子なんざ要らない。
1と2の理由は要するに、変数埋めこみObjectを許していないために
変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
食らわずに済むから、です。
3:newで作った例外Objectをcatch部で受けとって始末すればよい。
たしかC++って未だに(笑)例外専用クラスって無いんでしたよね。
＃つーか大元の基本クラスすらないんだっけか
となると、言語レベルで例外Objectの扱いにお約束を与えることも
できないわけで、それが面倒をもたらしている。
C++って、ある一部に拘ってしまったばっかりに、
他の全ての利便性を獲得できなくなってしまった
という風に思える。 1000行だとちゃんと2Mくらい増えるから当てになると思う。
>boolean[] isBold 2000行だったら無条件にboolean isBold[2000]ってするのか？
デフォルトではすべてのセルは同じセルスタイルオブジェクトを共有して
いるからそんなにメモリを食わないのだけど､配列になんかしたら常にメ
モリ食いになっちゃうじゃん。 第一isBoldとかはビットフラグだと思う。
>1と2の理由は要するに、変数埋めこみObjectを許していないために
>変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
デルの事は知らないけど､変数埋め込みがあろうがなかろうが宣言と
ともにnewが呼ばれるなら抱き合わせは発生するんじゃないの？
で、変数の宣言とともにnewが呼ばれることには非常に意味があると思う。
なぜなら変数の文法的スコープとともにデストラクタを呼べるから。
事前に言葉が抜けてるよ。 「独自仕様で勝手に拡張可能なら」代入演算子は要らないだろうな。
「過去の資産が不用なら」コピーコンストラクタは要らないだろうな。
C++は、普及のために多目的・標準化・資産継承・効率を選んだ言語だからね。
独自拡張で安易に組み込み型を増やした方が、特定目的のためなら使いやすいし、
特定環境でなら便利に使えるさ。 String型なんて無いからね。 代入したくもなるさ。
Complex型なんて無いからね。 足したくもなるさ。 え、特定OSで特定目的しか考えてないからComplexなんて要らないって？
そうだろうな。普通はFORTRAN資産の置き換えなんて考えないだろうな。
なら、Variant型なんて無いからね。 COMを呼びたくもなるさ。
コピーコンストラクタを呼び出すときに、さらにコピーが発生するので、
永久にコピーコンストラクタが呼び出され続けて暴走する。
従って CFoo::CFoo(CFoo &x) でなければならない。
なお CFoo::CFoo(CFoo *x) はオブジェクトのコピー時には
呼び出されないのであしからず。 ２：代入演算子（operator=）を作るのに必要。
１と同じ理由。 コピーコンストラクタと代入演算子は、基本的に全てのクラスに書いてくれ。
各必要がないときだけ、意図的に省くように。
理由は Effective C++ 参照。 ３：例外をcatchするのに必要。
throw をコピーで catch すると、例外オブジェクトのコピーコンストラクタ内で
さらに例外が発生してややこしくなる。ポインタで catch すると、開放されたゴミメモリをポイントすることになる。
例外ハンドラは参照で catch しないといけない。
こういう話を聞くたびに、delphiを思い出すんだよね。
C++でいう参照が無いのに、別に困っていない言語。
＃delphi以外の多くの言語でもソウだけど。
delphiとかに言わせれば、 1:コピーコンストラクタなんざ要らない。
2:代入演算子なんざ要らない。
1と2の理由は要するに、変数埋めこみObjectを許していないために
変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
食らわずに済むから、です。
3:newで作った例外Objectをcatch部で受けとって始末すればよい。
たしかC++って未だに(笑)例外専用クラスって無いんでしたよね。
＃つーか大元の基本クラスすらないんだっけか
となると、言語レベルで例外Objectの扱いにお約束を与えることも
できないわけで、それが面倒をもたらしている。
C++って、ある一部に拘ってしまったばっかりに、
他の全ての利便性を獲得できなくなってしまった
という風に思える。 1000行だとちゃんと2Mくらい増えるから当てになると思う。
>boolean[] isBold 2000行だったら無条件にboolean isBold[2000]ってするのか？
デフォルトではすべてのセルは同じセルスタイルオブジェクトを共有して
いるからそんなにメモリを食わないのだけど､配列になんかしたら常にメ
モリ食いになっちゃうじゃん。 第一isBoldとかはビットフラグだと思う。
>1と2の理由は要するに、変数埋めこみObjectを許していないために
>変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
デルの事は知らないけど､変数埋め込みがあろうがなかろうが宣言と
ともにnewが呼ばれるなら抱き合わせは発生するんじゃないの？
で、変数の宣言とともにnewが呼ばれることには非常に意味があると思う。
なぜなら変数の文法的スコープとともにデストラクタを呼べるから。
事前に言葉が抜けてるよ。 「独自仕様で勝手に拡張可能なら」代入演算子は要らないだろうな。
「過去の資産が不用なら」コピーコンストラクタは要らないだろうな。
C++は、普及のために多目的・標準化・資産継承・効率を選んだ言語だからね。
独自拡張で安易に組み込み型を増やした方が、特定目的のためなら使いやすいし、
特定環境でなら便利に使えるさ。 String型なんて無いからね。 代入したくもなるさ。
Complex型なんて無いからね。 足したくもなるさ。 え、特定OSで特定目的しか考えてないからComplexなんて要らないって？
そうだろうな。普通はFORTRAN資産の置き換えなんて考えないだろうな。
なら、Variant型なんて無いからね。 COMを呼びたくもなるさ。
CFoo::CFoo(CFoo x) というコピーコンストラクタを定義するとする。
コピーコンストラクタを呼び出すときに、さらにコピーが発生するので、
永久にコピーコンストラクタが呼び出され続けて暴走する。
従って CFoo::CFoo(CFoo &x) でなければならない。
なお CFoo::CFoo(CFoo *x) はオブジェクトのコピー時には
呼び出されないのであしからず。 ２：代入演算子（operator=）を作るのに必要。
１と同じ理由。 コピーコンストラクタと代入演算子は、基本的に全てのクラスに書いてくれ。
各必要がないときだけ、意図的に省くように。
理由は Effective C++ 参照。 ３：例外をcatchするのに必要。
throw をコピーで catch すると、例外オブジェクトのコピーコンストラクタ内で
さらに例外が発生してややこしくなる。ポインタで catch すると、開放されたゴミメモリをポイントすることになる。
例外ハンドラは参照で catch しないといけない。
こういう話を聞くたびに、delphiを思い出すんだよね。
C++でいう参照が無いのに、別に困っていない言語。
＃delphi以外の多くの言語でもソウだけど。
delphiとかに言わせれば、 1:コピーコンストラクタなんざ要らない。
2:代入演算子なんざ要らない。
1と2の理由は要するに、変数埋めこみObjectを許していないために
変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
食らわずに済むから、です。
3:newで作った例外Objectをcatch部で受けとって始末すればよい。
たしかC++って未だに(笑)例外専用クラスって無いんでしたよね。
＃つーか大元の基本クラスすらないんだっけか
となると、言語レベルで例外Objectの扱いにお約束を与えることも
できないわけで、それが面倒をもたらしている。
C++って、ある一部に拘ってしまったばっかりに、
他の全ての利便性を獲得できなくなってしまった
という風に思える。 1000行だとちゃんと2Mくらい増えるから当てになると思う。
>boolean[] isBold 2000行だったら無条件にboolean isBold[2000]ってするのか？
デフォルトではすべてのセルは同じセルスタイルオブジェクトを共有して
いるからそんなにメモリを食わないのだけど､配列になんかしたら常にメ
モリ食いになっちゃうじゃん。 第一isBoldとかはビットフラグだと思う。
>1と2の理由は要するに、変数埋めこみObjectを許していないために
>変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
デルの事は知らないけど､変数埋め込みがあろうがなかろうが宣言と
ともにnewが呼ばれるなら抱き合わせは発生するんじゃないの？
で、変数の宣言とともにnewが呼ばれることには非常に意味があると思う。
なぜなら変数の文法的スコープとともにデストラクタを呼べるから。
事前に言葉が抜けてるよ。 「独自仕様で勝手に拡張可能なら」代入演算子は要らないだろうな。
「過去の資産が不用なら」コピーコンストラクタは要らないだろうな。
C++は、普及のために多目的・標準化・資産継承・効率を選んだ言語だからね。
独自拡張で安易に組み込み型を増やした方が、特定目的のためなら使いやすいし、
特定環境でなら便利に使えるさ。 String型なんて無いからね。 代入したくもなるさ。
Complex型なんて無いからね。 足したくもなるさ。 え、特定OSで特定目的しか考えてないからComplexなんて要らないって？
そうだろうな。普通はFORTRAN資産の置き換えなんて考えないだろうな。
なら、Variant型なんて無いからね。 COMを呼びたくもなるさ。
コピーコンストラクタを呼び出すときに、さらにコピーが発生するので、
永久にコピーコンストラクタが呼び出され続けて暴走する。
従って CFoo::CFoo(CFoo &x) でなければならない。
なお CFoo::CFoo(CFoo *x) はオブジェクトのコピー時には
呼び出されないのであしからず。 ２：代入演算子（operator=）を作るのに必要。
１と同じ理由。 コピーコンストラクタと代入演算子は、基本的に全てのクラスに書いてくれ。
各必要がないときだけ、意図的に省くように。
理由は Effective C++ 参照。 ３：例外をcatchするのに必要。
throw をコピーで catch すると、例外オブジェクトのコピーコンストラクタ内で
さらに例外が発生してややこしくなる。ポインタで catch すると、開放されたゴミメモリをポイントすることになる。
例外ハンドラは参照で catch しないといけない。
こういう話を聞くたびに、delphiを思い出すんだよね。
C++でいう参照が無いのに、別に困っていない言語。
＃delphi以外の多くの言語でもソウだけど。
delphiとかに言わせれば、 1:コピーコンストラクタなんざ要らない。
2:代入演算子なんざ要らない。
1と2の理由は要するに、変数埋めこみObjectを許していないために
変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
食らわずに済むから、です。
3:newで作った例外Objectをcatch部で受けとって始末すればよい。
たしかC++って未だに(笑)例外専用クラスって無いんでしたよね。
＃つーか大元の基本クラスすらないんだっけか
となると、言語レベルで例外Objectの扱いにお約束を与えることも
できないわけで、それが面倒をもたらしている。
C++って、ある一部に拘ってしまったばっかりに、
他の全ての利便性を獲得できなくなってしまった
という風に思える。 1000行だとちゃんと2Mくらい増えるから当てになると思う。
>boolean[] isBold 2000行だったら無条件にboolean isBold[2000]ってするのか？
デフォルトではすべてのセルは同じセルスタイルオブジェクトを共有して
いるからそんなにメモリを食わないのだけど､配列になんかしたら常にメ
モリ食いになっちゃうじゃん。 第一isBoldとかはビットフラグだと思う。
>1と2の理由は要するに、変数埋めこみObjectを許していないために
>変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
デルの事は知らないけど､変数埋め込みがあろうがなかろうが宣言と
ともにnewが呼ばれるなら抱き合わせは発生するんじゃないの？
で、変数の宣言とともにnewが呼ばれることには非常に意味があると思う。
なぜなら変数の文法的スコープとともにデストラクタを呼べるから。
事前に言葉が抜けてるよ。 「独自仕様で勝手に拡張可能なら」代入演算子は要らないだろうな。
「過去の資産が不用なら」コピーコンストラクタは要らないだろうな。
C++は、普及のために多目的・標準化・資産継承・効率を選んだ言語だからね。
独自拡張で安易に組み込み型を増やした方が、特定目的のためなら使いやすいし、
特定環境でなら便利に使えるさ。 String型なんて無いからね。 代入したくもなるさ。
Complex型なんて無いからね。 足したくもなるさ。 え、特定OSで特定目的しか考えてないからComplexなんて要らないって？
そうだろうな。普通はFORTRAN資産の置き換えなんて考えないだろうな。
なら、Variant型なんて無いからね。 COMを呼びたくもなるさ。
18 ：ななしさん：2001/07/15(日) 22:10
>1
死ね、ばか。
>13
死ね、ばか。
死ね、ばか。
>13
死ね、ばか。
CFoo::CFoo(CFoo x) というコピーコンストラクタを定義するとする。
コピーコンストラクタを呼び出すときに、さらにコピーが発生するので、
永久にコピーコンストラクタが呼び出され続けて暴走する。
従って CFoo::CFoo(CFoo &x) でなければならない。
なお CFoo::CFoo(CFoo *x) はオブジェクトのコピー時には
呼び出されないのであしからず。 ２：代入演算子（operator=）を作るのに必要。
１と同じ理由。 コピーコンストラクタと代入演算子は、基本的に全てのクラスに書いてくれ。
各必要がないときだけ、意図的に省くように。
理由は Effective C++ 参照。 ３：例外をcatchするのに必要。
throw をコピーで catch すると、例外オブジェクトのコピーコンストラクタ内で
さらに例外が発生してややこしくなる。ポインタで catch すると、開放されたゴミメモリをポイントすることになる。
例外ハンドラは参照で catch しないといけない。
こういう話を聞くたびに、delphiを思い出すんだよね。
C++でいう参照が無いのに、別に困っていない言語。
＃delphi以外の多くの言語でもソウだけど。
delphiとかに言わせれば、 1:コピーコンストラクタなんざ要らない。
2:代入演算子なんざ要らない。
1と2の理由は要するに、変数埋めこみObjectを許していないために
変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
食らわずに済むから、です。
3:newで作った例外Objectをcatch部で受けとって始末すればよい。
たしかC++って未だに(笑)例外専用クラスって無いんでしたよね。
＃つーか大元の基本クラスすらないんだっけか
となると、言語レベルで例外Objectの扱いにお約束を与えることも
できないわけで、それが面倒をもたらしている。
C++って、ある一部に拘ってしまったばっかりに、
他の全ての利便性を獲得できなくなってしまった
という風に思える。 1000行だとちゃんと2Mくらい増えるから当てになると思う。
>boolean[] isBold 2000行だったら無条件にboolean isBold[2000]ってするのか？
デフォルトではすべてのセルは同じセルスタイルオブジェクトを共有して
いるからそんなにメモリを食わないのだけど､配列になんかしたら常にメ
モリ食いになっちゃうじゃん。 第一isBoldとかはビットフラグだと思う。
>1と2の理由は要するに、変数埋めこみObjectを許していないために
>変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
デルの事は知らないけど､変数埋め込みがあろうがなかろうが宣言と
ともにnewが呼ばれるなら抱き合わせは発生するんじゃないの？
で、変数の宣言とともにnewが呼ばれることには非常に意味があると思う。
なぜなら変数の文法的スコープとともにデストラクタを呼べるから。
事前に言葉が抜けてるよ。 「独自仕様で勝手に拡張可能なら」代入演算子は要らないだろうな。
「過去の資産が不用なら」コピーコンストラクタは要らないだろうな。
C++は、普及のために多目的・標準化・資産継承・効率を選んだ言語だからね。
独自拡張で安易に組み込み型を増やした方が、特定目的のためなら使いやすいし、
特定環境でなら便利に使えるさ。 String型なんて無いからね。 代入したくもなるさ。
Complex型なんて無いからね。 足したくもなるさ。 え、特定OSで特定目的しか考えてないからComplexなんて要らないって？
そうだろうな。普通はFORTRAN資産の置き換えなんて考えないだろうな。
なら、Variant型なんて無いからね。 COMを呼びたくもなるさ。
コピーコンストラクタを呼び出すときに、さらにコピーが発生するので、
永久にコピーコンストラクタが呼び出され続けて暴走する。
従って CFoo::CFoo(CFoo &x) でなければならない。
なお CFoo::CFoo(CFoo *x) はオブジェクトのコピー時には
呼び出されないのであしからず。 ２：代入演算子（operator=）を作るのに必要。
１と同じ理由。 コピーコンストラクタと代入演算子は、基本的に全てのクラスに書いてくれ。
各必要がないときだけ、意図的に省くように。
理由は Effective C++ 参照。 ３：例外をcatchするのに必要。
throw をコピーで catch すると、例外オブジェクトのコピーコンストラクタ内で
さらに例外が発生してややこしくなる。ポインタで catch すると、開放されたゴミメモリをポイントすることになる。
例外ハンドラは参照で catch しないといけない。
こういう話を聞くたびに、delphiを思い出すんだよね。
C++でいう参照が無いのに、別に困っていない言語。
＃delphi以外の多くの言語でもソウだけど。
delphiとかに言わせれば、 1:コピーコンストラクタなんざ要らない。
2:代入演算子なんざ要らない。
1と2の理由は要するに、変数埋めこみObjectを許していないために
変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
食らわずに済むから、です。
3:newで作った例外Objectをcatch部で受けとって始末すればよい。
たしかC++って未だに(笑)例外専用クラスって無いんでしたよね。
＃つーか大元の基本クラスすらないんだっけか
となると、言語レベルで例外Objectの扱いにお約束を与えることも
できないわけで、それが面倒をもたらしている。
C++って、ある一部に拘ってしまったばっかりに、
他の全ての利便性を獲得できなくなってしまった
という風に思える。 1000行だとちゃんと2Mくらい増えるから当てになると思う。
>boolean[] isBold 2000行だったら無条件にboolean isBold[2000]ってするのか？
デフォルトではすべてのセルは同じセルスタイルオブジェクトを共有して
いるからそんなにメモリを食わないのだけど､配列になんかしたら常にメ
モリ食いになっちゃうじゃん。 第一isBoldとかはビットフラグだと思う。
>1と2の理由は要するに、変数埋めこみObjectを許していないために
>変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
デルの事は知らないけど､変数埋め込みがあろうがなかろうが宣言と
ともにnewが呼ばれるなら抱き合わせは発生するんじゃないの？
で、変数の宣言とともにnewが呼ばれることには非常に意味があると思う。
なぜなら変数の文法的スコープとともにデストラクタを呼べるから。
事前に言葉が抜けてるよ。 「独自仕様で勝手に拡張可能なら」代入演算子は要らないだろうな。
「過去の資産が不用なら」コピーコンストラクタは要らないだろうな。
C++は、普及のために多目的・標準化・資産継承・効率を選んだ言語だからね。
独自拡張で安易に組み込み型を増やした方が、特定目的のためなら使いやすいし、
特定環境でなら便利に使えるさ。 String型なんて無いからね。 代入したくもなるさ。
Complex型なんて無いからね。 足したくもなるさ。 え、特定OSで特定目的しか考えてないからComplexなんて要らないって？
そうだろうな。普通はFORTRAN資産の置き換えなんて考えないだろうな。
なら、Variant型なんて無いからね。 COMを呼びたくもなるさ。
CFoo::CFoo(CFoo x) というコピーコンストラクタを定義するとする。
コピーコンストラクタを呼び出すときに、さらにコピーが発生するので、
永久にコピーコンストラクタが呼び出され続けて暴走する。
従って CFoo::CFoo(CFoo &x) でなければならない。
なお CFoo::CFoo(CFoo *x) はオブジェクトのコピー時には
呼び出されないのであしからず。 ２：代入演算子（operator=）を作るのに必要。
１と同じ理由。 コピーコンストラクタと代入演算子は、基本的に全てのクラスに書いてくれ。
各必要がないときだけ、意図的に省くように。
理由は Effective C++ 参照。 ３：例外をcatchするのに必要。
throw をコピーで catch すると、例外オブジェクトのコピーコンストラクタ内で
さらに例外が発生してややこしくなる。ポインタで catch すると、開放されたゴミメモリをポイントすることになる。
例外ハンドラは参照で catch しないといけない。
こういう話を聞くたびに、delphiを思い出すんだよね。
C++でいう参照が無いのに、別に困っていない言語。
＃delphi以外の多くの言語でもソウだけど。
delphiとかに言わせれば、 1:コピーコンストラクタなんざ要らない。
2:代入演算子なんざ要らない。
1と2の理由は要するに、変数埋めこみObjectを許していないために
変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
食らわずに済むから、です。
3:newで作った例外Objectをcatch部で受けとって始末すればよい。
たしかC++って未だに(笑)例外専用クラスって無いんでしたよね。
＃つーか大元の基本クラスすらないんだっけか
となると、言語レベルで例外Objectの扱いにお約束を与えることも
できないわけで、それが面倒をもたらしている。
C++って、ある一部に拘ってしまったばっかりに、
他の全ての利便性を獲得できなくなってしまった
という風に思える。 1000行だとちゃんと2Mくらい増えるから当てになると思う。
>boolean[] isBold 2000行だったら無条件にboolean isBold[2000]ってするのか？
デフォルトではすべてのセルは同じセルスタイルオブジェクトを共有して
いるからそんなにメモリを食わないのだけど､配列になんかしたら常にメ
モリ食いになっちゃうじゃん。 第一isBoldとかはビットフラグだと思う。
>1と2の理由は要するに、変数埋めこみObjectを許していないために
>変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
デルの事は知らないけど､変数埋め込みがあろうがなかろうが宣言と
ともにnewが呼ばれるなら抱き合わせは発生するんじゃないの？
で、変数の宣言とともにnewが呼ばれることには非常に意味があると思う。
なぜなら変数の文法的スコープとともにデストラクタを呼べるから。
事前に言葉が抜けてるよ。 「独自仕様で勝手に拡張可能なら」代入演算子は要らないだろうな。
「過去の資産が不用なら」コピーコンストラクタは要らないだろうな。
C++は、普及のために多目的・標準化・資産継承・効率を選んだ言語だからね。
独自拡張で安易に組み込み型を増やした方が、特定目的のためなら使いやすいし、
特定環境でなら便利に使えるさ。 String型なんて無いからね。 代入したくもなるさ。
Complex型なんて無いからね。 足したくもなるさ。 え、特定OSで特定目的しか考えてないからComplexなんて要らないって？
そうだろうな。普通はFORTRAN資産の置き換えなんて考えないだろうな。
なら、Variant型なんて無いからね。 COMを呼びたくもなるさ。
コピーコンストラクタを呼び出すときに、さらにコピーが発生するので、
永久にコピーコンストラクタが呼び出され続けて暴走する。
従って CFoo::CFoo(CFoo &x) でなければならない。
なお CFoo::CFoo(CFoo *x) はオブジェクトのコピー時には
呼び出されないのであしからず。 ２：代入演算子（operator=）を作るのに必要。
１と同じ理由。 コピーコンストラクタと代入演算子は、基本的に全てのクラスに書いてくれ。
各必要がないときだけ、意図的に省くように。
理由は Effective C++ 参照。 ３：例外をcatchするのに必要。
throw をコピーで catch すると、例外オブジェクトのコピーコンストラクタ内で
さらに例外が発生してややこしくなる。ポインタで catch すると、開放されたゴミメモリをポイントすることになる。
例外ハンドラは参照で catch しないといけない。
こういう話を聞くたびに、delphiを思い出すんだよね。
C++でいう参照が無いのに、別に困っていない言語。
＃delphi以外の多くの言語でもソウだけど。
delphiとかに言わせれば、 1:コピーコンストラクタなんざ要らない。
2:代入演算子なんざ要らない。
1と2の理由は要するに、変数埋めこみObjectを許していないために
変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
食らわずに済むから、です。
3:newで作った例外Objectをcatch部で受けとって始末すればよい。
たしかC++って未だに(笑)例外専用クラスって無いんでしたよね。
＃つーか大元の基本クラスすらないんだっけか
となると、言語レベルで例外Objectの扱いにお約束を与えることも
できないわけで、それが面倒をもたらしている。
C++って、ある一部に拘ってしまったばっかりに、
他の全ての利便性を獲得できなくなってしまった
という風に思える。 1000行だとちゃんと2Mくらい増えるから当てになると思う。
>boolean[] isBold 2000行だったら無条件にboolean isBold[2000]ってするのか？
デフォルトではすべてのセルは同じセルスタイルオブジェクトを共有して
いるからそんなにメモリを食わないのだけど､配列になんかしたら常にメ
モリ食いになっちゃうじゃん。 第一isBoldとかはビットフラグだと思う。
>1と2の理由は要するに、変数埋めこみObjectを許していないために
>変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
デルの事は知らないけど､変数埋め込みがあろうがなかろうが宣言と
ともにnewが呼ばれるなら抱き合わせは発生するんじゃないの？
で、変数の宣言とともにnewが呼ばれることには非常に意味があると思う。
なぜなら変数の文法的スコープとともにデストラクタを呼べるから。
事前に言葉が抜けてるよ。 「独自仕様で勝手に拡張可能なら」代入演算子は要らないだろうな。
「過去の資産が不用なら」コピーコンストラクタは要らないだろうな。
C++は、普及のために多目的・標準化・資産継承・効率を選んだ言語だからね。
独自拡張で安易に組み込み型を増やした方が、特定目的のためなら使いやすいし、
特定環境でなら便利に使えるさ。 String型なんて無いからね。 代入したくもなるさ。
Complex型なんて無いからね。 足したくもなるさ。 え、特定OSで特定目的しか考えてないからComplexなんて要らないって？
そうだろうな。普通はFORTRAN資産の置き換えなんて考えないだろうな。
なら、Variant型なんて無いからね。 COMを呼びたくもなるさ。
CFoo::CFoo(CFoo x) というコピーコンストラクタを定義するとする。
コピーコンストラクタを呼び出すときに、さらにコピーが発生するので、
永久にコピーコンストラクタが呼び出され続けて暴走する。
従って CFoo::CFoo(CFoo &x) でなければならない。
なお CFoo::CFoo(CFoo *x) はオブジェクトのコピー時には
呼び出されないのであしからず。 ２：代入演算子（operator=）を作るのに必要。
１と同じ理由。 コピーコンストラクタと代入演算子は、基本的に全てのクラスに書いてくれ。
各必要がないときだけ、意図的に省くように。
理由は Effective C++ 参照。 ３：例外をcatchするのに必要。
throw をコピーで catch すると、例外オブジェクトのコピーコンストラクタ内で
さらに例外が発生してややこしくなる。ポインタで catch すると、開放されたゴミメモリをポイントすることになる。
例外ハンドラは参照で catch しないといけない。
こういう話を聞くたびに、delphiを思い出すんだよね。
C++でいう参照が無いのに、別に困っていない言語。
＃delphi以外の多くの言語でもソウだけど。
delphiとかに言わせれば、 1:コピーコンストラクタなんざ要らない。
2:代入演算子なんざ要らない。
1と2の理由は要するに、変数埋めこみObjectを許していないために
変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
食らわずに済むから、です。
3:newで作った例外Objectをcatch部で受けとって始末すればよい。
たしかC++って未だに(笑)例外専用クラスって無いんでしたよね。
＃つーか大元の基本クラスすらないんだっけか
となると、言語レベルで例外Objectの扱いにお約束を与えることも
できないわけで、それが面倒をもたらしている。
C++って、ある一部に拘ってしまったばっかりに、
他の全ての利便性を獲得できなくなってしまった
という風に思える。 1000行だとちゃんと2Mくらい増えるから当てになると思う。
>boolean[] isBold 2000行だったら無条件にboolean isBold[2000]ってするのか？
デフォルトではすべてのセルは同じセルスタイルオブジェクトを共有して
いるからそんなにメモリを食わないのだけど､配列になんかしたら常にメ
モリ食いになっちゃうじゃん。 第一isBoldとかはビットフラグだと思う。
>1と2の理由は要するに、変数埋めこみObjectを許していないために
>変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
デルの事は知らないけど､変数埋め込みがあろうがなかろうが宣言と
ともにnewが呼ばれるなら抱き合わせは発生するんじゃないの？
で、変数の宣言とともにnewが呼ばれることには非常に意味があると思う。
なぜなら変数の文法的スコープとともにデストラクタを呼べるから。
事前に言葉が抜けてるよ。 「独自仕様で勝手に拡張可能なら」代入演算子は要らないだろうな。
「過去の資産が不用なら」コピーコンストラクタは要らないだろうな。
C++は、普及のために多目的・標準化・資産継承・効率を選んだ言語だからね。
独自拡張で安易に組み込み型を増やした方が、特定目的のためなら使いやすいし、
特定環境でなら便利に使えるさ。 String型なんて無いからね。 代入したくもなるさ。
Complex型なんて無いからね。 足したくもなるさ。 え、特定OSで特定目的しか考えてないからComplexなんて要らないって？
そうだろうな。普通はFORTRAN資産の置き換えなんて考えないだろうな。
なら、Variant型なんて無いからね。 COMを呼びたくもなるさ。
コピーコンストラクタを呼び出すときに、さらにコピーが発生するので、
永久にコピーコンストラクタが呼び出され続けて暴走する。
従って CFoo::CFoo(CFoo &x) でなければならない。
なお CFoo::CFoo(CFoo *x) はオブジェクトのコピー時には
呼び出されないのであしからず。 ２：代入演算子（operator=）を作るのに必要。
１と同じ理由。 コピーコンストラクタと代入演算子は、基本的に全てのクラスに書いてくれ。
各必要がないときだけ、意図的に省くように。
理由は Effective C++ 参照。 ３：例外をcatchするのに必要。
throw をコピーで catch すると、例外オブジェクトのコピーコンストラクタ内で
さらに例外が発生してややこしくなる。ポインタで catch すると、開放されたゴミメモリをポイントすることになる。
例外ハンドラは参照で catch しないといけない。
こういう話を聞くたびに、delphiを思い出すんだよね。
C++でいう参照が無いのに、別に困っていない言語。
＃delphi以外の多くの言語でもソウだけど。
delphiとかに言わせれば、 1:コピーコンストラクタなんざ要らない。
2:代入演算子なんざ要らない。
1と2の理由は要するに、変数埋めこみObjectを許していないために
変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
食らわずに済むから、です。
3:newで作った例外Objectをcatch部で受けとって始末すればよい。
たしかC++って未だに(笑)例外専用クラスって無いんでしたよね。
＃つーか大元の基本クラスすらないんだっけか
となると、言語レベルで例外Objectの扱いにお約束を与えることも
できないわけで、それが面倒をもたらしている。
C++って、ある一部に拘ってしまったばっかりに、
他の全ての利便性を獲得できなくなってしまった
という風に思える。 1000行だとちゃんと2Mくらい増えるから当てになると思う。
>boolean[] isBold 2000行だったら無条件にboolean isBold[2000]ってするのか？
デフォルトではすべてのセルは同じセルスタイルオブジェクトを共有して
いるからそんなにメモリを食わないのだけど､配列になんかしたら常にメ
モリ食いになっちゃうじゃん。 第一isBoldとかはビットフラグだと思う。
>1と2の理由は要するに、変数埋めこみObjectを許していないために
>変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
デルの事は知らないけど､変数埋め込みがあろうがなかろうが宣言と
ともにnewが呼ばれるなら抱き合わせは発生するんじゃないの？
で、変数の宣言とともにnewが呼ばれることには非常に意味があると思う。
なぜなら変数の文法的スコープとともにデストラクタを呼べるから。
事前に言葉が抜けてるよ。 「独自仕様で勝手に拡張可能なら」代入演算子は要らないだろうな。
「過去の資産が不用なら」コピーコンストラクタは要らないだろうな。
C++は、普及のために多目的・標準化・資産継承・効率を選んだ言語だからね。
独自拡張で安易に組み込み型を増やした方が、特定目的のためなら使いやすいし、
特定環境でなら便利に使えるさ。 String型なんて無いからね。 代入したくもなるさ。
Complex型なんて無いからね。 足したくもなるさ。 え、特定OSで特定目的しか考えてないからComplexなんて要らないって？
そうだろうな。普通はFORTRAN資産の置き換えなんて考えないだろうな。
なら、Variant型なんて無いからね。 COMを呼びたくもなるさ。
CFoo::CFoo(CFoo x) というコピーコンストラクタを定義するとする。
コピーコンストラクタを呼び出すときに、さらにコピーが発生するので、
永久にコピーコンストラクタが呼び出され続けて暴走する。
従って CFoo::CFoo(CFoo &x) でなければならない。
なお CFoo::CFoo(CFoo *x) はオブジェクトのコピー時には
呼び出されないのであしからず。 ２：代入演算子（operator=）を作るのに必要。
１と同じ理由。 コピーコンストラクタと代入演算子は、基本的に全てのクラスに書いてくれ。
各必要がないときだけ、意図的に省くように。
理由は Effective C++ 参照。 ３：例外をcatchするのに必要。
throw をコピーで catch すると、例外オブジェクトのコピーコンストラクタ内で
さらに例外が発生してややこしくなる。ポインタで catch すると、開放されたゴミメモリをポイントすることになる。
例外ハンドラは参照で catch しないといけない。
こういう話を聞くたびに、delphiを思い出すんだよね。
C++でいう参照が無いのに、別に困っていない言語。
＃delphi以外の多くの言語でもソウだけど。
delphiとかに言わせれば、 1:コピーコンストラクタなんざ要らない。
2:代入演算子なんざ要らない。
1と2の理由は要するに、変数埋めこみObjectを許していないために
変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
食らわずに済むから、です。
3:newで作った例外Objectをcatch部で受けとって始末すればよい。
たしかC++って未だに(笑)例外専用クラスって無いんでしたよね。
＃つーか大元の基本クラスすらないんだっけか
となると、言語レベルで例外Objectの扱いにお約束を与えることも
できないわけで、それが面倒をもたらしている。
C++って、ある一部に拘ってしまったばっかりに、
他の全ての利便性を獲得できなくなってしまった
という風に思える。 1000行だとちゃんと2Mくらい増えるから当てになると思う。
>boolean[] isBold 2000行だったら無条件にboolean isBold[2000]ってするのか？
デフォルトではすべてのセルは同じセルスタイルオブジェクトを共有して
いるからそんなにメモリを食わないのだけど､配列になんかしたら常にメ
モリ食いになっちゃうじゃん。 第一isBoldとかはビットフラグだと思う。
>1と2の理由は要するに、変数埋めこみObjectを許していないために
>変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
デルの事は知らないけど､変数埋め込みがあろうがなかろうが宣言と
ともにnewが呼ばれるなら抱き合わせは発生するんじゃないの？
で、変数の宣言とともにnewが呼ばれることには非常に意味があると思う。
なぜなら変数の文法的スコープとともにデストラクタを呼べるから。
事前に言葉が抜けてるよ。 「独自仕様で勝手に拡張可能なら」代入演算子は要らないだろうな。
「過去の資産が不用なら」コピーコンストラクタは要らないだろうな。
C++は、普及のために多目的・標準化・資産継承・効率を選んだ言語だからね。
独自拡張で安易に組み込み型を増やした方が、特定目的のためなら使いやすいし、
特定環境でなら便利に使えるさ。 String型なんて無いからね。 代入したくもなるさ。
Complex型なんて無いからね。 足したくもなるさ。 え、特定OSで特定目的しか考えてないからComplexなんて要らないって？
そうだろうな。普通はFORTRAN資産の置き換えなんて考えないだろうな。
なら、Variant型なんて無いからね。 COMを呼びたくもなるさ。
コピーコンストラクタを呼び出すときに、さらにコピーが発生するので、
永久にコピーコンストラクタが呼び出され続けて暴走する。
従って CFoo::CFoo(CFoo &x) でなければならない。
なお CFoo::CFoo(CFoo *x) はオブジェクトのコピー時には
呼び出されないのであしからず。 ２：代入演算子（operator=）を作るのに必要。
１と同じ理由。 コピーコンストラクタと代入演算子は、基本的に全てのクラスに書いてくれ。
各必要がないときだけ、意図的に省くように。
理由は Effective C++ 参照。 ３：例外をcatchするのに必要。
throw をコピーで catch すると、例外オブジェクトのコピーコンストラクタ内で
さらに例外が発生してややこしくなる。ポインタで catch すると、開放されたゴミメモリをポイントすることになる。
例外ハンドラは参照で catch しないといけない。
こういう話を聞くたびに、delphiを思い出すんだよね。
C++でいう参照が無いのに、別に困っていない言語。
＃delphi以外の多くの言語でもソウだけど。
delphiとかに言わせれば、 1:コピーコンストラクタなんざ要らない。
2:代入演算子なんざ要らない。
1と2の理由は要するに、変数埋めこみObjectを許していないために
変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
食らわずに済むから、です。
3:newで作った例外Objectをcatch部で受けとって始末すればよい。
たしかC++って未だに(笑)例外専用クラスって無いんでしたよね。
＃つーか大元の基本クラスすらないんだっけか
となると、言語レベルで例外Objectの扱いにお約束を与えることも
できないわけで、それが面倒をもたらしている。
C++って、ある一部に拘ってしまったばっかりに、
他の全ての利便性を獲得できなくなってしまった
という風に思える。 1000行だとちゃんと2Mくらい増えるから当てになると思う。
>boolean[] isBold 2000行だったら無条件にboolean isBold[2000]ってするのか？
デフォルトではすべてのセルは同じセルスタイルオブジェクトを共有して
いるからそんなにメモリを食わないのだけど､配列になんかしたら常にメ
モリ食いになっちゃうじゃん。 第一isBoldとかはビットフラグだと思う。
>1と2の理由は要するに、変数埋めこみObjectを許していないために
>変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
デルの事は知らないけど､変数埋め込みがあろうがなかろうが宣言と
ともにnewが呼ばれるなら抱き合わせは発生するんじゃないの？
で、変数の宣言とともにnewが呼ばれることには非常に意味があると思う。
なぜなら変数の文法的スコープとともにデストラクタを呼べるから。
事前に言葉が抜けてるよ。 「独自仕様で勝手に拡張可能なら」代入演算子は要らないだろうな。
「過去の資産が不用なら」コピーコンストラクタは要らないだろうな。
C++は、普及のために多目的・標準化・資産継承・効率を選んだ言語だからね。
独自拡張で安易に組み込み型を増やした方が、特定目的のためなら使いやすいし、
特定環境でなら便利に使えるさ。 String型なんて無いからね。 代入したくもなるさ。
Complex型なんて無いからね。 足したくもなるさ。 え、特定OSで特定目的しか考えてないからComplexなんて要らないって？
そうだろうな。普通はFORTRAN資産の置き換えなんて考えないだろうな。
なら、Variant型なんて無いからね。 COMを呼びたくもなるさ。
CFoo::CFoo(CFoo x) というコピーコンストラクタを定義するとする。
コピーコンストラクタを呼び出すときに、さらにコピーが発生するので、
永久にコピーコンストラクタが呼び出され続けて暴走する。
従って CFoo::CFoo(CFoo &x) でなければならない。
なお CFoo::CFoo(CFoo *x) はオブジェクトのコピー時には
呼び出されないのであしからず。 ２：代入演算子（operator=）を作るのに必要。
１と同じ理由。 コピーコンストラクタと代入演算子は、基本的に全てのクラスに書いてくれ。
各必要がないときだけ、意図的に省くように。
理由は Effective C++ 参照。 ３：例外をcatchするのに必要。
throw をコピーで catch すると、例外オブジェクトのコピーコンストラクタ内で
さらに例外が発生してややこしくなる。ポインタで catch すると、開放されたゴミメモリをポイントすることになる。
例外ハンドラは参照で catch しないといけない。
こういう話を聞くたびに、delphiを思い出すんだよね。
C++でいう参照が無いのに、別に困っていない言語。
＃delphi以外の多くの言語でもソウだけど。
delphiとかに言わせれば、 1:コピーコンストラクタなんざ要らない。
2:代入演算子なんざ要らない。
1と2の理由は要するに、変数埋めこみObjectを許していないために
変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
食らわずに済むから、です。
3:newで作った例外Objectをcatch部で受けとって始末すればよい。
たしかC++って未だに(笑)例外専用クラスって無いんでしたよね。
＃つーか大元の基本クラスすらないんだっけか
となると、言語レベルで例外Objectの扱いにお約束を与えることも
できないわけで、それが面倒をもたらしている。
C++って、ある一部に拘ってしまったばっかりに、
他の全ての利便性を獲得できなくなってしまった
という風に思える。 1000行だとちゃんと2Mくらい増えるから当てになると思う。
>boolean[] isBold 2000行だったら無条件にboolean isBold[2000]ってするのか？
デフォルトではすべてのセルは同じセルスタイルオブジェクトを共有して
いるからそんなにメモリを食わないのだけど､配列になんかしたら常にメ
モリ食いになっちゃうじゃん。 第一isBoldとかはビットフラグだと思う。
>1と2の理由は要するに、変数埋めこみObjectを許していないために
>変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
デルの事は知らないけど､変数埋め込みがあろうがなかろうが宣言と
ともにnewが呼ばれるなら抱き合わせは発生するんじゃないの？
で、変数の宣言とともにnewが呼ばれることには非常に意味があると思う。
なぜなら変数の文法的スコープとともにデストラクタを呼べるから。
事前に言葉が抜けてるよ。 「独自仕様で勝手に拡張可能なら」代入演算子は要らないだろうな。
「過去の資産が不用なら」コピーコンストラクタは要らないだろうな。
C++は、普及のために多目的・標準化・資産継承・効率を選んだ言語だからね。
独自拡張で安易に組み込み型を増やした方が、特定目的のためなら使いやすいし、
特定環境でなら便利に使えるさ。 String型なんて無いからね。 代入したくもなるさ。
Complex型なんて無いからね。 足したくもなるさ。 え、特定OSで特定目的しか考えてないからComplexなんて要らないって？
そうだろうな。普通はFORTRAN資産の置き換えなんて考えないだろうな。
なら、Variant型なんて無いからね。 COMを呼びたくもなるさ。
コピーコンストラクタを呼び出すときに、さらにコピーが発生するので、
永久にコピーコンストラクタが呼び出され続けて暴走する。
従って CFoo::CFoo(CFoo &x) でなければならない。
なお CFoo::CFoo(CFoo *x) はオブジェクトのコピー時には
呼び出されないのであしからず。 ２：代入演算子（operator=）を作るのに必要。
１と同じ理由。 コピーコンストラクタと代入演算子は、基本的に全てのクラスに書いてくれ。
各必要がないときだけ、意図的に省くように。
理由は Effective C++ 参照。 ３：例外をcatchするのに必要。
throw をコピーで catch すると、例外オブジェクトのコピーコンストラクタ内で
さらに例外が発生してややこしくなる。ポインタで catch すると、開放されたゴミメモリをポイントすることになる。
例外ハンドラは参照で catch しないといけない。
こういう話を聞くたびに、delphiを思い出すんだよね。
C++でいう参照が無いのに、別に困っていない言語。
＃delphi以外の多くの言語でもソウだけど。
delphiとかに言わせれば、 1:コピーコンストラクタなんざ要らない。
2:代入演算子なんざ要らない。
1と2の理由は要するに、変数埋めこみObjectを許していないために
変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
食らわずに済むから、です。
3:newで作った例外Objectをcatch部で受けとって始末すればよい。
たしかC++って未だに(笑)例外専用クラスって無いんでしたよね。
＃つーか大元の基本クラスすらないんだっけか
となると、言語レベルで例外Objectの扱いにお約束を与えることも
できないわけで、それが面倒をもたらしている。
C++って、ある一部に拘ってしまったばっかりに、
他の全ての利便性を獲得できなくなってしまった
という風に思える。 1000行だとちゃんと2Mくらい増えるから当てになると思う。
>boolean[] isBold 2000行だったら無条件にboolean isBold[2000]ってするのか？
デフォルトではすべてのセルは同じセルスタイルオブジェクトを共有して
いるからそんなにメモリを食わないのだけど､配列になんかしたら常にメ
モリ食いになっちゃうじゃん。 第一isBoldとかはビットフラグだと思う。
>1と2の理由は要するに、変数埋めこみObjectを許していないために
>変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
デルの事は知らないけど､変数埋め込みがあろうがなかろうが宣言と
ともにnewが呼ばれるなら抱き合わせは発生するんじゃないの？
で、変数の宣言とともにnewが呼ばれることには非常に意味があると思う。
なぜなら変数の文法的スコープとともにデストラクタを呼べるから。
事前に言葉が抜けてるよ。 「独自仕様で勝手に拡張可能なら」代入演算子は要らないだろうな。
「過去の資産が不用なら」コピーコンストラクタは要らないだろうな。
C++は、普及のために多目的・標準化・資産継承・効率を選んだ言語だからね。
独自拡張で安易に組み込み型を増やした方が、特定目的のためなら使いやすいし、
特定環境でなら便利に使えるさ。 String型なんて無いからね。 代入したくもなるさ。
Complex型なんて無いからね。 足したくもなるさ。 え、特定OSで特定目的しか考えてないからComplexなんて要らないって？
そうだろうな。普通はFORTRAN資産の置き換えなんて考えないだろうな。
なら、Variant型なんて無いからね。 COMを呼びたくもなるさ。
CFoo::CFoo(CFoo x) というコピーコンストラクタを定義するとする。
コピーコンストラクタを呼び出すときに、さらにコピーが発生するので、
永久にコピーコンストラクタが呼び出され続けて暴走する。
従って CFoo::CFoo(CFoo &x) でなければならない。
なお CFoo::CFoo(CFoo *x) はオブジェクトのコピー時には
呼び出されないのであしからず。 ２：代入演算子（operator=）を作るのに必要。
１と同じ理由。 コピーコンストラクタと代入演算子は、基本的に全てのクラスに書いてくれ。
各必要がないときだけ、意図的に省くように。
理由は Effective C++ 参照。 ３：例外をcatchするのに必要。
throw をコピーで catch すると、例外オブジェクトのコピーコンストラクタ内で
さらに例外が発生してややこしくなる。ポインタで catch すると、開放されたゴミメモリをポイントすることになる。
例外ハンドラは参照で catch しないといけない。
こういう話を聞くたびに、delphiを思い出すんだよね。
C++でいう参照が無いのに、別に困っていない言語。
＃delphi以外の多くの言語でもソウだけど。
delphiとかに言わせれば、 1:コピーコンストラクタなんざ要らない。
2:代入演算子なんざ要らない。
1と2の理由は要するに、変数埋めこみObjectを許していないために
変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
食らわずに済むから、です。
3:newで作った例外Objectをcatch部で受けとって始末すればよい。
たしかC++って未だに(笑)例外専用クラスって無いんでしたよね。
＃つーか大元の基本クラスすらないんだっけか
となると、言語レベルで例外Objectの扱いにお約束を与えることも
できないわけで、それが面倒をもたらしている。
C++って、ある一部に拘ってしまったばっかりに、
他の全ての利便性を獲得できなくなってしまった
という風に思える。 1000行だとちゃんと2Mくらい増えるから当てになると思う。
>boolean[] isBold 2000行だったら無条件にboolean isBold[2000]ってするのか？
デフォルトではすべてのセルは同じセルスタイルオブジェクトを共有して
いるからそんなにメモリを食わないのだけど､配列になんかしたら常にメ
モリ食いになっちゃうじゃん。 第一isBoldとかはビットフラグだと思う。
>1と2の理由は要するに、変数埋めこみObjectを許していないために
>変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
デルの事は知らないけど､変数埋め込みがあろうがなかろうが宣言と
ともにnewが呼ばれるなら抱き合わせは発生するんじゃないの？
で、変数の宣言とともにnewが呼ばれることには非常に意味があると思う。
なぜなら変数の文法的スコープとともにデストラクタを呼べるから。
事前に言葉が抜けてるよ。 「独自仕様で勝手に拡張可能なら」代入演算子は要らないだろうな。
「過去の資産が不用なら」コピーコンストラクタは要らないだろうな。
C++は、普及のために多目的・標準化・資産継承・効率を選んだ言語だからね。
独自拡張で安易に組み込み型を増やした方が、特定目的のためなら使いやすいし、
特定環境でなら便利に使えるさ。 String型なんて無いからね。 代入したくもなるさ。
Complex型なんて無いからね。 足したくもなるさ。 え、特定OSで特定目的しか考えてないからComplexなんて要らないって？
そうだろうな。普通はFORTRAN資産の置き換えなんて考えないだろうな。
なら、Variant型なんて無いからね。 COMを呼びたくもなるさ。
コピーコンストラクタを呼び出すときに、さらにコピーが発生するので、
永久にコピーコンストラクタが呼び出され続けて暴走する。
従って CFoo::CFoo(CFoo &x) でなければならない。
なお CFoo::CFoo(CFoo *x) はオブジェクトのコピー時には
呼び出されないのであしからず。 ２：代入演算子（operator=）を作るのに必要。
１と同じ理由。 コピーコンストラクタと代入演算子は、基本的に全てのクラスに書いてくれ。
各必要がないときだけ、意図的に省くように。
理由は Effective C++ 参照。 ３：例外をcatchするのに必要。
throw をコピーで catch すると、例外オブジェクトのコピーコンストラクタ内で
さらに例外が発生してややこしくなる。ポインタで catch すると、開放されたゴミメモリをポイントすることになる。
例外ハンドラは参照で catch しないといけない。
こういう話を聞くたびに、delphiを思い出すんだよね。
C++でいう参照が無いのに、別に困っていない言語。
＃delphi以外の多くの言語でもソウだけど。
delphiとかに言わせれば、 1:コピーコンストラクタなんざ要らない。
2:代入演算子なんざ要らない。
1と2の理由は要するに、変数埋めこみObjectを許していないために
変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
食らわずに済むから、です。
3:newで作った例外Objectをcatch部で受けとって始末すればよい。
たしかC++って未だに(笑)例外専用クラスって無いんでしたよね。
＃つーか大元の基本クラスすらないんだっけか
となると、言語レベルで例外Objectの扱いにお約束を与えることも
できないわけで、それが面倒をもたらしている。
C++って、ある一部に拘ってしまったばっかりに、
他の全ての利便性を獲得できなくなってしまった
という風に思える。 1000行だとちゃんと2Mくらい増えるから当てになると思う。
>boolean[] isBold 2000行だったら無条件にboolean isBold[2000]ってするのか？
デフォルトではすべてのセルは同じセルスタイルオブジェクトを共有して
いるからそんなにメモリを食わないのだけど､配列になんかしたら常にメ
モリ食いになっちゃうじゃん。 第一isBoldとかはビットフラグだと思う。
>1と2の理由は要するに、変数埋めこみObjectを許していないために
>変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
デルの事は知らないけど､変数埋め込みがあろうがなかろうが宣言と
ともにnewが呼ばれるなら抱き合わせは発生するんじゃないの？
で、変数の宣言とともにnewが呼ばれることには非常に意味があると思う。
なぜなら変数の文法的スコープとともにデストラクタを呼べるから。
事前に言葉が抜けてるよ。 「独自仕様で勝手に拡張可能なら」代入演算子は要らないだろうな。
「過去の資産が不用なら」コピーコンストラクタは要らないだろうな。
C++は、普及のために多目的・標準化・資産継承・効率を選んだ言語だからね。
独自拡張で安易に組み込み型を増やした方が、特定目的のためなら使いやすいし、
特定環境でなら便利に使えるさ。 String型なんて無いからね。 代入したくもなるさ。
Complex型なんて無いからね。 足したくもなるさ。 え、特定OSで特定目的しか考えてないからComplexなんて要らないって？
そうだろうな。普通はFORTRAN資産の置き換えなんて考えないだろうな。
なら、Variant型なんて無いからね。 COMを呼びたくもなるさ。
25 ：名無しさんの初恋：2001/07/15(日) 22:14
ま＞１は正直者だよね。
CFoo::CFoo(CFoo x) というコピーコンストラクタを定義するとする。
コピーコンストラクタを呼び出すときに、さらにコピーが発生するので、
永久にコピーコンストラクタが呼び出され続けて暴走する。
従って CFoo::CFoo(CFoo &x) でなければならない。
なお CFoo::CFoo(CFoo *x) はオブジェクトのコピー時には
呼び出されないのであしからず。 ２：代入演算子（operator=）を作るのに必要。
１と同じ理由。 コピーコンストラクタと代入演算子は、基本的に全てのクラスに書いてくれ。
各必要がないときだけ、意図的に省くように。
理由は Effective C++ 参照。 ３：例外をcatchするのに必要。
throw をコピーで catch すると、例外オブジェクトのコピーコンストラクタ内で
さらに例外が発生してややこしくなる。ポインタで catch すると、開放されたゴミメモリをポイントすることになる。
例外ハンドラは参照で catch しないといけない。
こういう話を聞くたびに、delphiを思い出すんだよね。
C++でいう参照が無いのに、別に困っていない言語。
＃delphi以外の多くの言語でもソウだけど。
delphiとかに言わせれば、 1:コピーコンストラクタなんざ要らない。
2:代入演算子なんざ要らない。
1と2の理由は要するに、変数埋めこみObjectを許していないために
変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
食らわずに済むから、です。
3:newで作った例外Objectをcatch部で受けとって始末すればよい。
たしかC++って未だに(笑)例外専用クラスって無いんでしたよね。
＃つーか大元の基本クラスすらないんだっけか
となると、言語レベルで例外Objectの扱いにお約束を与えることも
できないわけで、それが面倒をもたらしている。
C++って、ある一部に拘ってしまったばっかりに、
他の全ての利便性を獲得できなくなってしまった
という風に思える。 1000行だとちゃんと2Mくらい増えるから当てになると思う。
>boolean[] isBold 2000行だったら無条件にboolean isBold[2000]ってするのか？
デフォルトではすべてのセルは同じセルスタイルオブジェクトを共有して
いるからそんなにメモリを食わないのだけど､配列になんかしたら常にメ
モリ食いになっちゃうじゃん。 第一isBoldとかはビットフラグだと思う。
>1と2の理由は要するに、変数埋めこみObjectを許していないために
>変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
デルの事は知らないけど､変数埋め込みがあろうがなかろうが宣言と
ともにnewが呼ばれるなら抱き合わせは発生するんじゃないの？
で、変数の宣言とともにnewが呼ばれることには非常に意味があると思う。
なぜなら変数の文法的スコープとともにデストラクタを呼べるから。
事前に言葉が抜けてるよ。 「独自仕様で勝手に拡張可能なら」代入演算子は要らないだろうな。
「過去の資産が不用なら」コピーコンストラクタは要らないだろうな。
C++は、普及のために多目的・標準化・資産継承・効率を選んだ言語だからね。
独自拡張で安易に組み込み型を増やした方が、特定目的のためなら使いやすいし、
特定環境でなら便利に使えるさ。 String型なんて無いからね。 代入したくもなるさ。
Complex型なんて無いからね。 足したくもなるさ。 え、特定OSで特定目的しか考えてないからComplexなんて要らないって？
そうだろうな。普通はFORTRAN資産の置き換えなんて考えないだろうな。
なら、Variant型なんて無いからね。 COMを呼びたくもなるさ。
コピーコンストラクタを呼び出すときに、さらにコピーが発生するので、
永久にコピーコンストラクタが呼び出され続けて暴走する。
従って CFoo::CFoo(CFoo &x) でなければならない。
なお CFoo::CFoo(CFoo *x) はオブジェクトのコピー時には
呼び出されないのであしからず。 ２：代入演算子（operator=）を作るのに必要。
１と同じ理由。 コピーコンストラクタと代入演算子は、基本的に全てのクラスに書いてくれ。
各必要がないときだけ、意図的に省くように。
理由は Effective C++ 参照。 ３：例外をcatchするのに必要。
throw をコピーで catch すると、例外オブジェクトのコピーコンストラクタ内で
さらに例外が発生してややこしくなる。ポインタで catch すると、開放されたゴミメモリをポイントすることになる。
例外ハンドラは参照で catch しないといけない。
こういう話を聞くたびに、delphiを思い出すんだよね。
C++でいう参照が無いのに、別に困っていない言語。
＃delphi以外の多くの言語でもソウだけど。
delphiとかに言わせれば、 1:コピーコンストラクタなんざ要らない。
2:代入演算子なんざ要らない。
1と2の理由は要するに、変数埋めこみObjectを許していないために
変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
食らわずに済むから、です。
3:newで作った例外Objectをcatch部で受けとって始末すればよい。
たしかC++って未だに(笑)例外専用クラスって無いんでしたよね。
＃つーか大元の基本クラスすらないんだっけか
となると、言語レベルで例外Objectの扱いにお約束を与えることも
できないわけで、それが面倒をもたらしている。
C++って、ある一部に拘ってしまったばっかりに、
他の全ての利便性を獲得できなくなってしまった
という風に思える。 1000行だとちゃんと2Mくらい増えるから当てになると思う。
>boolean[] isBold 2000行だったら無条件にboolean isBold[2000]ってするのか？
デフォルトではすべてのセルは同じセルスタイルオブジェクトを共有して
いるからそんなにメモリを食わないのだけど､配列になんかしたら常にメ
モリ食いになっちゃうじゃん。 第一isBoldとかはビットフラグだと思う。
>1と2の理由は要するに、変数埋めこみObjectを許していないために
>変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
デルの事は知らないけど､変数埋め込みがあろうがなかろうが宣言と
ともにnewが呼ばれるなら抱き合わせは発生するんじゃないの？
で、変数の宣言とともにnewが呼ばれることには非常に意味があると思う。
なぜなら変数の文法的スコープとともにデストラクタを呼べるから。
事前に言葉が抜けてるよ。 「独自仕様で勝手に拡張可能なら」代入演算子は要らないだろうな。
「過去の資産が不用なら」コピーコンストラクタは要らないだろうな。
C++は、普及のために多目的・標準化・資産継承・効率を選んだ言語だからね。
独自拡張で安易に組み込み型を増やした方が、特定目的のためなら使いやすいし、
特定環境でなら便利に使えるさ。 String型なんて無いからね。 代入したくもなるさ。
Complex型なんて無いからね。 足したくもなるさ。 え、特定OSで特定目的しか考えてないからComplexなんて要らないって？
そうだろうな。普通はFORTRAN資産の置き換えなんて考えないだろうな。
なら、Variant型なんて無いからね。 COMを呼びたくもなるさ。
27 ：名無しさんの初恋：2001/07/15(日) 22:15
──────-
／ ( ( ( ( ) ) )
| ／￣￣＼＿／￣。
| | 丿 0|
| | | ∧ ∧ ∧ ∧ ∧ ∧ ∧ ∧ ∧ ∧ ∧ ∧
| | ━━ ━━| ＜ ＞
(6|| ( ●) ( ●)| ＜ 2chとか関係ないわホンマによォ ＞
| | ─' __|`- / ＜ 男としてむかつくわァ!!!!! ＞
| | ／ ＼ / ＜ ＞
ヽ ／∠三l / ∨ ∨ ∨ ∨ ∨ ∨ ∨ ∨ ∨ ∨ ∨ ∨
ヽ＿ ー ﾉ
CFoo::CFoo(CFoo x) というコピーコンストラクタを定義するとする。
コピーコンストラクタを呼び出すときに、さらにコピーが発生するので、
永久にコピーコンストラクタが呼び出され続けて暴走する。
従って CFoo::CFoo(CFoo &x) でなければならない。
なお CFoo::CFoo(CFoo *x) はオブジェクトのコピー時には
呼び出されないのであしからず。 ２：代入演算子（operator=）を作るのに必要。
１と同じ理由。 コピーコンストラクタと代入演算子は、基本的に全てのクラスに書いてくれ。
各必要がないときだけ、意図的に省くように。
理由は Effective C++ 参照。 ３：例外をcatchするのに必要。
throw をコピーで catch すると、例外オブジェクトのコピーコンストラクタ内で
さらに例外が発生してややこしくなる。ポインタで catch すると、開放されたゴミメモリをポイントすることになる。
例外ハンドラは参照で catch しないといけない。
こういう話を聞くたびに、delphiを思い出すんだよね。
C++でいう参照が無いのに、別に困っていない言語。
＃delphi以外の多くの言語でもソウだけど。
delphiとかに言わせれば、 1:コピーコンストラクタなんざ要らない。
2:代入演算子なんざ要らない。
1と2の理由は要するに、変数埋めこみObjectを許していないために
変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
食らわずに済むから、です。
3:newで作った例外Objectをcatch部で受けとって始末すればよい。
たしかC++って未だに(笑)例外専用クラスって無いんでしたよね。
＃つーか大元の基本クラスすらないんだっけか
となると、言語レベルで例外Objectの扱いにお約束を与えることも
できないわけで、それが面倒をもたらしている。
C++って、ある一部に拘ってしまったばっかりに、
他の全ての利便性を獲得できなくなってしまった
という風に思える。 1000行だとちゃんと2Mくらい増えるから当てになると思う。
>boolean[] isBold 2000行だったら無条件にboolean isBold[2000]ってするのか？
デフォルトではすべてのセルは同じセルスタイルオブジェクトを共有して
いるからそんなにメモリを食わないのだけど､配列になんかしたら常にメ
モリ食いになっちゃうじゃん。 第一isBoldとかはビットフラグだと思う。
>1と2の理由は要するに、変数埋めこみObjectを許していないために
>変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
デルの事は知らないけど､変数埋め込みがあろうがなかろうが宣言と
ともにnewが呼ばれるなら抱き合わせは発生するんじゃないの？
で、変数の宣言とともにnewが呼ばれることには非常に意味があると思う。
なぜなら変数の文法的スコープとともにデストラクタを呼べるから。
事前に言葉が抜けてるよ。 「独自仕様で勝手に拡張可能なら」代入演算子は要らないだろうな。
「過去の資産が不用なら」コピーコンストラクタは要らないだろうな。
C++は、普及のために多目的・標準化・資産継承・効率を選んだ言語だからね。
独自拡張で安易に組み込み型を増やした方が、特定目的のためなら使いやすいし、
特定環境でなら便利に使えるさ。 String型なんて無いからね。 代入したくもなるさ。
Complex型なんて無いからね。 足したくもなるさ。 え、特定OSで特定目的しか考えてないからComplexなんて要らないって？
そうだろうな。普通はFORTRAN資産の置き換えなんて考えないだろうな。
なら、Variant型なんて無いからね。 COMを呼びたくもなるさ。
コピーコンストラクタを呼び出すときに、さらにコピーが発生するので、
永久にコピーコンストラクタが呼び出され続けて暴走する。
従って CFoo::CFoo(CFoo &x) でなければならない。
なお CFoo::CFoo(CFoo *x) はオブジェクトのコピー時には
呼び出されないのであしからず。 ２：代入演算子（operator=）を作るのに必要。
１と同じ理由。 コピーコンストラクタと代入演算子は、基本的に全てのクラスに書いてくれ。
各必要がないときだけ、意図的に省くように。
理由は Effective C++ 参照。 ３：例外をcatchするのに必要。
throw をコピーで catch すると、例外オブジェクトのコピーコンストラクタ内で
さらに例外が発生してややこしくなる。ポインタで catch すると、開放されたゴミメモリをポイントすることになる。
例外ハンドラは参照で catch しないといけない。
こういう話を聞くたびに、delphiを思い出すんだよね。
C++でいう参照が無いのに、別に困っていない言語。
＃delphi以外の多くの言語でもソウだけど。
delphiとかに言わせれば、 1:コピーコンストラクタなんざ要らない。
2:代入演算子なんざ要らない。
1と2の理由は要するに、変数埋めこみObjectを許していないために
変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
食らわずに済むから、です。
3:newで作った例外Objectをcatch部で受けとって始末すればよい。
たしかC++って未だに(笑)例外専用クラスって無いんでしたよね。
＃つーか大元の基本クラスすらないんだっけか
となると、言語レベルで例外Objectの扱いにお約束を与えることも
できないわけで、それが面倒をもたらしている。
C++って、ある一部に拘ってしまったばっかりに、
他の全ての利便性を獲得できなくなってしまった
という風に思える。 1000行だとちゃんと2Mくらい増えるから当てになると思う。
>boolean[] isBold 2000行だったら無条件にboolean isBold[2000]ってするのか？
デフォルトではすべてのセルは同じセルスタイルオブジェクトを共有して
いるからそんなにメモリを食わないのだけど､配列になんかしたら常にメ
モリ食いになっちゃうじゃん。 第一isBoldとかはビットフラグだと思う。
>1と2の理由は要するに、変数埋めこみObjectを許していないために
>変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
デルの事は知らないけど､変数埋め込みがあろうがなかろうが宣言と
ともにnewが呼ばれるなら抱き合わせは発生するんじゃないの？
で、変数の宣言とともにnewが呼ばれることには非常に意味があると思う。
なぜなら変数の文法的スコープとともにデストラクタを呼べるから。
事前に言葉が抜けてるよ。 「独自仕様で勝手に拡張可能なら」代入演算子は要らないだろうな。
「過去の資産が不用なら」コピーコンストラクタは要らないだろうな。
C++は、普及のために多目的・標準化・資産継承・効率を選んだ言語だからね。
独自拡張で安易に組み込み型を増やした方が、特定目的のためなら使いやすいし、
特定環境でなら便利に使えるさ。 String型なんて無いからね。 代入したくもなるさ。
Complex型なんて無いからね。 足したくもなるさ。 え、特定OSで特定目的しか考えてないからComplexなんて要らないって？
そうだろうな。普通はFORTRAN資産の置き換えなんて考えないだろうな。
なら、Variant型なんて無いからね。 COMを呼びたくもなるさ。
29 ：名無しさんの初恋：2001/07/15(日) 22:32
age
CFoo::CFoo(CFoo x) というコピーコンストラクタを定義するとする。
コピーコンストラクタを呼び出すときに、さらにコピーが発生するので、
永久にコピーコンストラクタが呼び出され続けて暴走する。
従って CFoo::CFoo(CFoo &x) でなければならない。
なお CFoo::CFoo(CFoo *x) はオブジェクトのコピー時には
呼び出されないのであしからず。 ２：代入演算子（operator=）を作るのに必要。
１と同じ理由。 コピーコンストラクタと代入演算子は、基本的に全てのクラスに書いてくれ。
各必要がないときだけ、意図的に省くように。
理由は Effective C++ 参照。 ３：例外をcatchするのに必要。
throw をコピーで catch すると、例外オブジェクトのコピーコンストラクタ内で
さらに例外が発生してややこしくなる。ポインタで catch すると、開放されたゴミメモリをポイントすることになる。
例外ハンドラは参照で catch しないといけない。
こういう話を聞くたびに、delphiを思い出すんだよね。
C++でいう参照が無いのに、別に困っていない言語。
＃delphi以外の多くの言語でもソウだけど。
delphiとかに言わせれば、 1:コピーコンストラクタなんざ要らない。
2:代入演算子なんざ要らない。
1と2の理由は要するに、変数埋めこみObjectを許していないために
変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
食らわずに済むから、です。
3:newで作った例外Objectをcatch部で受けとって始末すればよい。
たしかC++って未だに(笑)例外専用クラスって無いんでしたよね。
＃つーか大元の基本クラスすらないんだっけか
となると、言語レベルで例外Objectの扱いにお約束を与えることも
できないわけで、それが面倒をもたらしている。
C++って、ある一部に拘ってしまったばっかりに、
他の全ての利便性を獲得できなくなってしまった
という風に思える。 1000行だとちゃんと2Mくらい増えるから当てになると思う。
>boolean[] isBold 2000行だったら無条件にboolean isBold[2000]ってするのか？
デフォルトではすべてのセルは同じセルスタイルオブジェクトを共有して
いるからそんなにメモリを食わないのだけど､配列になんかしたら常にメ
モリ食いになっちゃうじゃん。 第一isBoldとかはビットフラグだと思う。
>1と2の理由は要するに、変数埋めこみObjectを許していないために
>変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
デルの事は知らないけど､変数埋め込みがあろうがなかろうが宣言と
ともにnewが呼ばれるなら抱き合わせは発生するんじゃないの？
で、変数の宣言とともにnewが呼ばれることには非常に意味があると思う。
なぜなら変数の文法的スコープとともにデストラクタを呼べるから。
事前に言葉が抜けてるよ。 「独自仕様で勝手に拡張可能なら」代入演算子は要らないだろうな。
「過去の資産が不用なら」コピーコンストラクタは要らないだろうな。
C++は、普及のために多目的・標準化・資産継承・効率を選んだ言語だからね。
独自拡張で安易に組み込み型を増やした方が、特定目的のためなら使いやすいし、
特定環境でなら便利に使えるさ。 String型なんて無いからね。 代入したくもなるさ。
Complex型なんて無いからね。 足したくもなるさ。 え、特定OSで特定目的しか考えてないからComplexなんて要らないって？
そうだろうな。普通はFORTRAN資産の置き換えなんて考えないだろうな。
なら、Variant型なんて無いからね。 COMを呼びたくもなるさ。
コピーコンストラクタを呼び出すときに、さらにコピーが発生するので、
永久にコピーコンストラクタが呼び出され続けて暴走する。
従って CFoo::CFoo(CFoo &x) でなければならない。
なお CFoo::CFoo(CFoo *x) はオブジェクトのコピー時には
呼び出されないのであしからず。 ２：代入演算子（operator=）を作るのに必要。
１と同じ理由。 コピーコンストラクタと代入演算子は、基本的に全てのクラスに書いてくれ。
各必要がないときだけ、意図的に省くように。
理由は Effective C++ 参照。 ３：例外をcatchするのに必要。
throw をコピーで catch すると、例外オブジェクトのコピーコンストラクタ内で
さらに例外が発生してややこしくなる。ポインタで catch すると、開放されたゴミメモリをポイントすることになる。
例外ハンドラは参照で catch しないといけない。
こういう話を聞くたびに、delphiを思い出すんだよね。
C++でいう参照が無いのに、別に困っていない言語。
＃delphi以外の多くの言語でもソウだけど。
delphiとかに言わせれば、 1:コピーコンストラクタなんざ要らない。
2:代入演算子なんざ要らない。
1と2の理由は要するに、変数埋めこみObjectを許していないために
変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
食らわずに済むから、です。
3:newで作った例外Objectをcatch部で受けとって始末すればよい。
たしかC++って未だに(笑)例外専用クラスって無いんでしたよね。
＃つーか大元の基本クラスすらないんだっけか
となると、言語レベルで例外Objectの扱いにお約束を与えることも
できないわけで、それが面倒をもたらしている。
C++って、ある一部に拘ってしまったばっかりに、
他の全ての利便性を獲得できなくなってしまった
という風に思える。 1000行だとちゃんと2Mくらい増えるから当てになると思う。
>boolean[] isBold 2000行だったら無条件にboolean isBold[2000]ってするのか？
デフォルトではすべてのセルは同じセルスタイルオブジェクトを共有して
いるからそんなにメモリを食わないのだけど､配列になんかしたら常にメ
モリ食いになっちゃうじゃん。 第一isBoldとかはビットフラグだと思う。
>1と2の理由は要するに、変数埋めこみObjectを許していないために
>変数の宣言と「同時に」Objectが作られるという抱き合わせ(笑)を
デルの事は知らないけど､変数埋め込みがあろうがなかろうが宣言と
ともにnewが呼ばれるなら抱き合わせは発生するんじゃないの？
で、変数の宣言とともにnewが呼ばれることには非常に意味があると思う。
なぜなら変数の文法的スコープとともにデストラクタを呼べるから。
事前に言葉が抜けてるよ。 「独自仕様で勝手に拡張可能なら」代入演算子は要らないだろうな。
「過去の資産が不用なら」コピーコンストラクタは要らないだろうな。
C++は、普及のために多目的・標準化・資産継承・効率を選んだ言語だからね。
独自拡張で安易に組み込み型を増やした方が、特定目的のためなら使いやすいし、
特定環境でなら便利に使えるさ。 String型なんて無いからね。 代入したくもなるさ。
Complex型なんて無いからね。 足したくもなるさ。 え、特定OSで特定目的しか考えてないからComplexなんて要らないって？
そうだろうな。普通はFORTRAN資産の置き換えなんて考えないだろうな。
なら、Variant型なんて無いからね。 COMを呼びたくもなるさ。