C++相談室 part11

このエントリーをはてなブックマークに追加
1 ：v(^・^)v：
文法が汚くてもいいから、懐の広い言語を望むあなた。そんな
あなたにぴったりの言語、C++。
(´∀`).｡o(関連URLは>>2-5の辺り)
2 ：デフォルトの名無しさん：02/09/18 19:44
松本コンチータ
3 ：v(^・^)v：02/09/18 19:50
C++ Final Draft International Standard
http://www.kuzbass.ru/docs/isocpp/

Boost
http://www.boost.org/
STLport
http://www.stlport.org/
Loki
http://www.moderncppdesign.com/
Loki for VC7(LokiPort)
http://www.geocities.com/rani_sharoni/LokiPort.html
4 ：v(^・^)v：02/09/18 19:52
過去ログ
Part1
http://piza.2ch.net/tech/kako/980/980175292.html
Part2
http://pc.2ch.net/tech/kako/996/996640937.html
Part3
http://pc.2ch.net/tech/kako/1003/10038/1003832761.html
Part4
http://pc.2ch.net/tech/kako/1009/10090/1009071535.html
Part5
http://pc.2ch.net/tech/kako/1014/10142/1014217496.html
Part6
http://pc.2ch.net/tech/kako/1018/10184/1018454705.html
Part7
http://pc.2ch.net/test/read.cgi/tech/1021787032/
Part8
http://pc3.2ch.net/test/read.cgi/tech/1025010364/
Part9
http://pc3.2ch.net/test/read.cgi/tech/1027347982/
part10
http://pc3.2ch.net/test/read.cgi/tech/1029315669/
5 ：v(^・^)v：02/09/18 19:52
ISO/IEC 14882 International Standard
http://piza2.2ch.net/test/read.cgi?bbs=tech&key=969458279
新C++Builder相談室(C++Builder相談室 Part2)
http://pc.2ch.net/test/read.cgi/tech/997074601/
C Builder相談室 Part3
http://pc3.2ch.net/test/read.cgi/tech/1016065855/
6 ：デフォルトの名無しさん：02/09/18 20:05
C++にはクラスとかSTLとか色々ありますけど、最低限どれを覚えれば
C++を使いこなしているといえますか？
あと、C++を覚えただけじゃプログラムは作れないと聞きましたが、
他にどんな事を知る必要がありますか？
数学関係とかの知識なら大丈夫だと思います。
7 ：デフォルトの名無しさん：02/09/18 20:16
>>1
ｷﾞﾘｷﾞﾘｽﾚ勃ﾃ乙ー
8 ：デフォルトの名無しさん：02/09/18 20:18
>6
//が使えれば大丈夫。
9 ：デフォルトの名無しさん：02/09/18 20:19
>374 名前：デフォルトの名無しさん sage 投稿日：2002/09/18(水) 03:03
>オブジェクトを直接宣言する場合と、
>　CTest oObj(Hoge);
>一旦ポインタの形で宣言しnewする場合は、
>　CTest* pObj;
>　pObj = new CTest(Hoge);
>どのように使い分ければいいのでしょうか？
>375 名前：デフォルトの名無しさん sage 投稿日：2002/09/18(水) 03:10
>スコープを外れても残したい時はnew

前スレで↑を見て｢なるほど｣と納得していたのですが、
newするしたらdeleteしなければならない、となぜかわからずでも覚えてるの
ですが、この場合スコープ抜けちゃうとdeleteできませんよね？
本にはnet<->deleteとセットで書かれているので
理解できません。どうしてでしょうか？

10 ：デフォルトの名無しさん：02/09/18 20:22
>>9
ｺﾝｽﾄﾗｸﾀでnewしてﾃﾞｽﾄﾗｸﾀでdeleteするとか。＜スコープ抜けてからdelete

>>6
ちょとずれるが，C++ﾌﾟﾛｸﾞﾗﾐﾝｸﾞとSTLﾌﾟﾛｸﾞﾗﾐﾝｸﾞは何となく毛色が違うと思う。
自称C++ﾌﾟﾛｸﾞﾗﾏがListｸﾗｽとか作っててｱﾌｫかとｵﾓﾀ。
11 ：10：02/09/18 20:24
切れた。

だからSTLﾊﾞﾘﾊﾞﾘの人はSTLﾌﾟﾛｸﾞﾗﾏと名乗って欲しい。

で，「C++を使いこなしている」とは
・>>8
・クラス
・iostream
ぐらいでよいのでは？
12 ：10：02/09/18 20:25
・new delete
・例外
も。
13 ：デフォルトの名無しさん：02/09/18 20:26
>>10
ということは変数をクラスに持たせるということですよね。
そうすると、クラスに
CTest oObj(Hoge);
で宣言するのと
CTest* pObj;
pObj = new CTest(Hoge);
で宣言しnewするのとはどのように使い分ければいいのでしょうか？

と>>9の代わりに質問してみるテスト
14 ：10：02/09/18 20:28
>>13
ﾎﾟｲﾝﾀ宣言しておくのは多態性を実現したい時とか，
生成を遅らせたい時とか場合によっては生成しなくてもいい時とか。
15 ：9：02/09/18 20:28
>10
えっとさっきの例で話すと、
CTest *pObj(Hoge)；
pObj=new CTest(Hoge)；
って領域確報しちゃうとスコープ抜けたら
領域は確保されたままですが、*pObjはもう使えないですよね？
スコープ内でdelete pObjとするならわかるのですが、
この例だとスコープ抜けたらdeleteできないんじゃないんでしょうか？
deleteする必要はあるんですよね？
16 ：10：02/09/18 20:30
>>15
func()
{
　　CTest* pObj;
　　pObj = new CTest(Hoge);
　　return;
}
だと思ってるの？
たぶん前スレ375はそういう風には捕らえてないと思われ。
17 ：9：02/09/18 20:39
>16
元質問者の方のオリジナルのコードは
VCでMDIを作成する時に自動作成される↓なんですが、
CMultiDocTemplate* pDocTemplate;
pDocTemplate = new CMultiDocTemplate(IDR_MDITYPE,
RUNTIME_CLASS(CMDIDoc),
RUNTIME_CLASS(CChildFrame),
RUNTIME_CLASS(CMDIView));
この例だと>16に書かれている形式と同じですよね？
もちろんこの後deleteはありませんでした。
スコープ抜けたらdelete pDocTemplateはできないでしょうし、
なぜdeleteしなくていいのか、というのが悩みの種です。
18 ：デフォルトの名無しさん：02/09/18 20:39
>>16
正しくは？
19 ：10：02/09/18 20:59
>>17
deleteしてないんだったらしてないんじゃない？

>>18
CTest* pObj; // どこか（グローバルとかクラス面罵とか）
---------------------
pObj = new CTest(Hoge); // どこか

だと思ったんだと思う…。
20 ：デフォルトの名無しさん：02/09/18 21:01
>>19
deleteしなくてメモリリークは起きないの？
21 ：10：02/09/18 21:10
>>20
起きるよ？
22 ：デフォルトの名無しさん：02/09/18 21:19
pDocTemplateをその後一切さわってないの？
どこかに登録とかしてるはずなんだが。

もし、そうでないならリークしてるかnewをオーバーライドしてる
23 ：9：02/09/18 21:20
＞19
じゃなぜ>17のコードはdeleteしてないんでしょうか？
>21を見るとnew したら deleteしなきゃいけないんですよね？
少なくとも>17のコードはreturn TRUE；までの間に
delete pDocTemplate；
という文はありませんでした。
deleteしなければメモリリークが発生するというなら
どこでdeleteしてるのでしょうか？
話しがVCに流れてますがVCスレへ戻った方がいいでしょうか？？
24 ：デフォルトの名無しさん：02/09/18 21:21
ちなみに、この場合無限に生成される物じゃないから
リークしても別に構わない程度の物だとは思うが。
25 ：10：02/09/18 21:22
>>17
「元質問者」さんに聞いて見るのが吉なのでは？
26 ：10：02/09/18 21:24
>>23
何かかたくなに「deleteしなきゃいけない」って思いこんでるみたいだけど，
deleteしないコードは動かないってわけじゃないですよ。
実装がちゃんとしてる環境ではdeleteしなくてもプログラム終了時には解放されますよ。
（細かく突っ込まないでね。fjじゃないんだからさ）

あとC++の話題だと思うんで大丈夫だと思います。
27 ：9：02/09/18 21:26
＞22
確かに基底クラス(CObject)でオーバーライドされてました。
void* CAge::operator new(size_t nSize)
{
return malloc(nSize);
}
こんな感じです。
私は｢malloc｣のことよくわかっていないので
これ以上追求できないようです。
基本的にnew したら　deleteしなければならないのは確か。
ということはわかりました。
またおいおい覚えていきたいと思います。
ありがとうございました。
28 ：デフォルトの名無しさん：02/09/18 21:27
>>26
ちゃんとデストラクタは呼ばれますか？
29 ：9：02/09/18 21:28
>27で結論付けたはずが
>26を読ませてもらったところ間違いだと早速気付きました。
newすればかならずdeleteしなくてはならないというわけではない。
に訂正いたします。
実際私のレベルではこれ以上ついていけないっぽいので
例外を除いてdeleteは必ずしろっ、
と覚えておきますｗ
ありがとうございました。
30 ：10：02/09/18 21:29
>>28
呼ばれませんよ？
31 ：デフォルトの名無しさん：02/09/18 21:30
>>27
mallocはメモリを確保する命令。確保した後はfreeで解放しなければならない。
32 ：10：02/09/18 21:32
>>29
いや，deleteはしなきゃいかん。
が，deleteしてないからといって「動かない」というわけではない。
しかし，「動く」と言っても，「完全に設計どおりに動く」というわけではない。（>>28が指摘してるけど）
33 ：デフォルトの名無しさん：02/09/18 21:33
>>30
deleteしない終了時に解放されるのはメモリだけということですか。
deleteして終了するのとdeleteしないで終了するので違いがあるということですね。
34 ：10：02/09/18 21:33
最後の行訂正します。

しかし，「動く」と言っても，「完全に設計どおりに動く」というわけではない。（>>28が指摘してるけど）
↓
しかし，「動く」と言っても，「完全に設計どおりに動く」とは限らない。
「設計通りに動くかもしれないし動かないかもしれない」（>>28が指摘してるけど）
35 ：10：02/09/18 21:34
>>33
そういうことです。メモリ以外の資源はリークする可能性があります（使っている場合）
36 ：デフォルトの名無しさん：02/09/18 21:42
deleteしたときしなかったとき…の動作については10氏の通りだが、

>>23
特に CMultiDocTemplate に関して言うなら、こいつはコンストラクタの中で自分を
CDocManagerというクラスのオブジェクトに自分を登録しておいて、
　// pDocTemplate = new CMultiDocTemplate(IDR_MDITYPE, ... );
　// ここの中でDocManagerに登録↑
で、例えばCDocManagerのデストラクタの中からdeleteが呼ばれる
ようになっているのでとりあえず心配は要らん。
37 ：9：02/09/18 21:46
>36
あぁ、なるほど、
全て納得いきました。
そいういう流れだったんですね。
全部納得いってすっきりしました。
ありがとうございました。
感謝。
38 ：デフォルトの名無しさん：02/09/18 21:47
ごちゃごちゃしてきたな。さかのぼって始めらへんのやつ>>15をコピペしてみよう。
答えが出てないみたいだから。

15 ：9 ：02/09/18 20:28
>10
えっとさっきの例で話すと、
CTest *pObj(Hoge)；
pObj=new CTest(Hoge)；
って領域確報しちゃうとスコープ抜けたら
領域は確保されたままですが、*pObjはもう使えないですよね？
スコープ内でdelete pObjとするならわかるのですが、
この例だとスコープ抜けたらdeleteできないんじゃないんでしょうか？
deleteする必要はあるんですよね？
39 ：デフォルトの名無しさん：02/09/18 21:51
>>38
混乱させるな
40 ：10：02/09/18 22:01
>>38->>39
ﾜﾗﾀ
41 ：10：02/09/18 22:02
>>36さん解説ありがとう。ぼくも納得しました。
>>37お疲れ様
42 ：元質問者：02/09/18 22:25
私の質問が続いているみたいだったので顔を出しました。
まず、
>25
これは私が書いたコードではなくVC++というツールが吐く
スケルトンです。

なぜMDIスケルトンがnewを使うかを確認するために、下記にコード変更
staticCMultiDocTemplate oDocTemplate(
IDR_TEST33TYPE,
RUNTIME_CLASS(CTest333Doc),
RUNTIME_CLASS(CChildFrame),
RUNTIME_CLASS(CTest333View));
AddDocTemplate(&oDocTemplate);
ビルドして実行すると、予想に反して何事もなく動作しました。
（アプリ抜けるときに例外発生するけど、もともとnewを想定した>36辺りの処
理の問題だと思われます。あまり重要でないと思う。）

→普通のオブジェクトでいいものを何でnewしてるんだろう？
　→Win9X系のリソース(640KByteの)問題で、ヒープにCMultiDocTemplate
　　のエリアを確保したかったのでは？（子ウインドが何枚開かれるのか分か
　　らないので）
と言うことでリソースメータを起動して、オブジェクトの場合とnewの場合と
で、それぞれ子ウインドを1000枚開いて比較。
→結果、リソース使用量変わらず。

ここまでやって、”なんか知らんがnew使った方がいいんだろう。”
という結論に達しました。また気が向いたら解析することにします。
（今度はこっちがスレ違いに、、、）
43 ：元質問者：02/09/18 22:39
よく考えたらstaticもヒープに取られるんだっけ？
>42 ではリソース問題の確認にならない可能性大。
44 ：デフォルトの名無しさん：02/09/18 23:04
MFC のことはよく分からんが、
>>42
> 普通のオブジェクトでいいものを何でnewしてるんだろう？
その CMultiDocTemplate っつーのをクライアントが動的に生成できる
ようにするためなんでは。

しかし、おれは 36 の説明じゃ訳分からんかったよ。42 の
> AddDocTemplate(&oDocTemplate);
で分かったけど。36 もこのことが言いたかったんだね。

>>43
> よく考えたらstaticもヒープに取られるんだっけ？
んなことはない。
45 ：デフォルトの名無しさん：02/09/18 23:13
>>44
うお、じゃstaticはどこに取られるんだ？急に足下がおぼつかなく
思えてきたYO…。
46 ：デフォルトの名無しさん：02/09/18 23:22
data とか bss とか。
47 ：　：02/09/19 00:20
>>42
CWinAppのメンバ
CDocManager* m_pDocManager;
オブジェクトにＣDocTemplate*渡されてポインタ管理が任されているみたいだね。
それで
CDocManager::~CDocManager()できちんと解放されているようだ。
delete m_pDocManager;
はCWinAppのデストラクタで呼ばれている。

staticにするとアプリ終了時に２重にデストラクタが呼ばれるから例外が呼ばれる
ようだけど。
48 ：デフォルトの名無しさん：02/09/19 03:20
ちょっと話ズレるんですけど、実体で持つ場合とポインタで持つ場合の違いで
クラスAがクラスBをメンバに持ちたい時
実体持ちの場合のクラスAのサイズ＝sizeof(クラスA)+sizeof(クラスB)
ポインタ持ちの場合＝sizeof(クラスA)+sizeof(ポインタ)
となって、実体持ちだとコピーの時にオーバーヘッドが発生
という事であってますか？

更に突っ込んで、実体持ちだとクラスBの実装が変わってサイズも変わったりすると
クラスAに関しても再コンパイルが必要になるけど
ポインタ持ちだとクラスBの再コンパイルだけでいいって事であってますか？
49 ：デフォルトの名無しさん：02/09/19 03:27
全然違う
50 ：デフォルトの名無しさん：02/09/19 09:53
CreateWindowで作ったボタンのフォントを変えたいのですが
CreateFontしてGetDCしてSelectObjectしてみたのですが変わりません
やり方的にはこれでいいんでしょうか？
51 ：デフォルトの名無しさん：02/09/19 09:58
>>50
スレ違い。

Win32API 質問箱 Build5
http://pc3.2ch.net/test/read.cgi/tech/1028580373/
52 ：!=49 だが：02/09/19 10:50
>>48
49> 全然違う、だけじゃアレなんで (w

> 実体持ちの場合のクラスAのサイズ＝sizeof(クラスA)+sizeof(クラスB)
実体持ちの場合のクラスAのサイズ＝sizeof(クラスA) だが?
というツッコミは置いといて、48 の言いたいことは、
実体持ちの場合のクラスAのサイズ＝sizeof(クラスA - クラスBのメンバ) + sizeof(クラスB)
ってことだろうけど、メンバを4バイトとか8バイト境界にアライメント
させてる場合は、違ってくる可能性がある。

> 実体持ちだとコピーの時にオーバーヘッドが発生
ポインタ持ちだとオーバーヘッドが発生しないわけでもない。
クラスAのコピーコンストラクタの作りによる。

> ポインタ持ちだとクラスBの再コンパイルだけでいいって事であってますか？
これは合ってるかな。この場合は、クラスAを定義しているところで
クラス B を定義しているヘッダファイルをインクルードしないようにね。
53 ：52：02/09/19 10:55
まちがえた。
> > ポインタ持ちだとクラスBの再コンパイルだけでいいって事であってますか？
> これは合ってるかな。
合ってない(w
クラス A の定義をインクルードしている、他のファイルは再コンパイルの
必要がない。クラス A の実装ファイルは、(たぶん クラス B を使っているので)
再コンパイルが必要だろう。
54 ：デフォルトの名無しさん：02/09/19 11:01
C++のコンパイル速度はこれ以上速くなりそうもないな。
55 ：52：02/09/19 11:03
再三スマソ。
ようするに、クラス A の実装からクラス B の実装が見えるのなら再コンパイル。
見えないなら不要、ということ。クラス間の依存はできるだけ減らすようにがんがれ。
ちなみにおれは、pimpl パターンがお気に入りだ。
56 ：デフォルトの名無しさん：02/09/19 12:29
>>54
何を基準にして「これ以上」なのか知らんが、書き方に気をつけると、それなりに
は速くなる。インターフェースと実装を分離して、ヘッダファイル間の依存関係を
減らすとかさ。

(あと gcc は遅すぎ)
57 ：デフォルトの名無しさん：02/09/19 13:59
今家(linux)で作ったプログラムを学校(solaris)コンパイルしています。
でも、家では警告だけだった
char* a = NULL;
を
char* a = (char*)NULL;
に直さないと駄目になりました。
なぜでしょうか?また直さないでコンパイル通したいのですが駄目ですか?
58 ：デフォルトの名無しさん：02/09/19 14:08
>>57
C++だから NULLが(void *)0などと定義されているためエラーになったの
だろう。

検索かけてNULLを0にしる。
59 ：デフォルトの名無しさん：02/09/19 14:09
もっと簡単な方法があった。

#undef NULL
const int NULL = 0;
60 ：デフォルトの名無しさん：02/09/19 14:14
>>57
ちょっとstddef.hを覗いてみて欲しい。次のような行が書かれてないか？

#ifndef NULL
# if defined(__cplusplus)
# define NULL 0
# else
# define NULL ((void *)0)
# endif
#endif
61 ：デフォルトの名無しさん：02/09/19 14:16
コンパイル時間って何かに影響すんの？
62 ：デフォルトの名無しさん：02/09/19 14:18
>>58, 59, 60
みんな、がりがとう。自分で
#define NULL((void*) 0)
と定義してたのが不味かったみたいです(w;
63 ：デフォルトの名無しさん：02/09/19 14:55
メンバ関数ポインタを作ろうとしているのですがうまくいきません
下の(a.*pP)()のところでコンパイルエラーになってしまいます
書き方が違うのでしょうかおしえてください

class A{
private:
int a;
public:
void (A::*pP) ();
A(){pP = Print;}
void SetA(int s){a = s;}

};
int main()
{
A a;
a.SetA(100);
(a.*pP)(); //error
return 0;
}
64 ：デフォルトの名無しさん：02/09/19 15:53
>>61
開発効率

とくにバグとりのときに、

1. バグをとる
2. コンパイルする
3. テストする

のサイクルが遅いと嫌。
65 ：デフォルトの名無しさん：02/09/19 15:56
>>61
精神的ストレス
66 ：デフォルトの名無しさん：02/09/19 16:35
>>63
えーと･･･
ネタ？
67 ：デフォルトの名無しさん：02/09/19 16:50
>>63
PrintってAのメンバなのかい？
68 ：63：02/09/19 16:56
すいません
A::Print() がぬけてました
69 ：デフォルトの名無しさん：02/09/19 16:56
>>61
コンパイルに12時間もかかるプロジェクトとかやったやつ、いる？
そんな本読んだよ。
70 ：デフォルトの名無しさん：02/09/19 17:01
大体平均的なコンパイル時間ってどのくらい？ 規模にもよるとは思うが。
71 ：デフォルトの名無しさん：02/09/19 17:02
>>63
もっぺんソースさらせ
72 ：デフォルトの名無しさん：02/09/19 17:04
pPがAのメンバなのだから (a.*(a.pP))(); こうしなければならないんでは。
73 ：デフォルトの名無しさん：02/09/19 17:09
>>70
俺のプロジェクトは大体20秒だな。
74 ：デフォルトの名無しさん：02/09/19 17:23
>>72
それだ！
75 ：デフォルトの名無しさん：02/09/19 17:25
ビルドに1時間かかるプロジェクトってどんなもんよ？
100万行くらい？
76 ：63：02/09/19 17:48
>>72
ああコンパイル出来ました
ありがとうございます。
77 ：デフォルトの名無しさん：02/09/19 18:08
なるほどこのようになるのか。

class A {
private:
int a;
public:
void (A::*pP)() const;
A() { pP = &A::Print; }
void SetA(int s) {a = s;}
void Print() const { std::cout << "a = " << a << std::endl; }
};
int main()
{
A a;
void (A::*pP2)() const;

pP2 = A::Print;
a.SetA(100);
(a.*(a.pP))();
(a.*pP2)();
}
78 ：デフォルトの名無しさん：02/09/19 18:22
>>70
手元のテンプレートライブラリ使いまくりの C++ 20,000 行のコードで、フルビルド
2分30秒。Pentium III-M 800MHz / VC6 / 最適化 速度優先

C++ が危険なのは、注意して書かないとファイル間に依存関係が容易に発生
してしまい、ひとつファイルを書き換えたらフルビルドに近い状態になってしまう
こと。上でも誰かが言ってた pimpl イディオムや、インターフェースと実装の分
離を徹底しないと、規模が大きいプロジェイクトでは破綻するよ。
79 ：デフォルトの名無しさん：02/09/19 18:40
pimplはテンプレートの旨みを２つ消す
・インライン展開
・コードの短縮、簡略化
80 ：デフォルトの名無しさん：02/09/19 18:48
インターフェースと実装の分離でよい本ある？
具体例のあるやつ。
81 ：デフォルトの名無しさん：02/09/19 19:42
>>78
プリコンパイル済みヘッダは適切に設定してる？
テンプレート使いまくり、33万行のC++コード
Pentium III 800MHz / VC6 / 最適化 速度優先
でフルビルド2分。
82 ：前スレ979：02/09/19 21:38
遅レスだけど前スレ982と984へ。

intやらshortやらも含めて全てのクラスの基底にvoid型のクラスがあるという仮定での話。
この仮定の下ではvoid *はvoidを指すポインタと言う事ができる。
83 ：78：02/09/20 00:03
>>81
抜かりはないつもりだったんだが、設定ミス見付けた(w
修正後は 40 秒に短縮。Thanks.
84 ：デフォルトの名無しさん：02/09/20 00:05
>>79
前者は、それは使いどころを間違ってる。pimpl を使って実装を隠すべき
なのは、もともと仮想関数経由で呼ばれるような部分。
85 ：デフォルトの名無しさん：02/09/20 00:50
>>84
勿論そんなことわかってるよ。
ただ、テンプレート使いまくりでのコンパイル速度の低下の
解消法として使った場合は>>79のようになるだろ？
86 ：デフォルトの名無しさん：02/09/20 02:09
>>85
テンプレートの場合には、ヘッダ間の依存関係は (それほど) 発生しないと
思うんだが。気のせい？
87 ：デフォルトの名無しさん：02/09/20 02:55
コンパイルが遅いとかいうのは処理系依存の話だよねえ
88 ：デフォルトの名無しさん：02/09/20 11:30
>>87
フルビルドの場合はそういう側面が強いが、
差分コンパイル（という言い方あるよな）なら処理系に依存しない
テクニックがあってよくネタになる。
上の pimpl イディオムとかな。
89 ：デフォルトの名無しさん：02/09/20 13:29
>>87
処理系間の比較みたいな話になると、逆にこのスレの方が良いかも。gcc スレ
や VC スレだと、その処理系以外の話はスレ違いだからねぇ。
90 ：デフォルトの名無しさん：02/09/20 22:46
VC++ って、メンバ関数テンプレートの特殊化はできなかったっけ?

class Foo {
public:
template<class T> void func( const T& obj );
};
template<> void Foo::func( const int& obj ) { } // これがエラー
int main(){
Foo().func( int() );
return 0;
}

foo.cpp(5) : error C2511: 'func' : ｵｰﾊﾞｰﾛｰﾄﾞされたﾒﾝﾊﾞ関数が '<Unknown>' にありません。
というようなエラーになるんだけど。
91 ：デフォルトの名無しさん：02/09/20 22:50
C++コンパイルおせーな。
2分や40秒もかかるのかよ。
92 ：デフォルトの名無しさん：02/09/20 23:03
昔は一晩がかりでしたが何か
93 ：デフォルトの名無しさん：02/09/20 23:33
昔結果出るまでに1週間かかったことありましたが何か
94 ：93：02/09/20 23:34
しまった。コンパイルの話じゃなかった。ｽﾓｧｿ。
プログラム作って穴開けてもらって実行してもらって結果もらうまでが1週間ですた
95 ：デフォルトの名無しさん：02/09/21 00:13
おじいさん、昔話ばっかり言わないでよ。
96 ：デフォルトの名無しさん：02/09/21 00:35
昔はマイコンにつきっきりでフロッピー入れ替えながらコンパイルしましたが何か
97 ：デフォルトの名無しさん：02/09/21 00:51
>>91
だから分割コンパイル重要なんですよ。
98 ：デフォルトの名無しさん：02/09/21 01:02
カーネルのリビルドやユーザーランドのリビルドは時間かかるぞ～
この間のリゾルバの騒ぎのときは、リコンパイルに２０時間かかった。
99 ：デフォルトの名無しさん：02/09/21 01:36
> template<> void Foo::func( const int& obj ) { } // これがエラー
じゃなくて
template<int> void Foo::func( const int& obj ) { }
だったりしなかったっけ。
100 ：デフォルトの名無しさん：02/09/21 04:52
>>90
VCはまだクラス定義の外でのスペシャライゼーション定義には対応してないよ。
101 ：90：02/09/21 14:19
さいでしたか…
しかたがない、非メンバ関数でやることにします。
でも、クラス内で specialization できても意味ないよねぇ。
たんなる多重定義と変わらんもん。
102 ：デフォルトの名無しさん：02/09/21 20:40
>>101
まったく無意味でもないかな
ユーザーによるクラス定義外でのスペシャライゼーション
定義を可能にすることは、隠蔽されるべき非公開メンバへの
自由なアクセスを許すに等しいからね。
103 ：デフォルトの名無しさん：02/09/21 21:56
なるほど。その視点は気づきませんでした。
ということは、非メンバ関数のテンプレートでも friend にしたら
同じ問題をかかえるということか。
104 ：デフォルトの名無しさん：02/09/22 19:06
struct A
{ int a; };

struct B : A
{ int b; };

void func(A arry[4])
{
　for(int i = 0; i < 4; i++)
　　arry[i].a = 0;
}

void test(void)
{
　B m[4];
　func(m);
}
これコンパイル通るのっていいの？
105 ：デフォルトの名無しさん：02/09/22 19:21
>>104
何か問題？
func(A arry[4])はfunc(A *arry)と同等で
func(m)ではmが標準変換でB*に変換され
B*からA*へのアップキャストは標準だから
106 ：デフォルトの名無しさん：02/09/22 19:32
コンパイルは通るのが正しい(↑のようにポインタの変換だから)
でも、一般的に、親クラスの配列(の先頭要素へのポインタ)が求められているところに
子クラスの配列を渡してはいけない。参照扱いでも同様。
理由はEffective C++(Moreかも)に書いてあったと思った。
107 ：104：02/09/22 19:41
よくよく考えればそうだった。
実はそれが本題でなく…
後少し時間をください。
108 ：104：02/09/22 19:59
template<class T>
struct A
{
　T a,b;
};

struct B : A<int>
{
　//関数だけ
};

template<class T>
void func(A<T> *a)
{
}

void test(void)
{
　B m[3],*n;
　func(m); // NG
　func(n); // OK
}

'B [3]' から 'A<T> *' に変換できません。
と言われます。なぜm[3]を*mと解釈してくれないんですかねぇ？
109 ：デフォルトの名無しさん：02/09/22 20:05
>>108
キャストが行われないから
110 ：デフォルトの名無しさん：02/09/22 20:18
stringの配列の個数分ループさせるロジックを使いたいのですが、
配列の個数を取得する方法がわかりません、教えてアルゴマン。
111 ：デフォルトの名無しさん：02/09/22 20:23
vector使え
112 ：104：02/09/22 20:23
テンプレートを使うとキャストされないんでしょうか？？
func<int>(m);
func(&m[0]);
なら可能なんですが、他の型同様にfunc(m)で素直に渡したいと考えいるので・・・
なんとかfunc(m)で渡す方法はないですか？

飯買いに行ってきます。
113 ：デフォルトの名無しさん：02/09/22 20:30
bcc では通った。＞ func(m);
114 ：デフォルトの名無しさん：02/09/22 20:41
C++ 3rd の 13.3.2 [3] によれば
「テンプレート引数の推測によって決まったテンプレート関数引数には、
格上げ、標準変換、ユーザー定義変換を適用することはできない」とある。
ということは、引数の推測の際には、継承関係などは全く考慮されない
ということではないか。
115 ：デフォルトの名無しさん：02/09/22 20:44
>他の型同様にfunc(m)で素直に渡したい
のであれば、
inline void func(B *a) { func<int>(a); }
でも定義しておけばよいかと。
116 ：デフォルトの名無しさん：02/09/22 20:52
ということは func(&m[0]) も本当なら駄目っていうことになるか。
117 ：デフォルトの名無しさん：02/09/22 21:12
>>108
実際問題として、変更されたら困ることが多いからだろう。struct B にメンバ変数が
あったら func 内で a[1] とかに触ると、確実に値を壊すし。

っつか継承を使うなら配列は忘れて vector 使え。その方が身のためだ。
118 ：デフォルトの名無しさん：02/09/22 22:59
>>117
継承との関わりで、配列とvectorの間に特別な違いは無いと思う。
どっちを使っても一緒。
そして、継承するようなオブジェクトの実体はvectorなどに入れるべきでは
ない。m1, m2, m3という3個の変数と同じ程度の気持ちで配列に入れるのは
問題ないけど、vectorを使う、ということは実行時に値を追加したい、
ということで、その場合はvector<B*>かvector<shared_ptr<B> >を使うべき。
119 ：デフォルトの名無しさん：02/09/22 23:05
>>118
> 継承との関わりで、配列とvectorの間に特別な違いは無いと思う。
いや delete[] の罠がある。
120 ：デフォルトの名無しさん：02/09/23 01:05
保守
121 ：104：02/09/23 01:49
かなり遅くなってしまいましたが、レスを。
色々やって見ましたが駄目でした。
func(T *a)で取って、内部でA<T>に変換するこで妥協を…
こんな感じに↓
template<class T>
void func(T *a)
{
　A<T::value_type> *b = a;
　//　(；´Д｀)ﾊｧﾊｧ･･･な処理
}

やっぱり標準変換ということで引っかかってるようでした。
func(&m[0])は通るのに･･･
標準変換とかでエラーをだすのはVCだけなんかな？bccはOkらしいし。
STLは覚え中なんで今度の機会に・・・。
mで渡すのにこだわっていたのは&m[0]でしか渡せないのは
非常に分かりにくいと思いまして。(実はもう少し複雑)
ご迷惑お掛けしました。そしてありがとうございました。

寝ます。
122 ：デフォルトの名無しさん：02/09/23 02:33
>>121
//　(；´Д｀)ﾊｧﾊｧ･･･な処理

どんな処理やねん(w
123 ：デフォルトの名無しさん：02/09/23 14:46
下記のようなプログラムを書いたのですが、コンパイルエラーが出ます。
エラーの中身を見るとchar型にint型を入れることができないと言うことなのですが
どうすればよいかイマイチわかりません。わかる方、教えてください。

main()
{
int a,b,c,title;
char file[64];
char name[64];
FILE *fp;
a=0;
b=1;
c=10;
title=10;

for(int x=0;x<title;title++)
{
name=title".dat";
strcpy(file,name);
fp=fopen(file,"a");
for(a=0;a<c;++a)
{
b=b+b;
printf("%d\n",b);
fprintf(fp,"%d\n",b);
}
fclose(file);
}
}
124 ：デフォルトの名無しさん：02/09/23 15:02
エラーの原因は
name=title".dat"; <-- ここ
C++は int(整数) から文字列への自動変換はサポートしていないので
自分で、やらなければならない。

しかし、このプログラムにはそれ以外にも
title=10;
for(int x=0;x<title;title++)
fclose(file);　
などなど、バグだらけだからもう一回初めから作り直した方が
良いと思ふ
125 ：123：02/09/23 16:16
>>124
ありがとうございます。
一から書き直します
126 ：デフォルトの名無しさん：02/09/23 17:02
みんなｓｔｒｉｎｇをintにするのどうしてる？
それと逆の場合。
127 ：デフォルトの名無しさん：02/09/23 17:06
string → int ... atoi()
int → string ... stringstream
128 ：デフォルトの名無しさん：02/09/23 17:06
>>126
> みんなｓｔｒｉｎｇをintにするのどうしてる？
> それと逆の場合。

その時次第。
129 ：デフォルトの名無しさん：02/09/23 17:14
boost::lexical_cast
130 ：デフォルトの名無しさん：02/09/23 17:58
>>123 さんの場合は snprintf が最適解かもっすね。
snprintf( name, 64, "%d.dat", title );
# snprintf がなければ sprintf っすか。
# C++ というよりは C なので sage
131 ：デフォルトの名無しさん：02/09/23 21:01

#include <boost/lexical_cast.hpp>
#include <string>

void f(){
std::string s = "10";
int i = boost::lexical_cast<int>(s);
i += 2;
s = boost::lexical_cast<string>(i);
}
132 ：126：02/09/23 21:07
意外に多くのレスありがとう。
ちなみに俺は、>>127さんと同じです。
もちろん、ケースにもよりますが。
実は、ちょっとatoiはなんか古臭い感じがして、
stringstreamは大げさな感じがしていたのですが、
ちょと安心しますた。
133 ：デフォルトの名無しさん：02/09/23 22:05
lexical_cast は、"0x10~ とかの16進数を扱えない気がしたが
134 ：デフォルトの名無しさん：02/09/23 22:27
>>133
lexical_castは内部でstringstreamを使ってるので、ちょこっといじれば出来るようになる。
135 ：デフォルトの名無しさん：02/09/23 23:58
>>133
特殊化すれば出来る。
136 ：デフォルトの名無しさん：02/09/24 00:12
>>135
おいおい、文字列を扱う部分をフル実装しなけりゃならんの？
137 ：デフォルトの名無しさん：02/09/24 01:17
136==あふぉ
138 ：デフォルトの名無しさん：02/09/24 02:39
とりあえずlexical_cast.hppを見れ。激しく短いぞ。
139 ：デフォルトの名無しさん：02/09/24 03:25
>>138
激しく短くても、lexical_cast<const char*>を特別化したら
自分で中身を全部かかなきゃだめと言ってみるテスト
140 ：デフォルトの名無しさん：02/09/24 03:29
>>139
それは仕方ないかと。
lexical_castは拡張を予想して作られたものではないだろうし。
141 ：デフォルトの名無しさん：02/09/24 04:46
何進数でも使えるように lexical_cast を書き直せば良いと。
142 ：デフォルトの名無しさん：02/09/24 07:56
>>139
全部ったって、中身は５行だぞ、確か。
143 ：デフォルトの名無しさん：02/09/24 09:58
template<typename Target, typename Source, class Manip>
Target lexical_cast(Source arg, Manip manip)
{
# ifdef BOOST_LEXICAL_CAST_USE_STRSTREAM
std::strstream interpreter; // for out-of-the-box g++ 2.95.2
# else
std::stringstream interpreter;
# endif
Target result;

if(!(interpreter << manip << arg) || !(interpreter >> result) ||
!(interpreter >> std::ws).eof())
throw bad_lexical_cast();

return result;
}
144 ：デフォルトの名無しさん：02/09/24 10:16
>>143
C++のキャストの構文と違うからダウト
145 ：デフォルトの名無しさん：02/09/24 12:25
>>144
お前ヴァカだろ。
146 ：デフォルトの名無しさん：02/09/24 12:38
template<typename T, class Manip>
class manip_adapter
{
　T val;
　Manip manip;
public:
　manip_adapter(const T& v, Manip m) : val(v), manip(m){}
　friend std::ostream& operator<<(std::ostream& os, const manip_adapter& rhs)
　{ return (os << rhs.manip << rhs.val); }
};

template<typename T, class Manip>
manip_adapter<T, Manip> make_adapter(const T& v, Manip m)
{ return manip_adapter<T, Manip>(v, m); }

int main()
{
　std::string temp( boost::lexical_cast<std::string>(
　　　　　　　　　　　　make_adapter(make_adapter(100, std::hex), std::showbase)));
　std::cout << temp << std::endl;
　return 0;
}

おもっきり実装依存だが
つか、ここまでするくらいなら素直に stringstream 使えって言われる罠
147 ：デフォルトの名無しさん：02/09/24 15:43
本で安全のために記号定数よりconst定数を使う事の方が多いと書いてありましたが,
なぜでしょうか？
マクロは危険？
副作用はありますが,
#define N_MAX 100
とかなら安全のような気もしますが
constの方が,コンパイラが厳密にミスを見つけてくれるということでしょうか？
148 ：デフォルトの名無しさん：02/09/24 15:56
名前空間の安全性の事かなぁ？
149 ：デフォルトの名無しさん：02/09/24 15:59
>>147

>>148に追加

マクロはコンパイラではなく、プリプロセッサで処理される。

処理系によってはconstやenumにしておけばデバッガから
シンボルとして追えたりするので便利なことも多い。

マクロの場合は#undefすれば再定義できるので危険。

他になんかあるかな？
150 ：デフォルトの名無しさん：02/09/24 16:11
float f;

f=100.0/3.0;

warning C4305: '=' : 'const double' から 'float' へ切り詰めます。

なぜに？

小数の計算は,元々doubleで計算されるから？
151 ：デフォルトの名無しさん：02/09/24 16:25
100.0f/3.0f
152 ：デフォルトの名無しさん：02/09/24 16:25
>>150
yes
153 ：150：02/09/24 16:30
>>151
グッジョブ
154 ：デフォルトの名無しさん：02/09/24 16:50
string s;

s="metjgetijgse;9gjser;0gj;sejge09u4g5;4sejgso4ejmo;gnje;oirjge905gjm;e0j5g:;ejmg;e5jge5jg;0erjg;erjhgo59rhjg;rhjgn0p;strhjg";

可能？
155 ：デフォルトの名無しさん：02/09/24 18:20
マクロ定数とconst定数の話だけど、
const定数は宣言した分のメモリ空間しか占有しないけど
マクロ定数は利用されているところに展開されるから
いっぱい使われてると、その分メモリ圧迫するとか
そういう事ってあったりするんでしょうか？

というか、そういう違いを吸収するのがコンパイラの性能なんでしょうか？
156 ：デフォルトの名無しさん：02/09/24 18:38
>>155
> const定数は宣言した分のメモリ空間しか占有しないけど
その代わり変数アドレスをそこら中にばらまくことになるから、大差ない。
157 ：デフォルトの名無しさん：02/09/24 18:41
文字列の場合はそうともいえない。
158 ：デフォルトの名無しさん：02/09/24 19:01
const std::complex<zero> zero(0);
と
#define ZERO std::complex<double>(0)
はエライちがいじゃないか。
159 ：デフォルトの名無しさん：02/09/24 20:22
>>158
一方が const で他方が非 const だと、全く意味が違うと思われ。
(言いたいことは分かるが）
160 ：デフォルトの名無しさん：02/09/24 20:49
const int GLOBAL=0; のような定数宣言をヘッダファイルに書いて、
これを複数の cpp ファイルにインクルードしたとき、実行時には
cpp ファイル毎に定数のためのメモリが取られるんでしたっけ。
(最適化で変わることもある？)
161 ：デフォルトの名無しさん：02/09/24 21:29
俺はやっぱ名前空間の問題が一番大きいと思うな。
#define はめったなことじゃ使わないで欲しい
Winプログラムしてると泣けてくる
162 ：デフォルトの名無しさん：02/09/24 22:04
int i=0;
a[6]={1,1,1,1,-1,1};

while(a[i] != -1)
{
　//処理

　++i;
}

この場合,別にi++でも問題ないよね？
普通は,どっちを採用した方がいいんだろうか？
163 ：名無しさん＠ＸＥｍａｃｓ：02/09/24 22:14
>162
++i
164 ：デフォルトの名無しさん：02/09/24 22:14
>>162
かわらない
165 ：デフォルトの名無しさん：02/09/24 22:15
>>161

#define N '\n'

cout << "a=" << a << N;

ｳﾏｰ
166 ：デフォルトの名無しさん：02/09/24 22:37
endl使えよ！
167 ：デフォルトの名無しさん：02/09/24 22:38
>>165
素直にendl使えよ。

ところで、streamって<<演算子呼ばれたら勝手にflush呼ぶんだっけ？
168 ： ◆k/Ubp.Kg ：02/09/24 22:42
>>167
<<演算子じゃなくて、endlん中でflushしてるんじゃなかったっけ？
169 ： ◆k/Ubp.Kg ：02/09/24 22:47
手もとにソースがあったので、glibcでの実装。

ostream& endl(ostream& outs)
{
    return flush(outs.put('\n'));
}

operator<<()ではflushしてないっす。
170 ：デフォルトの名無しさん：02/09/24 22:56
std::coutの直後にstd::cinを呼ぶとflushされる。
171 ：デフォルトの名無しさん：02/09/24 22:58
>>160
gccでconst intの場合を試してみたら、Cの時は実体が作られたけど、
C++の場合は最適化すると実体が消えるみたい。
最適化をしなくても、constを付けるとファイルスコープになるらしく、
hoge.c(cc):
extern const int i;
int main(void) {
  return i;
}
moge.c(cc):
const int i = 1;
fuga.c(cc):
const int i = 2;
とすると、Cでコンパイルするとmultiple definition of 'i'に
なって、C++でコンパイルするとundefined reference to 'i'に
なった。
ちなみに、Cで最適化ありの場合、
static const int i = 0;
int main(void) {
  return i;
}
をコンパイルすると、return i;はxorになって、iはどこからも
使われていないのに、iの実体だけは作られていた。
Cのこの挙動の理由が分かる人いない？
172 ：139：02/09/24 23:15
>>171
> 最適化をしなくても、constを付けるとファイルスコープになるらしく、
> とすると、Cでコンパイルするとmultiple definition of 'i'に
> なって、C++でコンパイルするとundefined reference to 'i'に
> なった。

仕様だ。C++ では、const つけるとディフェルトはファイルスコープになる。
173 ：デフォルトの名無しさん：02/09/24 23:32
>>172
ディフェルト？どういう意味？
174 ：172：02/09/24 23:44
>>173
> ディフェルト？どういう意味？

D-Felt だ。手触りがいいフェルトなんだよ...、って Typo だよ、いちいち指摘すんじゃねー。
175 ：デフォルトの名無しさん：02/09/24 23:57
>>174
乗りツッコミにワラタ
176 ：デフォルトの名無しさん：02/09/25 00:02
素直にstringstream使えよ
177 ：デフォルトの名無しさん：02/09/25 01:15
>>168-170
Thx.

なんでそんなこと聞いたかというと、
>>165はstd::flushを呼び出してないので、
画面に表示されないこともあるのかなぁ…と。。。
でも、どこかで、'\n'を書き込んだら自動的にフラッシュされるとか
書いてあったような気がする。。。

自信がなくてｽﾏｿ
178 ：vcpp6：02/09/25 12:05

すみません。質問させてください。
クラスのメンバ関数のデフォルトの引数は、

class A{ void func( int = 1 ); }; void A::func( int i ){}

↑以外の方法で指定できますか？
ホントは↓のように指定したいのですが、エラーが出ます。

class A{ void func( int ); }; void A::func( int i = 1 ){}

179 ：デフォルトの名無しさん：02/09/25 12:16
class A
{
　void func();
　void func( int i );
};

void A::func(){ func( 1 ); }
void A::func( int i ){}
180 ：vcpp6：02/09/25 12:21
オーバーロードですか。ソースが長くなりますね。
まあ、ほんの２行ですが。>>179さん回答どうも

引数が複数あるときはその引数数×２行分長くなりますね。
181 ：デフォルトの名無しさん：02/09/25 12:24
>>180
まぁ、しょーがないよ

class A{ void func( int ); };

と宣言されたメンバ関数を
a.func(); と呼び出すことは不可能だもんよ
コンパイラは

void A::func( int i = 1 ){}

なんてされてるなんて知らないからね
182 ：vcpp6：02/09/25 12:31
レスどうも。>>181さん

なんか、インラインなら出来そうですが、
インラインはやめたほうがいいでしょうか。
メモリを食うとか、何とか、デメリットが有ったような気がします。
↑この辺忘れてしまったので御教授お願いします。
183 ：デフォルトの名無しさん：02/09/25 12:36
WindowsでFindWindow関数の第一引数は
そのアプリケーションのウィンドウ名ということですが、
他の方の作ったアプリケーションのウィンドウ名の
取得はどのようにすればよいのでしょうか？
184 ：デフォルトの名無しさん：02/09/25 12:43
>>182
インライン化しても意味無いと思う

>>183
スレ違いだと思う
185 ：デフォルトの名無しさん：02/09/25 12:48
誘導>>183 http://pc3.2ch.net/test/read.cgi/tech/1032548635
186 ：171：02/09/25 13:11
>>172
なんか、先に宣言してから定義するとグローバルになるっぽいけど、
何だかなあ。
187 ：デフォルトの名無しさん：02/09/25 13:12
>>182
インライン（ヘッダに実装がある）ならば技術的に実装は可能だろうけど、
仕様がそれを許してないから意味無い
188 ：160：02/09/25 14:08
>>171　
>gccでconst intの場合を試してみたら、Cの時は実体が作られたけど、
>C++の場合は最適化すると実体が消えるみたい。
やっぱりそうですか。
宣言の数がかなり多いので、cpp ファイル毎に領域が取られると
すると無駄になってしまいますよね。最適化を考えない場合は
素直に extern したほうが無難ですかね。。
以前 const 定数について、& 演算子で定数のアドレスを取るなど
しない限りにおいては、#define のように値が定数の使用個所に
埋め込まれる(ことがある？) というような話を聞いたことが
あります。激しくうろ覚えですが、最適化の話だったかも
しれません。
189 ：デフォルトの名無しさん：02/09/25 14:24
>>188
C++だとconstはデフォルトでstaticだから、
アドレス参照などで必要にならない限り実体を持つ必要はない。

念のために書いておくけど、実装上は&を使うかだけでは判断できない。
複合型やdoubleなんかの場合は使っただけで割り当てられる場合もある。
190 ：デフォルトの名無しさん：02/09/25 14:51
#define KAKOU a '[' << a << ']'

cout << KAKOU(a) << N;

ｳﾏｰ
191 ：デフォルトの名無しさん：02/09/25 15:27
cout << a '[' << a << ']'(a) << N;
192 ：189：02/09/25 15:35
#define KAKOU (a) '[' << (a) << ']'
193 ：190：02/09/25 15:36
つーかどうみても189じゃなくて,190だろうが
194 ：デフォルトの名無しさん：02/09/25 17:27
externがよくわからん俺はドキュでつか？
（どっかに実体があってって話わわかるけど、
あんまり使えないっつーこってす。）
195 ：デフォルトの名無しさん：02/09/25 18:06
よく使う実体(Appインスタンスとか)をexternしてるけど
196 ：ブタ：02/09/25 18:14
ｺｰﾄﾞ 44 (0x2C) で終了って正しく終了できているのですか？
197 ：デフォルトの名無しさん：02/09/25 18:15
>>196
コンパイラは？
198 ：デフォルトの名無しさん：02/09/25 18:18
>>196
それか、mainをint型にして0で終了汁
199 ：ブタ：02/09/25 18:18
VC++をつかってます．
C:\Windows\ﾃﾞｽｸﾄｯﾌﾟ\Hossaka\新しいフォルダver2\visual.c(190) : warning C4715: 'mean' : 値を返さないｺﾝﾄﾛｰﾙ ﾊﾟｽがあります
って警告がでます．どうしたらいいのでしょうか？
200 ：デフォルトの名無しさん：02/09/25 18:21
>>199
int func1( int i )
{
if( i )
return 3; // 警告。i == 0 では何も返さない。
}
こういうこと
201 ：200：02/09/25 18:31
>>199
>>200みたいになってない？
だから
int func1( int i )
{
　if( i ) return 3;
　return 0;
}
に汁
202 ：　：02/09/25 18:43
>>201
俺はそういう場合,elseをつける派
203 ：デフォルトの名無しさん：02/09/25 18:53
int hoge()
{
　・・・
　switch(i)
　{
　case　1:　return　1;
　default:　return　0;
　}
}
これは警告オプションとかきつくしたりしても警告出ませんか？
204 ：デフォルトの名無しさん：02/09/25 19:00
3項演算子だったら大丈夫

(i?1) return 1:return 0;

そっちは知らんけど,必ず実行されるならいいんでない？
おすすめはしないけど
205 ：デフォルトの名無しさん：02/09/25 19:12
>>204
それを書くなら return (i == 1) ? 1 : 0; だろう。
206 ：204：02/09/25 19:25
ﾜﾗﾀ
207 ：ブタ：02/09/25 19:52
int mean(unsigned char c[])
{
int i,buf;

buf=0;
for(i=0;i<27;i++){
buf+=(int)c[i];
return(buf/27);
}
}
ってなってます
208 ：デフォルトの名無しさん：02/09/25 20:01
それは、
int mean( unsigned char c[])
{ return c[0]/27; }
とどう違うのか？
209 ：デフォルトの名無しさん：02/09/25 20:17
ﾜﾗﾀ
210 ：デフォルトの名無しさん：02/09/25 20:29
ﾜﾗﾀ
211 ：デフォルトの名無しさん：02/09/25 20:33
extern int A;
と
extern "C"{}
でなぜ同じキーワードを使うのかﾜｶﾗﾝ
212 ：デフォルトの名無しさん：02/09/25 20:42
>>211
予約語を増やしたくないから。
213 ：188：02/09/25 21:06
>>189
>C++だとconstはデフォルトでstaticだから、
>アドレス参照などで必要にならない限り実体を持つ必要はない。
なるほどです。
このことは言語仕様で決められているとかではなくて
各コンパイラが、こういうケースでは実体は必要ないと
解釈しても良い(実体を生成しなくても良い)という
ことでしょうか。

>念のために書いておくけど、実装上は&を使うかだけでは判断できない。
>複合型やdoubleなんかの場合は使っただけで割り当てられる場合もある。
例えば double 型の定数に記憶が割り当てられるか
どうかは、それぞれのコンパイラの解釈に依るという
ことですよね。
214 ：デフォルトの名無しさん：02/09/25 22:55
>>160
const はデフォルトでは static linkage だから、それをヘッダに書くと
翻訳単位毎に別々の実体が割り当てられるが。
215 ：214：02/09/25 22:59
既出もいいところだったな。すまん。

ところで extern で const int a; とかとったとしても

printf("%d", a);

というプログラムをコンパイルすると「変数 a のアドレス」が出てくる。
オブジェクトコードのサイズだけ見ると

printf("%d", 1);

も全く変わらんぞ。
216 ：デフォルトの名無しさん：02/09/25 23:09
intで比べてもしょうがないだろ（藁
217 ：デフォルトの名無しさん：02/09/26 00:53
>>216
なにゆえ？
218 ：デフォルトの名無しさん：02/09/26 01:53
大抵ポインタのサイズはintと同じだから

extern const char str[];
cout << str << endl;

と

cout << "asdfghjklqwertyuiopzxcvbnm" << endl;

が同じだったら考え直す
219 ：デフォルトの名無しさん：02/09/26 12:17
>>215
アセンブリ言語のコード吐かせて比較汁。
220 ：引きこもり：02/09/26 16:51
お前らintって聞いたらinteger思い浮かべるか？
interrupt思い浮かべるか？
221 ：デフォルトの名無しさん：02/09/26 17:02
int86ならinterrupt
int32ならinteger
222 ：デフォルトの名無しさん：02/09/26 17:02
integer
interruptはINTって大文字じゃなきゃ。
223 ：デフォルトの名無しさん：02/09/26 17:04
21でもinterruptかな
224 ：デフォルトの名無しさん：02/09/26 20:15
IRQは俺だけか、、、
225 ：デフォルトの名無しさん：02/09/26 20:54
http://www.int-ngy.com/
226 ：デフォルトの名無しさん：02/09/26 21:34
>>224
> IRQは俺だけか、、、

俺もだよ。68系は IRQ だからな。でも、68系のソフトウェア割り込みは、SWI か TRAP だから 86 みたいに混乱 (はしてないようだが...) は無いね。
227 ：デフォルトの名無しさん：02/09/27 01:25
intをあえて日本語で言えば整数となるだろう。
しかし、断じてこれはintegerではない！
intはintなのだ。ひとつの単語なのだ。
あ～int、愛しのint・・・
228 ：デフォルトの名無しさん：02/09/27 01:38
>>227
intは積分記号だろ？
229 ： ◆k/Ubp.Kg ：02/09/27 02:44
>>228
TeXnicianですね(￣ー￣)ニヤリッ

>>227
>しかし、断じてこれはintegerではない！
分かる気がする…Pascalとかでhoge:integerという表記を見るとなんか違和感がある。
hoge:intじゃないのか、と。たまに人のDelphiのソースいじったりすると、hoge:intと書いて
コンパイラに怒られています…(;´Д｀)
230 ：デフォルトの名無しさん：02/09/27 02:48
charも混ぜてください
231 ：デフォルトの名無しさん：02/09/27 06:08
>>230
ほんとうは文字列でもなんでもないくせに、自分の所在をchar *で表すようなやつはダメ。
232 ：デフォルトの名無しさん：02/09/27 18:24
>>231
BYTEならいいですか？typedefで見せ掛けだけですが･･･


ofstreamでバイナリで開いてもバイナリで書き込んでくれませんが
こんなにファイルサイズが勿体無い仕様にしたのは何故でしょう？
233 ：デフォルトの名無しさん：02/09/27 18:41
>>232
？
234 ：デフォルトの名無しさん：02/09/27 18:46
>>233
ofstream fout("aaa.a",ios::out|ios::trunc|ios::binary);
fout<<0x12345678<<'\n';
fout.close();
とやってもファイルには
305419896
と書かれるのですが･･･
235 ：デフォルトの名無しさん：02/09/27 18:52
文字列はstringだってママンから習わなかったの？
236 ：デフォルトの名無しさん：02/09/27 18:55
いやバイナリで開いてるんだから数値を直接入れてくれてもいいのかなと
237 ：デフォルトの名無しさん：02/09/27 18:58
neta ha sine
238 ：デフォルトの名無しさん：02/09/27 19:05
>>234
どういう結果を期待してたの？
239 ：234：02/09/27 19:09
バイナリで 78 56 34 12 0a ってなればいいかなと0aは'\n'でし
240 ：234：02/09/27 19:13
>>239
ああ0a取れないか・・・馬鹿でした
241 ：234：02/09/27 19:15
でも
fin>>iで
iのサイズとれば値を取得できるような・・・
242 ：234：02/09/27 19:30
連続カキコすいません

テンプレート関数内でTのサイズ計れなかったですか？
計れるのならばバイナリで直接数値をぶち込んでも問題はないかと

時間なのでもうすぐ帰ります
243 ：デフォルトの名無しさん：02/09/27 23:13
>>232
> typedefで見せ掛けだけですが･･･
身分詐証、それがイカンのよ。
244 ：デフォルトの名無しさん：02/09/27 23:42
>>236
>いやバイナリで開いてるんだから数値を直接入れてくれてもいいのかなと
ネタとしか思えん…
245 ：デフォルトの名無しさん：02/09/27 23:48
「バイナリを使えば何でもできる」
そう純粋に信じていた無垢な時代が、漏れたちにだって……なかったなあ
246 ：デフォルトの名無しさん：02/09/27 23:54
XMLなんて文字ばっかり
247 ：デフォルトの名無しさん：02/09/27 23:55
釣れた釣れた

ってそろそろ来るんだろうな･･･。
248 ：デフォルトの名無しさん：02/09/28 06:37
C++でpimplイディオムを利用すると自分が敗者になったような錯覚を覚えます。
どうしたらいいでしょうか？
249 ：デフォルトの名無しさん：02/09/28 08:03
漢なら全部テンプレートにしろ。
cppファイル１つにhファイルが2000、とかの状況に萌えろ。
250 ：デフォルトの名無しさん：02/09/28 11:17
>>248
C++ 廃業する。
251 ：デフォルトの名無しさん：02/09/28 14:18
>248
pimpl をただの構造体として使っているとか?
メンバ関数も持たせて、処理を移譲するようにしてやると少しは
オブジェクト指向らしくなると思う。
オレは昔は純粋仮想関数からなるインタフェースクラスを継承することに
美を感じていたが、最近では多態が不要なところでそれをやるのは
ダサいと思うようになってきた。そういうところは、pimpl を使って
処理を移譲するほうが美しい。
252 ：デフォルトの名無しさん：02/09/28 14:27
>>251
ただの構造体隠蔽として使う方がまだ美しいと感じる。

ガワと中身という違う物を実装しているとはいえ、
見てくれ（インターフェイス）が同一な物を２度作らなきゃならんのがダサいと思う。

>最近では多態が不要なところでそれをやるのは

同一の理由により、インターフェイス継承もやりたくない。
253 ：デフォルトの名無しさん：02/09/28 15:29
pimplなんて使うのはダサい！！！
男は黙ってコンパイルせい！！
Pentium 166MHzで！！！
254 ：デフォルトの名無しさん：02/09/28 16:22
構造体ってなんだっけ？

････あ、structureのことか。
日本語キモくって最近使って無かった（ｗ
255 ：デフォルトの名無しさん：02/09/28 17:08
>>254
大和言葉を使いなさい
256 ：デフォルトの名無しさん：02/09/28 17:25
>>254
国賊め！！！
北朝鮮に拉致されてしまえ！！！
257 ：デフォルトの名無しさん：02/09/28 17:27
仮想でない関数はクラスの外で宣言できるようになっていれば、
データ構造だのprivate関数だのを外に晒す必要も無くなるだろうに。
あとメンバtypedefやメンバconstの類も。
operator newがあれば前方宣言だけでインスタンスまで作れる。
258 ：デフォルトの名無しさん：02/09/28 17:56
>>257
そのかわり間接参照が一回増えるのが嫌…っつー時代に設計された言語だ。
そこを責めてくれるな。
259 ：デフォルトの名無しさん：02/09/28 19:03
C++処理系には前処理だけを行なうスイッチが用意されている。

Visual C++の場合

cl /GX /P smp1.cpp -/Pスイッチで前処理だけしてsmp1.iファイルを作る


というふうに本に書いてあったのですが,意味がわからないのですが･･･



あと,cstdioとかは,ネームスペース名は,std;ではなくてどういうのになるんでしょうか？
260 ：デフォルトの名無しさん：02/09/28 19:09
std::ostream に NULL 終端ではない char[] を指定文字数分だけ出力したいのですが、スマートな方法はありますでしょうか？

考えた方法は
１.バッファを確保し strncpy 後に NULL を追加して <<(ostream&, char*)
　　うまくいくだろうけどバッファの動的確保のコストが気になる。
２．ループで指定文字数まで <<(ostream&, char)
　　うまくいくだろうけど効率悪すぎ
３．std::setw
　　指定文字数より長い場合には何もしてくれない
４．同期化された静的バッファにコピー後に <<(ostream&, char*)
　　バッファ長より長い文字列の場合に結局ループしながら書き出さなければならない & 同期化のコストもちょっと気になる。


何か良い方法はないでしょうか？
261 ：デフォルトの名無しさん：02/09/28 19:17
>>260
ない
262 ：デフォルトの名無しさん：02/09/28 19:20
>>261
そんな冷たい事言わずに…
「ない」って言い切るくらい凄腕な方なら、私が考えた例よりも
効率の良い方法とかもいくつか思い浮かんだりするでしょう？
トレードオフの問題も絡めて、私の愚考よりも少しでもいい方法とかあったら
教えてください、よろしくお願いします。
263 ：260：02/09/28 19:21
260=262です。よろしくお願いします。
264 ：デフォルトの名無しさん：02/09/28 19:25
>>258
スタック上にインスタンス作ったり、operator newが無かったりする時は、
クラスの定義が必要、となっていれば、別にオーバーヘッドは無いだろ。
265 ：デフォルトの名無しさん：02/09/28 19:26
>>260
単純に
basic_ostream::write( const char_type *, streamsize )
でダメなのか？
266 ：デフォルトの名無しさん：02/09/28 19:39
int n;


cout << (cin >> n) << endl;

なんか変な数値が出るんだけども,cin関数の戻り値が表示されてるってこと？
267 ：デフォルトの名無しさん：02/09/28 19:49
>>262
効率の良い方法を求めてるわけ？
答えは簡単。
ostreamを捨ててどっかからファイルクラスを拾ってくる。
これ、最強。
268 ：デフォルトの名無しさん：02/09/28 19:56
>>266
MSDNより

cin
extern istream cin;
このオブジェクトは、標準入力からバイト ストリームを抽出します。オブジェクトが生成されると、cintie() を呼び出し、&cout を返します。
269 ：デフォルトの名無しさん：02/09/28 19:59
struct A
{
};

struct B
{
　friend void func(A& a)
　{
　}
};

struct C
{
　friend void func(A& a)
　{
　}
};

void test()
{
　A a;
　func(a);
}

これってエラーにならんのね(VC)
270 ：デフォルトの名無しさん：02/09/28 20:15
funcはクラス外で宣言されたものとみなされるから、かな？
271 ：デフォルトの名無しさん：02/09/28 20:24
>>270
struct B と C のどっちのfuncを呼んだのだろう？と思って
舌のようなコードにしたら、Bが呼ばれてた。

struct B
{
　friend void func(A& a)
　{
　　printf("struct B\n");
　}
};

struct C
{
　friend void func(A& a)
　{
　　printf("struct C\n");
　}
};

…Cのほうは？
272 ：デフォルトの名無しさん：02/09/28 20:28
class と struct の違いって何よ？
273 ：デフォルトの名無しさん：02/09/28 20:30
>>272
デフォルトのメンバがprivateかpublicか。
274 ：デフォルトの名無しさん：02/09/28 20:34
>>273
+キーワードの違い
275 ：デフォルトの名無しさん：02/09/28 21:05
>>272
structはprivateなメンバがないクラスを記述するのに使うとよい。
276 ：デフォルトの名無しさん：02/09/28 21:48
>>264
operataor new というか、ファクトリを前クラスに定義しろって話か？

できそうな気はするが、多重定義や名前空間に絡んで、予期せぬ名前解決された
ときにリンクするまで（あるいは実行時エラーが出るまで）トラブルが判明しないとい
う嫌なバグを作り込みそうな気がする。
277 ：デフォルトの名無しさん：02/09/28 22:03
>>271
VCがヴァカなだけでは？
278 ：デフォルトの名無しさん：02/09/28 22:32
VC以外はどう？
279 ：デフォルトの名無しさん：02/09/28 22:35
bcc, gcc共にコンパイルできず。
funcがすでに定義されてると。
280 ： ◆JAPH9PWA ：02/09/28 22:51
>>266
iostreamはストリームの状態を表す為にoperator void*()とoperator!()をオーバーロードしてるんだよ。
std::cout << (cin >> n) << std::endl;
この場合、istream::operator>>(istream&, T)は第一引数を参照で返すから、
(cin >> n)はcinそのものを返す、と。
で、そのあとcinを出力する為にistream::operator void*()を呼び出す為、
一見不可解な値が表示されるというわけ。
281 ：デフォルトの名無しさん：02/09/28 22:51
こまったもんだ
282 ：266：02/09/29 01:24
>>280
くっ,全然わからない･･･
C++勉強し始めて,7日目だけどいつ頃になったらわかるようになるかな？
283 ：デフォルトの名無しさん：02/09/29 01:25
最初から頭を突っ込むところじゃないと思うけど・・・
284 ：デフォルトの名無しさん：02/09/29 01:43
>>282
あきらめろ、おまえには無理だ。
285 ：デフォルトの名無しさん：02/09/29 01:51
>>282
最初は誰でもわからない、特にC++はCとは違って体系的な学習が
不可欠だ。

取り敢えず入門書１冊読破せよ。
286 ：デフォルトの名無しさん：02/09/29 02:04
>>285
はるひこさんのビギナー編ファイル入出力意外全部読みました
C++やると,C言語に戻りたくないですね
287 ：デフォルトの名無しさん：02/09/29 02:07
>>286
読むだけではなく、手間を厭わず打ち込んで試してみた？
そういう一見無駄な努力が、実はとても役に立つのだ。
288 ：デフォルトの名無しさん：02/09/29 02:12
>>287
すごくうちまくったよ
とはいわないけど,50回くらいは,

cout << "a=" << a << '\n';
進化
cout << "a=" << a << endl;

とか打ちましたよ

まーもっと打てよぼけとか言われそうですけど

C++覚えると,就職有利になりますかね？
c/c++募集ってとこにいきたいんですけど,C言語だけしか覚えていないんですよね
289 ：デフォルトの名無しさん：02/09/29 02:22
>>288
晴彦はどうかと思うが…。
まあ次は何かｱﾌﾟﾘ作ってみなさいってこった
290 ：デフォルトの名無しさん：02/09/29 02:25
>>288
あとは using namespace std; を外して、std::を識別子の前に付ける
ようにすればよい。

就職は、ほとんど会社に入ってから覚えさせられる事が多いので、
まずは自分でバグ取りできるだけの力をつけるようにする。そうすれ
ば進歩が速い。
291 ：デフォルトの名無しさん：02/09/29 03:31
>>290
クラス内でusing namespace std;とかする分には
問題ないんじゃ？
292 ：デフォルトの名無しさん：02/09/29 03:31
あと関数内で。
293 ：デフォルトの名無しさん：02/09/29 03:47
C#やるようになって、C++のヘッダと実装を分ける書き方がなんと美しかったことかと気づかされた。
かといってC++の#includeはいやだ・・・う～～む・・・
294 ：デフォルトの名無しさん：02/09/29 04:54
>>288
> C++覚えると,就職有利になりますかね？
C++ 使う職場なら、もちろん有利になる。
295 ：デフォルトの名無しさん：02/09/29 08:13
VC++.NETで
std::ios::noreplace
がないんだけど。
他に変わる物もみたらないのですが、どうすればよいのでしょうか？

296 ：デフォルトの名無しさん：02/09/29 08:57
>>295
http://www.microsoft.com/japan/developer/library/vccore/_core_differences_in_iostream_implementation.htm
古いiostreamを使うのが一番手っ取り早いかと。
297 ：デフォルトの名無しさん：02/09/29 10:11
>>293
ヘッダなんて無駄なだけだろ
298 ：295：02/09/29 10:24
>>296
ありがとうございます。
古いバージョン使うのあまり気が進まないです。(将来使えなくなりそうなので)
先にファイルOPENして確認するとかしかないか...。
299 ：デフォルトの名無しさん：02/09/29 11:08
>>297
分けないとネストが深くなりすぎてみにくくなる。
まぁ、オレもC/C++の#includeはちょっと好きじゃないけど。
C++なんてnamespaceがあるんだからヘッダのネストとかで悩ませられるのはどうかと思う。
300 ：デフォルトの名無しさん：02/09/29 18:24
ヘッダは無駄と思う。設計ミスって引数変えたり名前変えたりしたときにヘッダもいじらにゃならんし。
そもそも２度同じこと(プロトタイプ宣言とか)を書かないといけないのがスマートじゃない…。Cは仕方無いとして、
C++はなんでヘッダがあるんだろう…？

301 ：デフォルトの名無しさん：02/09/29 19:45
>300
テンプレートライブラリのため
302 ：デフォルトの名無しさん：02/09/30 00:43
Cというなの言語は今はありません。死に耐えました。
ただC++によってそのコードは今生かされているだけなのです。
303 ：300：02/09/30 03:24
>>301
いや、分かってるよ。
分かってるんだけど、もっと別の(ヘッダファイルを使う以外の)スマートなアプローチは無かったんかい、と。
304 ：デフォルトの名無しさん：02/09/30 10:35
>>303
なら、ヘッダに全部書けよ。
305 ：デフォルトの名無しさん：02/09/30 16:48
C++で 比較の結果が0/1であることは保証されてますか？
306 ：デフォルトの名無しさん：02/09/30 16:48
age
307 ：デバックの名無しさん：02/09/30 16:57
乱数はどうやって、発生できるんですか？
308 ：デフォルトの名無しさん：02/09/30 17:13
>>307
ランダムマスターでも使え。
http://www2.toshiba.co.jp/efort/market/rmaster/index_j.htm
309 ：デフォルトの名無しさん：02/09/30 17:18
発生器を使って。
310 ：デフォルトの名無しさん：02/09/30 17:22
「乱数発生法」でぐぐれば一杯出てくる。
http://www.google.co.jp/search?sourceid=navclient&hl=ja&ie=UTF-8&oe=UTF-8&q=%E4%B9%B1%E6%95%B0%E7%99%BA%E7%94%9F%E6%B3%95
311 ：デバックの名無しさん：02/09/30 17:23
>308
C++でやりたいんです。
312 ：デフォルトの名無しさん：02/09/30 17:33
Mersenne Twisterは？
http://www.emit.jp/mt/mt.html
313 ：デフォルトの名無しさん：02/09/30 17:52
boost/random
http://www.boost.org/libs/random/index.html
314 ：デフォルトの名無しさん：02/09/30 18:27
>>305
ある意味、保証されているが、そういう認識の仕方は少し問題だと思う。
315 ：デフォルトの名無しさん：02/09/30 18:39
>>314
どういう事ですか？
Cで比較演算の真偽値が0/非0と言うのは理解してますが、
C++だと0/1が保証されているという記事を読んだので、どうなのだろうと。
316 ：デフォルトの名無しさん：02/09/30 18:44
>>315
厳密にはC++で比較演算の結果はbool型のtrue/falseを返す。
これを整数に変換すると1/0になるという認識が正しい。
317 ：デフォルトの名無しさん：02/09/30 18:49
組み込みの比較演算子は保証されてるけど演算子がオーバーロード
されてる場合もあるからなあ。。
318 ：デフォルトの名無しさん：02/09/30 18:57
>>316-317
なるほど。
サンクスコです
319 ：デフォルトの名無しさん：02/09/30 19:25
std::fstreamの質問です

std::ofstream TestFile("./test.txt");
として
TestFile << "test message...";
とやった場合、メッセージの部分は
fstreamの内部にあるバッファへ溜め込まれているだけ
という認識でいいんでしょうか？
TestFile.flush()するまでファイルアクセスは無いですよね？

fstreamのソースみてもわけわからないです・・・
320 ：デフォルトの名無しさん：02/09/30 19:33
やってみてファイルを見てみましょう
321 ：デフォルトの名無しさん：02/09/30 19:36
>>319
そんなもん実装依存だよ
flushすれば確実に吐き出されることが保証されているだけ
322 ：デフォルトの名無しさん：02/09/30 19:40
>>319
バッファが一杯になると自動的にフラッシュされる。
323 ：デフォルトの名無しさん：02/09/30 19:41
逆に、flushしないで溜め込んでおいたバッファの内容を
参照できるような関数ってあるんでしょうか？

例えばTestFile.c_str()みたいな・・・
324 ：デフォルトの名無しさん：02/09/30 19:44
>>323
rdbuf()
325 ：デフォルトの名無しさん：02/09/30 19:49
>323
検索したらゾロゾロ出てきました
ありがとう
326 ：デフォルトの名無しさん：02/09/30 19:49
>324のミス・・・
327 ：デフォルトの名無しさん：02/09/30 19:59
rdbuf()の面白い使い方。ファイルの内容をたった一行で
全表示する。

#include <iostream>
#include <fstream>

int main()
{
std::fstream ifs("rdbuf.cpp");

std::cout << ifs.rdbuf();
}
328 ：デフォルトの名無しさん：02/09/30 20:11
>>327
それも実装依存。
329 ：デフォルトの名無しさん：02/09/30 20:17
>>328
327です。
ソースきぼん。
俺のソースはC++標準ライブラリ、P603、§13.9。
330 ：デフォルトの名無しさん：02/09/30 20:19
おっとっと間違いﾊｹｰﾝ。std::fstream→std::ifstreamにしてください
331 ：デフォルトの名無しさん：02/09/30 22:17
標準ストリームに関する質問です

std::endl std::ends std::flush の実体ってどこで宣言（定義）されてるんでしょうか？
ヘッダファイル群にGREPしたところ、ヤツらの型が
basic_ostream& (*pf)(basic_ostream&)で受け取れるとこまではわかったんですけど
受け取ってからどうやって振り分けたものか悩んでおります


ストリームのラッパークラスなんて初心者が手を出すような領域じゃ無いのかな・・・
332 ：デフォルトの名無しさん：02/09/30 22:21
>>331
basic_ostreamのような気がする。継承を見ていくと。
333 ：デフォルトの名無しさん：02/09/30 22:24
>>331
実装によるのでコンパイラと使ってるiostreamライブラリぐらいは書いた方が。
今俺の手元にあるSTLPort for DegitalMarsC++ だと stl/_ostream.h にあったが。

つーか、振り分けって具体的に振り分けて何をするつもりだ？
endl をトラップして自前の改行文字を書くフィルタを作るとかか？
334 ：331：02/09/30 22:44
やりたい事は、ファイルオープンと同時に現在時刻の文字列をファイルの先頭に書き込んで
ファイルクローズの際に、またその時の時刻の文字列をファイルの終端に書き足すクラスで
標準ストリームのように、<<演算子で次々挿入できるようにして
endlとflushを受け取ったときに標準ストリームと同じ様な挙動にしたいなぁと

とりあえず<<演算子のオーバーロード（&受け取った型毎オーバーライド）と
endlを捕まえてバッファの内容を吐き出すところまでは実装できたんですが
そういやflush受け取ったときはどうしよう・・・と悩んでいる最中です
335 ：331：02/09/30 22:48
あ、えーと、そんなもんostreamのポインタなりを返す
パブリックなメンバ作ればいいじゃねぇかと言う話かもしれませんが
mystream.lpfstream << "なんたらかんたら" << endl;　とかやると
↑の部分が見苦しいナァと思いまして・・・

贅沢言うな！ってとこなんでしょうか
336 ：デフォルトの名無しさん：02/09/30 22:49
>>334
それだったら、basic_fstreamをpublic継承して、endl, ends, flushだけを
オーバライドすればいいのでは。
337 ：331：02/09/30 22:57
あとなんでこんなややこしい事しとるのかといいますと
fstreamってバッファがいっぱいになると勝手にファイルに書き込んじゃうらしいので
明示的に「書き込め！」って指示するまでひたすらバッファへ溜め込むようにしたいんです

>336氏の方法だと、ファイルオープン/クローズ時の
現在時刻の書き込みはどう実装すれば良いんでしょうか？
338 ：デフォルトの名無しさん：02/09/30 22:58
basic_filebufを自分好みにカスタマイズ
339 ：デフォルトの名無しさん：02/09/30 23:05
う～んopen/close時までカスタマイズするとなると、basic_fstreamの
コンストラクタ/デストラクタまでオーバライドする必要があるなあ。

しかもbasic_ostreamのヘッダを覗いていたら、endl, ends, flushなど
のマニピュレータは、basic_ostreamのメンバ関数ではない様子。
そうなるとオーバライドできないですね。

やはりここは myendl, myends, myflushなど名前を変えた方がよいかも。

rdbuf(pointer)で、大きなストリームバッファは設定できるけど、
出力に合わせて拡張するストリームバッファなんてどうやって実現
していいものやらさっぱりわかりません。
340 ：331：02/09/30 23:13
現在の実装では、バッファにstd::stringを使っているので
可変長バッファの問題はクリアだと思います

flushをendlと同義に扱うか、もっと研究してflushの正体を暴くか
どちらかかと思うのですが・・・

ちなみに以前myendlなどで実装しようと目論んだ事がありましたが
マニピュレータのやり方がわからず、グローバルなmyendlクラスを定義して
お茶を濁すという、なんとも恥ずかしい過去がありまして
今度こそスマートに実装しようとがんばってみましたが、ちょっとお手上げ状態です・・・
341 ：デフォルトの名無しさん：02/09/30 23:22
>>340
それだったら何とかなるかも。ユーザー定義のマニピュレータですよね。

template <class charT, class traits>
inline
std::basic_ostream<charT, traits>&
myendl(std::basic_ostream<charT, traits>& strm)
{
strm << std::endl;
// ここにさせたい処理を書く
}

のような感じでどうでしょう。
342 ：デフォルトの名無しさん：02/09/30 23:22
flushは内部でストリームバッファクラスのpubsync()メンバーを呼んでるなり。
343 ：デフォルトの名無しさん：02/09/30 23:23
符号付き32bit整数をリトルエンディアンで負数は2の補数表現で出力する関数を作りたいのですが
移植性を考えたときによく分からなくなってきたので質問させていただきます。

最初は以下のようにしました。
void writeInt32(std::ostream &o, long v)
{
o.write((char*)&v, sizeof(v));
}
これだと以下のようなことが気になりました。
・long*をchar*にした結果は実装依存？
・sizeof(long)が4とは限らない
・longが負の時のビットパターンが2の補数表現とは限らない

というわけでとりあえず次に以下のようにしました。
o.put(v & 0xff);
o.put((v >> 8) & 0xff);
o.put((v >> 16) & 0xff);
o.put((v >> 24) & 0xff);
ところが、putの引数はcharなんです。
プログラミング言語C++第三版の付録C.3.4(p.942)の下の方には
> void f(char c, signed char sc, unsigned char uc)
> {
> c = 255; // 限定無しのcharがsignedで8ビットなら未定義
とあります。
つまり、(v & 0xff)の結果が255の場合、o.put(v & 0xff)は未定義なのではないでしょうか？
あと、負数が2の補数表現でない場合も考えないといけなそうです。
結局標準C++の範囲内でなんとかするのは不可能なのでしょうか？
344 ：デフォルトの名無しさん：02/09/30 23:23
あ、最後に return strm; つけて下さい。
345 ：デフォルトの名無しさん：02/09/30 23:30
数値表現の可能性を論じてたら先に進まない。
符号付き整数の右シフトも怪しいから、

unsigned long l = (unsigned)v;
としてからo.put(l & 0xff)として書き込むのが良いかと。
346 ：デフォルトの名無しさん：02/09/30 23:32
>>343
charに127を超えるintを代入した時だけが未定義なのであって、
(v >> 8) & 0xffをputするのは別に代入ではなくて関数の引数
だから大丈夫では？
347 ：343：02/09/30 23:55
>>345
>数値表現の可能性を論じてたら先に進まない。
全くその通りですね。2の補数ではない時を考えて負だったらビット反転させて1足して……とかアホなことをやろうかと思ったところで目が覚めました。

>unsigned long l = (unsigned)v;
>としてからo.put(l & 0xff)として書き込むのが良いかと。
実用上これで問題ないと思うのですが、C++標準でsigned charの範囲以上の値を使用した場合の動作が未定義となっているならちょっと怖いなと思ったもので。
どなたかこのコードでうまくいかない環境をご存じの方いらっしゃいますか？

>>346
私もその可能性はあるかなとは思いましたが、一応値渡しですし、代入していることになるのかなと。うーん……
348 ：デフォルトの名無しさん：02/10/01 00:22
>>347
ビットパターンでの表現を絶対に保つ必要があるキャストということなら、
　o.put( reinterpret_cast<char>( l & 0xff ) );
で一応定義された範囲の動作にならんかなぁ。自信ない。
349 ：デフォルトの名無しさん：02/10/01 03:48
>>343
普通の数学的処理(比較、商、剰余)をすればよい
350 ：デフォルトの名無しさん：02/10/01 06:13
charが8ビットである保証はないYO
351 ：デフォルトの名無しさん：02/10/01 09:56
c++でJavaにあるfinal( == 継承できない )と同じような事を実装できないでしょうか?
Javaにできてc++にできないのはものすごく悔しいんですが...

Singletonを応用すれば動的確保限定で継承できないclassが作れますが、
静的なインスタンスが作れないのと、カッコワイルので誰かエレガントな実装を教えてください。
352 ：デフォルトの名無しさん：02/10/01 10:34
>>351
ヘッダに「継承したら頃す」とか書いとけ
353 ：デフォルトの名無しさん：02/10/01 10:41
いや継承したら頃せ
354 ：Java厨：02/10/01 11:12
>>351

悔しいかぁ

>^_^<ぎゃははははは－(爆ｗ
355 ：デフォルトの名無しさん：02/10/01 11:15
char *hoge;
のときは、
hoge = new char[10];
とやればいいと思っているのですが、

char hoge[];
と宣言されている変数を初期化するには、
hoge[10]
とかやればいいの？

356 ：デフォルトの名無しさん：02/10/01 11:34
>>351
__sealed



とか言ってみる
357 ：デフォルトの名無しさん：02/10/01 12:55
>char hoge[];
これはコンパイル通らないのではない？
358 ：デフォルトの名無しさん：02/10/01 16:14
>>351
コンストラクタをprivateにする。
359 ：デフォルトの名無しさん：02/10/01 16:16
extern char hoge[];
void f(char hoge[]){
// ...
}

...って、どっちも初期化の必要は無いな。正直俺の手には負えません
360 ：デフォルトの名無しさん：02/10/01 17:54
次のコードが "max(long double): 1.#INF" と出力するのはなぜでしょうか。

std::cout << "max(long double): " << std::numeric_limits<long double>::max() << std::endl;

gcc3.2(MinGW)です。
361 ：デフォルトの名無しさん：02/10/01 19:29
const char* hoge() って関数で
return NULL; するのはマズいですか？
const char* const hoge() の方がいいかな・・・
362 ：デフォルトの名無しさん：02/10/01 19:41
>>361
値返しだから前者でいいです
363 ：デフォルトの名無しさん：02/10/01 19:42
>>361
あのー、できるだけC++ではNULLの代わりに0を使った方がいいです。
364 ：デフォルトの名無しさん：02/10/01 19:43
>>363
ネタ？
365 ：デフォルトの名無しさん：02/10/01 19:49
>>364
C++の時は、NULLは0になるのでしょうか。
366 ：デフォルトの名無しさん：02/10/01 19:50
>>364
C++ thirdを読みましょう。

# ﾄﾞｯﾁﾃﾞﾓｲｲｷｶﾞｽﾙｹﾄﾞ
367 ：デフォルトの名無しさん：02/10/01 19:54
ガイシュツだけど、STLPortは次のようになってるね。

#ifndef NULL
# if defined(__cplusplus)
# define NULL 0
# else
# define NULL ((void *)0)
# endif
#endif

ほとんどの場合 (void *)0で問題ないけど、>>57-62のような
環境もあるから、0を使った方が無難かと。
368 ：デフォルトの名無しさん：02/10/01 20:02
>>367
62 は環境の問題じゃなくて自分で勝手に
#define NULL ((void*)0)
したせいでうまくいかなくなったって話じゃないの？

NULL は所詮マクロだから処理系依存だけど、
ほとんどの環境で 0 になってるし、なってなけりゃ自分で#defineすればいいだけの話。

むしろ

p = 0; //（ p は int* ）

とかなってて、この近辺でバグってるっぽい時に、
本当は *p = 0 なのか p = 0 なのかいちいち見直さなきゃいけないのは時間の無駄。
NULL はソースの可読性を上げるためのもんなんだから使ったもん勝ちでしょ、
と漏れは思います。
369 ：デフォルトの名無しさん：02/10/01 20:06
１年ぐらい前にそういうスレがあったきがする
370 ：デフォルトの名無しさん：02/10/01 20:14
gcc3.2(MinGW)では

/* A null pointer constant. */

#if defined (_STDDEF_H) || defined (__need_NULL)
#undef NULL/* in case <stdio.h> has defined it. */
#ifdef __GNUG__
#define NULL __null
#else /* G++ */
#ifndef __cplusplus
#define NULL ((void *)0)
#else /* C++ */
#define NULL 0
#endif /* C++ */
#endif /* G++ */
#endif/* NULL not defined and <stddef.h> or need NULL. */
#undef__need_NULL

となっているから、やはり 0 になるようですね。NULLを使っても現時点の
コンパイラでは問題が出ないようになっているのかなあ。
371 ：デフォルトの名無しさん：02/10/01 20:18
文法に
member-declaration:
　decl-specifier-seqopt member-declarator-listopt ;
　function-definition ;opt
　::opt nested-name-specifier templateopt unqualified-id ;
　using-declaration
　template-declaration
という部分がありますが上から三番目ってなんですか？

class c {
　std::vector<int> ;
};
とかやっても結局一番上のやつが適用されているように見えます。
（まぁコンパイルエラーですが）

あと、unqualified_id　に template_id が含まれているのもようわかりません。
unqualified-id:
identifier
operator-function-id
conversion-function-id
~ class-name
template-id

誰か教えて♥
372 ：デフォルトの名無しさん：02/10/01 20:20
0はポインタとして扱うときは常にnull pointerになるのは保証されてる。
マシンによるnull pointerの実際の表現がどんな形であろうと，
ソースの方が0であれば何の問題もない。
で，NULLはnull pointerであることを明示するためのものだから，
#define NULL 0
が正解

（C++では）
373 ：デフォルトの名無しさん：02/10/01 20:33
またNULLの話か(*´∀｀)
374 ：デフォルトの名無しさん：02/10/01 20:45
NULLの次は何？
malloc/free？
375 ：デフォルトの名無しさん：02/10/01 20:57
null ってキーワードを作ってくれよ！
376 ：デフォルトの名無しさん：02/10/01 21:00
Effective C++にある。nullの実装例。
377 ：デフォルトの名無しさん：02/10/01 21:32
NULLスレの余寒
378 ：デフォルトの名無しさん：02/10/01 21:38
null

1　無価値の,効果のない,重要でない.
2　ない,存在しない,ゼロの,ゼロに等しい.
3　〔数〕（集合で）空（くう）の
a ～ set　 空集合.
4　特徴［表情］のない,無表情な.

NULLスレの余寒
379 ：デフォルトの名無しさん：02/10/01 21:46
でも、CのNULLとC++のNULLではカナーリ意味合いが違うよね。
俺の会社では 0 を使っているが。(C++ 3rdに従っている)

>>368氏の意見にも一理あるが、処理系が異なっても NULLの
意味合いを維持できるかちょっと心配がある。
380 ：デフォルトの名無しさん：02/10/01 22:09
というか今時のC++コンパイラで(void*)0なんてやってる処理系無いよ
381 ：デフォルトの名無しさん：02/10/01 22:12
>>380
そりゃ char* p; if ( p == NULL ) ...
が通らなくなるからねえ
382 ：デフォルトの名無しさん：02/10/01 22:12
NULLスレの余寒
383 ：361：02/10/01 22:24
ごめんなさい　ごめんなさい・・・

ぼくが聞きたかったのは、constポインタを返す関数なのに
NULLつーどこに実体があるのか知れないモノを返して良いものかという疑問なワケでして・・・
const char& hoge() だとコンパイルエラーだし、ホンマにえぇのんかっちゅー・・・
384 ：デフォルトの名無しさん：02/10/01 22:26
NULLと聞いて思い出した素朴な疑問。
C++標準ライブラリでは全ての識別子はstd名前空間内で定義されることに
なっていると思いますが、NULLはどうしてstd::つけなくていいんでしょうか？

NULLは<cstddef>で定義されるとありますが、同じcstddef内で定義される
size_tはよくstd::size_tと書いてあるのを見ます。
でもstd::NULLというのは見たことが無いのですが……
(というか、コンパイル通りませんでした。いや、書きたくもないですが(笑))

#define NULL 0じゃstdに入れられないのは分かるけど
C++3rd 5.1.1のようにconst int NULL = 0;とかにすればできなくはないでしょうし。

このあたりのtypedefやマクロの頭につけるstd::の有無はコンパイラによって
かなりばらつきがあるみたいです。ホントのところどうなってるんでしょう？
385 ：362：02/10/01 22:27
>>383
いいつってんだろヴォケ
NULLの実体？アフォですか？
値返しだから関数から戻るときにコピーが作られるんだよ
386 ：デフォルトの名無しさん：02/10/01 22:29
>>384
const int NULL = 0; ってポインタに変換できるの？
コードに直接書かれた 0 だけだと思ってたんだけども
387 ：デフォルトの名無しさん：02/10/01 22:30
NULLスレの悪寒
388 ：361：02/10/01 22:37
>385
そんなもんスレ読んどりゃわかるわカス
スレがメチャクチャなりだしたから
なんであんな阿呆な質問したんか説明しに来ただけじゃドアホ
389 ：デフォルトの名無しさん：02/10/01 22:38
ここも荒れ出したな・・・・NULLとmalloc&freeは禁句なのだろうか。
390 ：デフォルトの名無しさん：02/10/01 22:39
NULLスレになってんのは361とは関係ないような・・・
391 ：デフォルトの名無しさん：02/10/01 22:46
NULL NULL…（*´Д`）ﾊｧﾊｧ…
392 ：デフォルトの名無しさん：02/10/01 22:47
僕のﾃｨﾑﾎﾟが NULL NULL してきたのですが...
393 ：デフォルトの名無しさん：02/10/01 22:55
>>386
C++3rdの5.1.1「ゼロ」の最初によると

「ゼロ(0)は、int型である。しかし、標準変換(C.6.2.3)があるので、
0はすべての整数系データ型、浮動小数点数型、ポインタ型、
メンバへのポインタ型の定数解いて使うことが出きる。……」

ってなってます。で、C.6.2.3「ポインタとリファレンスの変換」を見ると、その中に

「0と評価される定数式は、暗黙のうちに任意のポインタまたはメンバ型への
ポインタに変換できる。」

とあるので、0になる定数式ならなんでもNULLとして使うことができるのでは
ないかと思います。たぶん。
394 ：デフォルトの名無しさん：02/10/01 22:59
寝てる妹のパンツの中に手を入れていじってたら
NULL NULL してきたのですがこれって病気でしょうか？
395 ：デフォルトの名無しさん：02/10/01 23:04
>>393
サンクス
定数式なら桶なのねん。

・
・・
・・・・・・・・
char* p = ( 50+20*4 )/5 - 26 も null ポインタになるのかしらん？
396 ：デフォルトの名無しさん：02/10/01 23:10
逆に定数じゃなきゃダメなのかしら。
int a = 1;
a--;
char *p = a;
あ、コンパイル時に無効なアドレスに変換できないからダメなのかな。
397 ：デフォルトの名無しさん：02/10/02 00:09
>>395
当然
>>396
だめぽ
398 ：デフォルトの名無しさん：02/10/02 00:56
>>371

class Foo
{
　 template<typename T> class Bar;
};
::Foo::template Bar<int>; 　 // 三行目

ってことじゃないの？
見てのとおり、メンバークラステンプレートのスペシャライゼーションの
宣言だけれど。

template_id はテンプレートのスペシャライゼーションを表すものなんだから
unqualified_id に入るのも当たり前な気もするけど。

詳しく知りたいなら、一度 ISO/IEC 14882 に目を通すことを進める。
399 ：デフォルトの名無しさん：02/10/02 02:25
メンバ関数の戻り値が下記のものはどう使い分けるのですか？

class CTest {
　　：
public:
　CTest mFuncA();
　CTest& mFuncB();
　　：
}
Ctest Ctest::mFuncA(){
　return *this;
}
Ctest& Ctest::mFuncB(){
　return *this;
}
400 ：399：02/10/02 02:36
例が分かりにくかったのでもう少し具体的に、、、
下記のコードをコンパイルしてステップ実行したのですが、
戻り値が CTest と CTest& の違いがよく分かりませんでした。
どのように使い分けるのでしょうか？

class CTest{
public:
　int　a;
　CTest mFuncA() {return *this;}
　CTest& mFuncB() {return *this;}
};
int main() {
　CTest ct1,ct2;
　
　ct1.a = 10;
　ct2.a = 100;
　ct2 = ct1.mFuncA();
　
　ct1.a = 20;
　ct2.a = 200;
　ct2 = ct1.mFuncB();
　
　ct1.a = 30;
　ct2.a = 300;
　return 0;
}
401 ：デフォルトの名無しさん：02/10/02 03:14
mFuncAはCTestのcopyを返す。mFuncBはCTestのreferenceを返す。

前者はイヤンな一時オブジェクトを生成する。
後者が返すのはthisそのもの。


# (ﾟДﾟ；)
402 ：デフォルトの名無しさん：02/10/02 03:16
>398
specialization というか、qualification だよね。
C++ 3rd, C.13.6 に書いてある。
403 ：401：02/10/02 03:19
仕様書持ってないからちょっと待って。
違うかも。
404 ：デフォルトの名無しさん：02/10/02 03:45
>>403
合ってるよ。

referenceを返す方は当然

ct1.mFuncA().a = 20;
ct2.mFuncA().a = 30;

のような書き方ができて、元のオブジェクトのメンバを変えられる。

ct1.mFuncB().a = 20;
ct2.mFuncB().a = 30;

はエラーではないが、一時変数を変更するだけで、その値は捨て
られるので何の効果もない。
405 ：デフォルトの名無しさん：02/10/02 03:46
スマソ。mFuncAとmFuncBは逆ですた。
406 ：デフォルトの名無しさん：02/10/02 05:37
抽象基底クラスAがあり、class B,CをAから継承するとします。
関数funcの引数としてB,Cをとりたいとき、
1. template <typename hoge> func (hoge tmp)
2. func (A tmp)
実行速度を含めてどっちがいいんでしょうか？
407 ：デフォルトの名無しさん：02/10/02 06:09
>>406
顔を洗って出直して来ること。
func ([const] A* tmp);が正解。
func (const A& tmp);もまあOK。
408 ：371：02/10/02 10:23
>>398
ありがとうございます、が意味がよくわかりません。

>::Foo::template Bar<int>; 　 // 三行目
のとこはクラスの外側だから「三行目」にはならないと思うんですが。
（templateもいらない(あってはならない？)ような？）

>見てのとおり、メンバークラステンプレートのスペシャライゼーションの
>宣言だけれど。
ということですが、これはなんか意味を持っているのですか？
int;
ってするのと構文的には同じ(block-declaration　->　simple-declaration)
ように見えます。
実際、gcc2.95では
> declaration does not declare anything
っていわれます(templateは削って)。

>詳しく知りたいなら、一度 ISO/IEC 14882 に目を通すことを進める。
そこから文法を引用しました。本文は長いので眺めただけですが。
409 ：402：02/10/02 11:46
だから C++ 3rd, C.13.6 をよめって。
410 ：デフォルトの名無しさん：02/10/02 12:12
C++3rd持ち出して偉そうに語るヤシっているけど、
C++3rd買うくらいならIS買う人もいるんだから
持ってるのが当然って言い方はどうかと :P
411 ：371：02/10/02 12:15
>>409
読んだけどそれとはぜんぜん違う話だと思うな
412 ：402：02/10/02 15:12
ああ、そうか、たしかに状況は違うね。
でも、後続する unqualified-id が template であることを明示する、
という機能では同じものかと思う。ところで、今、
template<class T> class Foo {
T::template hoge<int>;
};
とか試したけど、g++ 3.2 じゃ、エラーになるね。
ISO C++ forbids declaration of `hoge' with no type
`::hoge<int>' is not a valid declarator
とか言われる。書き方が間違ってる?
413 ：デフォルトの名無しさん：02/10/02 15:37
>>412
typename T::template hoge<int>; とすればよい。
414 ：371：02/10/02 19:13
>>412
えーとつまりキーワード「template」について
nested-neme-specifier や qualified-id や上述の member-declaration で
同じ意味(次の'<'は演算子ではない)で使われているということ
を言ってるのですか？

それならその通りだと思いますが、>>371の質問の意図は「上から三番目」
がどの場面で適用されるのか？ということなので。

>>412で挙げてある例(?)に>>413の修正をしたものも明らかに>>371の
「一番上」が適用されると思うし(typenameがあるから三番目にはならない)。

勘違いがあれば突っ込んでね♥

あ、あと>>371でunqualified-idにtemplate-idがなぜ含まれるのかわからん
って書いてるのはusing-declarationで使うからっていうことで自分では
納得できたので、この理解で問題なければ触れていただかなくて結構です。
415 ：デフォルトの名無しさん：02/10/02 19:47
スレ立てるまでもない質問にも出してしまったのですが，
こっちの方が適切と思うのでこちらにだけ繰り返し
張らせていただきます．ごめんなさい
＜困ってること＞
継承を介してメンバ関数のオーバーロード
ではなく多重定義を狙ったのですがうまくいきません．

＜詳細＞
親クラスから継承して子クラスを作りました．そのとき，
親クラスで定義したSet(int)というpublicな
メンバ関数があるのですが，これと同じ関数名で
引数の違うSet(int,int)という関数を定義しました．
これで，子クラスにSet(int)とSet(int,int)という
多重定義されたメンバ関数が定義されたと思い
まして，喜び勇んで子クラスで宣言した変数a
からa.Set(int)を呼び出したらgccに
「そんなメンバ関数無いよ」と起こられました．
誰か，こんな現象について知っている方
解説お願いします．
416 ：デフォルトの名無しさん：02/10/02 19:57
子供が親と同じ名前のﾒｿﾄﾞを宣言した瞬間、
親の関数は引数にかかわらず全て隠されてしまいます。
417 ：デフォルトの名無しさん：02/10/02 19:59
a.親クラス::Set(int)
418 ：デフォルトの名無しさん：02/10/02 20:01
C++の仕様で最もハマりやすいアレですな。
Exceptional C++という本にも説明があったと思う。

今実験したんだけど、virtualでも隠されるとは思わなかった・・・
419 ：デフォルトの名無しさん：02/10/02 20:02
解決策としては子クラスに
using 親::Set;
って書けばよいです。

なぜこんなことになるかというと
オーバーロード解決はその識別子が見つかった時点で親にさかのぼるのを
やめてしまうからです。
つまり 子::Set があるので 親::Setは候補に入らないのです。
で、using-declarationによって 親::Set が 子::Set と同じレベルに置かれるので
OKになるっていうことだと。
420 ：デフォルトの名無しさん：02/10/02 20:05
>>416,417
どうもありがとうございます．
なるほど，そうでしたか！！このように隠れてしまわない
ためにできる方法はないでしょうかね？ちなみに技術評論社
「決定版　はじめてのC++（塚越一雄）」では
これができるとし　　　　　　っかり書いてありました
が，騙されたということですね．それにしても
分かってよかったです．大変お世話になりました！！
421 ：デフォルトの名無しさん：02/10/02 20:06
g++では__nullを使うようにしてるんだけど、VC++ではそういう
適当な拡張はあるの?
422 ：398：02/10/02 20:09
>>408
C++標準はメンバークラステンプレートの任意のスペシャライゼーションを、
クラス定義の外部で宣言することを許している（クラス内部に存在しなければ
定義もOK）。
だから、クラス定義の外で問題ない。

>これはなんか意味を持っているのですか?
宣言だけしといて、定義しなけりゃその型のスペシャライゼーションを
抑止できるような気もするが……気のせいかもしれない。
＃手元にVC7しかないので……

>そこから文法を引用しました。本文は長いので眺めただけですが。
あるなら、せめて9.2とか14.2 とか、ちゃんと読んでみてほしいな



423 ：デフォルトの名無しさん：02/10/02 20:09
>>421
自重しる
424 ：デフォルトの名無しさん：02/10/02 20:11
>> 418
Exceptional C++にはちゃんと書いてあったんですね！
購入を検討します．
>> 419
かっこいいですね！ちゃんと隠蔽の回避方法があるとは！

みなさん，丁寧な説明痛み入ります．ありがとう！！
425 ：デフォルトの名無しさん：02/10/02 20:21
彼女のパンツを見たら__nullっとしたものがついてましたが病気でしょうか
426 ：423：02/10/02 20:21
>>421
ちなみに無い
427 ：399 = 400：02/10/02 20:24
>>401 >>403
>>404 >>405
おっしゃるような現象が確認できました。
（ct2.mFuncA().a = 30; の方はコンパイルエラーになりましたが、）
なんとなく違いが分かりました。どうもありがとう。
428 ：デフォルトの名無しさん：02/10/02 20:28
>>425
あなたがback_inserterだからです
429 ：421=428：02/10/02 20:29
>>426
サンクスコ
430 ：デフォルトの名無しさん：02/10/02 20:53
C++2nd r.13.1「宣言の一致」を要約すると、派生クラスのメンバと
基底クラスのメンバは異なるスコープに属しているので、両方に
同じ名前のメンバ関数があるときは多重定義されるのではなくて
派生クラスのものが基底クラスのものを「隠す」ということに
なるようです。
431 ：430：02/10/02 20:55
鬱死
432 ：371：02/10/02 21:03
>>422
もしかして自分は大前提を知らないのかもしれないので
まずひとつだけ教えてください。

スペシャライゼーションってどういう意味で使ってますか？
自分が知ってるのはクラステンプレートでは
template</* ... */> class templ_name<int> { /* ... */ };
っていうのだけなんですが、これのほかに
最初に「template」が置かれない「スペシャライゼーション」と呼ばれるもの
があるのですか？
( >>398では ::Foo::template Bar<int>; を
　「スペシャライゼーション」といってるのですよね？)
433 ：デフォルトの名無しさん：02/10/02 21:17
すみません、VC++で、ＤＯＳ窓でよいのですが、
S-JISのコードを指定して出力っていうのが、どうしても半角になってしまうんです。
どうしたら全角で出すことが出来るでしょうか？
434 ：デフォルトの名無しさん：02/10/02 21:30
main()
{
　puts("これでも半角になるのかYO!");
}
435 ：433：02/10/02 21:32
>>434
ありがとうございます。
でも、変数にs-jisの文字コードをいれて、
それをs-jisだと指定して、全角で出力するにはどうするといいでしょうか？
よろしくお願いします。
436 ：デフォルトの名無しさん：02/10/02 21:34
いみがわからんのう・・
437 ：デフォルトの名無しさん：02/10/02 21:35
そのおかしくなるプログラムを見せてみてYO!
438 ：デフォルトの名無しさん：02/10/02 21:47
main()
{
std::string s = "これでも半角になるのかYO!";
　std::cout << s << std::endl;
}
439 ：デフォルトの名無しさん：02/10/02 21:58
>>435
もしかしてint型の変数に全角のコードを入れてらっしゃるとか？
440 ：デフォルトの名無しさん：02/10/02 22:04
まさか……
putchar(0x82a0);//←「あ」
とかやってるとか？
441 ：デフォルトの名無しさん：02/10/02 22:08
はい。
442 ：デフォルトの名無しさん：02/10/02 22:09
cout.put('え').put('あ'); //er...uguxu
443 ：デフォルトの名無しさん：02/10/02 22:14
putchar(0x82); putchar(0xa0);
444 ：デフォルトの名無しさん：02/10/02 22:15
↑
ｦ■
445 ：デフォルトの名無しさん：02/10/02 22:27
std::cout.put(0x82).put(0xa0);
446 ：デフォルトの名無しさん：02/10/02 23:12
エンディアーン
447 ：デフォルトの名無しさん：02/10/02 23:21
カラの class Foo {}; があるとき、既存のclass Bar { ... };
を class Bar : public Foo { ... }; に書き換えても、
sizeof(Bar) が変化しないことって保障されていますっけ?

VC++の6では無変化かなと思うのですが。
448 ：( ´-｀).｡ｏＯ(なんでだろう……)：02/10/02 23:27
// 環境: VC++7 + STLport 4.5.3
#include <cstdio>

int main()
{
std::puts("hogehoge"); // error C2039: 'puts' : '_STL' のメンバではありません。
}
449 ：デフォルトの名無しさん：02/10/02 23:28
あの、MIDI音っていうんですかね。midiOutShortMsg。
ピアノ音みたいなのが出るじゃないですか。
で、MIDIででる、ギターとか好きな音を大体のですがどうすればいいでしょうか？
また、ピアノ音は自然に消えますよね？で、鳴らしつづけるにはどうすればいいでしょうか？
450 ：デフォルトの名無しさん：02/10/02 23:29
>>447
Barに一つでも新しいデータメンバ or 仮想関数が付け加わったら、
サイズは大きくなるよ。sizeof()という事になるとパディングの問題も
あるけど、おおむね大きくなると見て良い。
451 ：デフォルトの名無しさん：02/10/02 23:31
>>448
cstdio.hで全体をstdのネームスペースで包んでいない。つまり、STLPortが
適用されていない可能性あり。
452 ：デフォルトの名無しさん：02/10/02 23:31
>>450
Barの変化でサイズが変わるのはOKです。Fooを継承したことで
サイズが変わり得るかどうかだけ知りたい感じでしょうか。

Fooは常にカラです。

453 ：デフォルトの名無しさん：02/10/02 23:32
>>450
答えになっているのか？
454 ：デフォルトの名無しさん：02/10/02 23:32
>>452
基底クラスに仮想関数があったら、変わるんじゃない？
455 ：デフォルトの名無しさん：02/10/02 23:34
おもいっきり実装依存な予感

便乗だけどメンバ変数の無いクラスのsizeofの値って決まってたっけ？
456 ：デフォルトの名無しさん：02/10/02 23:34
すごくスレ違いでｽﾏｿ。
只今、モナー版にて、「☆☆モナー海を渡る☆☆」
というスレで、その手のプロ（海外版windows等に詳しい方､
AA、モナー職人様、英語のプロ（パソコン用語詳しい方）、
などを臨時必要としています。手の空いている方、
腕に覚えのある方,興味のある方はぜひご参加くださいませ。
457 ：447：02/10/02 23:37
ちなみに、Cからのポーティングをやってます。
似たような構造体が大量にありまして、それ一つ一つにメソッド
書いてられません。

コーディング規約の縛りで、Cプログラマが見る可能性のある部分に
templateを使ってはだめなので、そういう構造体を一様にFooから派生
させちまえ、という作戦です。void* よりいくらかマシかなと。

Fooで受けたあと、僕の好きになる部分では、templateで各構造体への
処理を共通化する予定と。

458 ：デフォルトの名無しさん：02/10/02 23:41
それは無理にC++化するとハマるんでない？
仮想関数は使う予定？
459 ：デフォルトの名無しさん：02/10/02 23:42
>>458
FooにもBar(群)にも仮想関数は使わない予定。というか
両方ともメソッドなしのホントのstruct。
460 ：デフォルトの名無しさん：02/10/02 23:44
>>459
メソッド無しのstructなら、なぜ継承しなければならないのかと小一時間。
461 ：デフォルトの名無しさん：02/10/02 23:44
せっかくスゲェ波>>449が来たってのに、みんな無視かよ！
乗ろうぜ！乗ろうぜ！？
462 ：デフォルトの名無しさん：02/10/02 23:46
struct Foo {};
struct Bar1 : public Foo { ... };
struct Bar2 : public Foo { ... };

class Hoge {
public: void SetBar( const Foo& foo );
};

SetBarを複数書きたくないから。 >>460


463 ：デフォルトの名無しさん：02/10/02 23:46
うーん、うーん(;´Д`)
あとはnewとmallocが混在しなければ大丈夫・・・かなあ
464 ：デフォルトの名無しさん：02/10/02 23:47
>>461 無視
465 ：デフォルトの名無しさん：02/10/02 23:47
Hoge::SetBarの中でどうやってBar1とBar2を見分けるのさ？
466 ：デフォルトの名無しさん：02/10/02 23:48
>>449は質問っぽい文章をランダムに生成するスクリプトだろ。
467 ：デフォルトの名無しさん：02/10/02 23:50
(ﾟ⊿ﾟ) ﾂﾏﾝﾈ
468 ：デフォルトの名無しさん：02/10/02 23:50
#define SetBar( s ) templateSetBar( s ) /* ここだけ C プログラマに見せる */

template< typename type > void templateSetBar( type& s )
{
}
469 ：デフォルトの名無しさん：02/10/02 23:52
>>465
ダウンキャストすりゃわからないはずもないけど？

というか、前に書いたように、別のメソッド
private: template <typename T> void ProcessBar( const T& bar ) { ... }
に渡して、bar.member_name に直接アクセスする予定。

Bar1とBar2で、少なくとも俺が触らなければいけない部分は、
メンバ名、型ともに同一なんでね。

で、Bar1とBar2は、sizeofの値が変わるとまずいらしいのね。
多分構造体の直書きとかしてるんでしょう。Cじゃシリアライズ
も糞もないだろうから。

# なんのために説明してるんだろう。。。
470 ：デフォルトの名無しさん：02/10/02 23:54
>>468
そうしようかな・・・・・・・

文句きそうだけど。。
471 ：デフォルトの名無しさん：02/10/02 23:55
>>470
そんなこと（ﾟεﾟ）ｷﾆｼﾅｲ!!
472 ：デフォルトの名無しさん：02/10/02 23:55
>>469
ごめん。469は俺の失言。

どうしよ・・

473 ：デフォルトの名無しさん：02/10/03 00:04
やっぱりテンプレートだけにします。
メンバ変数だけの構造体の扱いなんて　すっかり忘れていた罠。
ど失礼しましたー。
474 ：デフォルトの名無しさん：02/10/03 01:53
ビビッた････
窓の辺にドスンドスン体当たりしてくる音が聞こえて開けたら
物凄いデカイ蛾だった･･･
一瞬ツバメかと重多よ
475 ：ん？：02/10/03 01:56
3分格闘して2本の帚で挟んで外に出してやったよ。
476 ：デフォルトの名無しさん：02/10/03 01:56
STLスレが熱い。
477 ：デフォルトの名無しさん：02/10/03 02:01
STLスレが臭い。
478 ：デフォルトの名無しさん：02/10/03 02:57

●●●●●●●●「オセロさえ納期内に作れない＝ＯＯ役立たず 」祭り●●●●●●●
／|　　　　　　 　 |　 |＿＿＿＿_ΦΦΦΦΦΦΦΦΦΦΦ||ΦΦΦ
　 |　　　　　　 　 |　 |￣￣￣ ／|　　　　　 　 　 　 　 　 　 　 ||
　 |　　　　　　 　 |　 |　　　／ ／|TTTTTT　　 TTTTTTTTTT||TTTTT
　 |　 　 　 　 ／＼　|　 ／|／|／|^^^^^^ |三三| ^^^^^^^^^^^||^^^^^^^
　 |　 　 　 ／　 ／　|／／ ／ ／|
　 |　　　／　 ／ |＿|／|／|／|／|
　 |　 ／　 ／　　|文|／ ／／ ／
　 |／　 ／.　 ＿.|￣|／|／|／　　　　　　　　　Λ＿Λ
／|＼／ 　／　／ 　|／ ／　　　　　　　　　　 （＿＿_）
／|　 　 ／　／　 ／ヽ　　　　　　　　　　　　/〔 非OO 〕〕つ
　 |　　　|￣|　 |　|ヽ／l　　　　　　　　　　　 ｀/二二ヽ
　 |　　　|　 |／|　|__|／　　　Λ＿Λ　　　　 /　/（＿）
　 |　　　|／|　 |／　　　　　 （　´∀｀）　　　（＿）　　　 Λ＿Λ
　 |　　　|　 |／　　　　　 ／/ /　 ^￣］ﾟ　　　　　　　　（｀　　　）
　 |　　　|／　　　　　　　 ﾟ/￣￣_ヽ　　　　　　　　　⊂〔〔 非OO 〕
479 ：デフォルトの名無しさん：02/10/03 03:08
荒らさんと何かネタくれ。
480 ：名無しさん＠Ｅｍａｃｓ：02/10/03 06:12
がいしゅつな質問だとは思うのですが、
コピーコンストラクタと operator= のオーバーロードって
どんなときに使い分けるんですか?

どっちも同じでいいじゃん、と思うのですけど。
481 ：デフォルトの名無しさん：02/10/03 06:26
>>480
コピーコンストラクタ：
　代入以外でも使える（引数とか戻り値）
　const なメンバが初期化できる
operator=：
　右辺が同じクラスじゃなくても使える

とか
482 ：デフォルトの名無しさん：02/10/03 06:26
>>480
初期化と同時に複製するか、
初期化の跡に代入するか、の違い。
483 ：デフォルトの名無しさん：02/10/03 10:26
ポインタに関する質問2点です。

ポインタが（ ）で囲まれている場合の
通常のポインタとの違いを教えてください。
　例
　(*Labels)[key]=Value　や
　(*P).first　など。

また，* が後ろについている場合の
前につく場合との違いをおしえてください。
　例　関数の戻り値が，クラス名*


484 ：デフォルトの名無しさん：02/10/03 10:37
>>483
そんな簡単なこともわからないのかよ。だっせー。
485 ：デフォルトの名無しさん：02/10/03 10:42
>>484
要するに答えられないわけですね(^^)
486 ：デフォルトの名無しさん：02/10/03 10:49
>>485
そう、答えられないの。要するにお前は俺と同レベル、もしくはそれ以下(藁
487 ：デフォルトの名無しさん：02/10/03 10:51
>>486
×要するにお前は俺と同レベル、もしくはそれ以下(藁
○要するに俺はお前と同レベル、もしくはそれ以下(藁
488 ：デフォルトの名無しさん：02/10/03 11:06
C++というより、Cの質問だと思うけど
たしか a[] は *a よりも「くっつきやすい」ので、
カッコをつけないと

　*(Labels[key])=Value
　*(P.first)

のように解釈されてしまうんだと思う。
これは全然意味がちがっちゃうよね。

あと、char* など、 * が後ろについている場合は
それは「char*」という型名の一部、前についている場合は
演算子。

こんなとこでいいかな?
489 ：デフォルトの名無しさん：02/10/03 11:11
>>483
１・
括弧は演算の優先順位を変えるだけ

２．
変数に付いてるなら * は常に前にある、
型なら常に後ろにある
int * p;
変数の後ろに * が来たらそりゃ積演算子だ
490 ：483：02/10/03 12:07
>488
初プログラムがC++の初心者なので，
Cとの差異がわからず申し訳ありませんでした。
にもかかわらずレスいただいて感激です。

まず，1つめについては +激しく理解+ です。

2つめについては…もちょっとよろしいですか?
つまり，* が後ろにあってもやはりポインタ型を表す
ということでよろしいでしょうか。

今読んでいる本から抜粋しますと
Vertex* Edge::souce()
となっており，Vertexは自作のクラスです。
491 ：483：02/10/03 12:13
>489
あ，返事を書いているうちに新たな回答が
ありがとうございます。
つまり，変数とクラスを判別するために，
前と後ろに書き分けるということでしょか。
492 ：デフォルトの名無しさん：02/10/03 12:21
>>491
ここはちょっと難しいねぇ。
* には3種類の意味があるんだ
型の後ろに付いてポインタ型を表すもの
変数の前に付いて間接参照するもの（typedef含む）
変数の後ろに付いて積演算するもの

変数とクラスを判別するために前と後ろに分けるんじゃなくて
それぞれ意味が違うから書き分けるの
493 ：492：02/10/03 12:23
すまん
（typedef含む）は脳内消去してくれ、ちょっと意味が違う
494 ：デフォルトの名無しさん：02/10/03 12:38
>>489
()は関数呼び出し演算子の可能性もあるYO!
495 ：483：02/10/03 12:38
はい，難しいです(´Д`*)
ここは，ポインタ型なんだ!と割り切った方がいいのでしょうか。
今，初心者本1冊目の最終章なのですが
例題のプログラムが急に難しい応用や
既出じゃないことが出てきたような気がして
辟易しています。

性格上，全部きっちり理解するまで次に進めないのですが
そもそも，このような勉強方法が間違っているのでしょうか(藁
もっとポインタやクラスについて詳しい本を，次々読んだ方がいいのかな。
496 ：デフォルトの名無しさん：02/10/03 12:53
>>495
ん～～漏れがぴきぴきドカーンと来た説明に
変数や関数の宣言は型の右っかわに書いた式がそのまま左にある型と同じくなるように作られたってやつ。

int * p は int* 型の p というより、むしろ *p の型が int と理解すると早いです。
Vertex * Edge::source() は、Edge::source() の戻り値が Vertex* という意味なんだけれど、
むしろ *Edge::source() の型が Vertex と思ったほうがいいです。

そう理解しておくと複雑なポインタ宣言
int (*(*pfunc)(int, int))(void) = func;
みたいなのも理解しやすい
497 ：483=495：02/10/03 16:42
>>496
念力集チューしてみましたがだめぽ…。
ますますこんぐらがってきた!!
Vertex *p_souce　がVertexクラスのオブジェクト（ポインタ）
P_souceを宣言しているということは
わかるのですが，
戻り値が Vertex* という意味がどうしてもわかりません。

>int (*(*pfunc)(int, int))(void) = func;
括弧がいっぱいですね。泣きたくなってきました。

498 ：デフォルトの名無しさん：02/10/03 17:04
>>497
Vertex *v[];
が (array of) (pointer to) (Vertex)
って読めるのはわかるかな？
これがわかってるんなら、関数と変数を分けて考えずに、
Vertex *f();
ていうのは上の「～の配列(array of ～)」 が
「～を返す関数(function retunring ～)」に変わっただけだと考えるのはどうかな？

つまり、 * も　[] も 引数を示す()　も変数名(あるいは識別子)に付く「飾り」
っていうような・・。
499 ：483=495：02/10/03 17:34
>498
バカでごめんね。･ﾟ･(ﾉД｀)･ﾟ･｡。つきあってくれてありがとね。

Vertex *f();
Vertexクラスにポインタを返す関数fということでしょうか…。
そこはかとなくわかってきたような気も…。

ただ，例題のプログラムの中で *の位置を
Vertex* Edge::source();
Labels *getlabels( );
というようにわざわざ書き分けてあるので
何か意味があるのかと思っていたのですが…。

※Labels というのは，map<string string>をtypedefしたものです。
500 ：デフォルトの名無しさん：02/10/03 17:39
>Vertexクラスにポインタを返す関数f：に=>の
クラスに返すってどこにポインタが入るのよ

>Vertex* Edge::source();
>Labels *getlabels( );
書き分けは意味なし気分次第でしょう
501 ：500：02/10/03 17:41
>map<string string>をtypedef
あ、これならスペースが無いとコンパイル通らないかも
502 ：483=495：02/10/03 18:03
>500
重ね重ね申し訳ないです。

>書き分けは意味なし気分次第でしょう
ま，マジですか…これで一週間悩んでますた。

だって，ポインタの説明の章で
int *p ，int* p のどちらの書き方でもかまわないが
本書では，int *pで統一します ってわざわざ断り書きしてあったの。
で，Vertex* これは何だ？と。
小○俊夫タンめ～ヽ(`Д´)ﾉ

でもおかげでいろいろ勉強になりました。
コレ以上厨質問すると怒られそうなので，また自習に戻ります。
またどうしようもなくなったら来ますのでよろしくお願いします。
503 ：デフォルトの名無しさん：02/10/03 21:53
声を録音するにはどうすればいいのでしょうか
504 ：デフォルトの名無しさん：02/10/03 21:57
ラブホテルにコンクリートマイクを持ち込むといいんじゃないでしょうか
505 ：デフォルトの名無しさん：02/10/03 23:15
>>503
馬鹿質？
506 ：デフォルトの名無しさん：02/10/04 00:11
ヘッダファイルの基本的な書き方を教えてください。
実装とインタフェイスを分けて、実装が変わっても大丈夫なようにする
ハンドルを使うのが一般的なんでしょうか？
507 ：デフォルトの名無しさん：02/10/04 00:13
>>503
スタート→プログラム→アクセサリ→エンターテイメント→サウンドレコーダ
508 ：503：02/10/04 00:16
もっと気の利いた回答を期待したのだがな。
洒落のわからんやつばかりだ。
もてねーだろ、おめーら。
509 ：デフォルトの名無しさん：02/10/04 01:08
市ね508
510 ：デフォルトの名無しさん：02/10/04 01:11
>>506
>実装とインタフェイスを分けて、実装が変わっても大丈夫なようにする
と
>ハンドルを使うのが一般的なんでしょうか？
の繋がりがよーわからん。
511 ：デフォルトの名無しさん：02/10/04 01:13
ヘッダファイルの書き方とクラス・インターフェースの設計は別問題だとオモワレ
512 ：デフォルトの名無しさん：02/10/04 01:21
>>506
「pimplイディオム」で検索すれ。
513 ：鬱：02/10/04 06:20
あーMFCもままにならないままC#は出るしよお
DirectXはquaternionだしよ、わからねえっつうの
寝転がったままオナーニしたら精子飛び散るしよお
P4ねえからSSE2命令使えねえしデザパタも全然まだだし
かなりやることがあるのに全然消化できてない
鬱だよぉ(=；ω；)
514 ：371：02/10/04 06:35
誰か相手してクリ
>>371
515 ： ( ´-｀).｡ｏＯ(なんでだろう……)：02/10/04 17:35
stlport\config\stl_msvc.hの中の
#define _STLP_NO_USING_FOR_GLOBAL_FUNCTIONS
をコメントアウトしたら、>>448のコードがコンパイルできるようになった。ほっほっほ。
516 ：デフォルトの名無しさん：02/10/04 19:40
テンプレートの引数に応じて、コンストラクタの引数の数を変えることは可能ですか？
template<int N>
struct A
{
　template<int M>
　A();
　template<> A<1>(int x){}
　template<> A<2>(int x, int y){}
　A<N>;
};

A<2> a(1,2);
見たいなことなんですが。
517 ：デフォルトの名無しさん：02/10/04 19:44
>>516
コンストラクタの多重定義、もしくはデフォルト引数では不足なのか？
518 ：デフォルトの名無しさん：02/10/04 19:51
>>517
ベクトルを扱うクラスを自作してるんですが、
内部に持ってる変数をv[N]と定義してるため、
v[1]に対しA(int x, int y)が呼ばれてしまうのは都合が悪いです。
519 ：デフォルトの名無しさん：02/10/04 20:51
WAVEファイルで取り込んだファイルの各瞬間の音の高さを知りたいのですが
なにか方法をご存知ですか？
520 ：黒飴なめなめ♪：02/10/04 21:02
知らん
521 ：デフォルトの名無しさん：02/10/04 21:05
俺も知らん
522 ：デフォルトの名無しさん：02/10/04 22:33
フーリエ変換しる!
523 ：516：02/10/04 23:26
>>517
+継承でそれっぽいのができました。
ありがとうございました。
524 ：デフォルトの名無しさん：02/10/05 00:12
「C言語なら俺に聞け」スレで聞いたのですがC++じゃないか？と言われたので
ここで質問させてもらいます。

人から貰った関数の引数に double *&a というのがあるのですが、これって
どういう意味なんでしょうか？
525 ：デフォルトの名無しさん：02/10/05 00:13
doubleポインタの参照
526 ：デフォルトの名無しさん：02/10/05 00:47
>>525
thx!
527 ：デフォルトの名無しさん：02/10/05 01:41
>>523
還元してください。
528 ：516：02/10/05 02:45
>>527
還元できるほどの大した事はやってないです。
派生先にB(int x) : base(x)、B(int x, int y) : base(x,y)…を用意して
基本クラスにN個とるコンストラクタが無ければエラーが出るようにしただけです。
529 ：デフォルトの名無しさん：02/10/05 04:41
>>528
結果の重要性はともかく、
質問した時と同じくらいの情報が、そんなふうに結論として出ると、
なんとなく収まりがいいもんですな。
530 ：デフォルトの名無しさん：02/10/05 07:24
解決した時に，たとえ自分のくだらないミスであったとしても
きちんと報告するのが良い質問者の姿勢です
531 ：デフォルトの名無しさん：02/10/05 13:49
Linux で C++ を使い始めたのですが、シグナル処理のことで判らない
ことがあるのでお訊きします。

class foo {
...
void A();
void B(int signum);
...
};

void
foo::B(int signum)
{
(シグナル処理)
}

void
foo::A()
{
...
signal(SIGTERM, B);
...
}

というような構成ですと、コンパイル時に
no matches converting function `B' to type `void (*)(int)'
という文句を言われてしまいます。B を class foo の外の
関数にすると何も言われずにコンパイルが通ります。

foo 内だと何故駄目なのかよく判らないのですが...
532 ：デフォルトの名無しさん：02/10/05 13:57
int n;

cin >> n;

cout << n << endl;

aを入力したら,変な数値が出てきたんだけど･･･
なぜに？
533 ：デフォルトの名無しさん：02/10/05 14:02
>>532
単にnの初期化されて無い値がそのままでたんでは？
int n=893;とするとどうよ。
534 ：532：02/10/05 14:04
不正な入力があったら,値が代入されないんですね
535 ：デフォルトの名無しさん：02/10/05 14:11
マニピュレータって覚えています？
あんまり必要なさそうなんで,やりたくないんですが
536 ：デフォルトの名無しさん：02/10/05 14:30
>>535
大抵のマニピュレータは単なるシンタクスシュガーだ。
必要無さそうだと思うならやらなくて良し。


俺は使うけどな。
537 ：デフォルトの名無しさん：02/10/05 14:34
＞５１０
えーと、ハンドルクラスを使うと依存関係が少なくなると
いうのを本を読んだのですが、クラスの数が増えるのと
ややこしくなるため、ほんとにこんなことするのかなって
おもたのです。

＞５１２
どうもありがとうです。
538 ：デフォルトの名無しさん：02/10/05 14:47
>>531
一旦staticメンバ関数あるいは単なる関数で受けないとダメ
539 ：デフォルトの名無しさん：02/10/05 15:29
>>531
http://www.parashift.com/c++-faq-lite/pointers-to-members.html#faq-32.2
540 ：デフォルトの名無しさん：02/10/05 16:27
ファイル exception.h
（ここには例外処理が書いてある）。

ファイル classA.h
#include "exception.h"


ファイル　main.cpp
#include <iostream.h>
#include "classA.h"
#include "exception.h"

みたいな事をしていいのでしょうか？
この場合、exception.hファイルがmain.cppに2回インクルードされていることに
なり、おかしなことになりますか？
何かいい方法があれば教えてください。

また、include等を詳しく説明したサイトがあれば、教えてくれると助かります。
541 ：デフォルトの名無しさん：02/10/05 16:34
>>540
ちなみに、

#include <iostream.h>
#include <iostream.h>

とかやってみな。おかしくなんないだろ ?

<iostream.h> の最初の方に、

#ifndef _INC_IOSTREAM
#define _INC_IOSTREAM

と書いてあるので、上みたいに２回呼ばれた時にこれがどういう動作するのかよく考えましょう。
542 ：デフォルトの名無しさん：02/10/05 16:35
インクルードガードでぐぐる。
543 ：540：02/10/05 16:41
>>541
てことは、exception.hは
iostream.hみたいにうまいこと書かなければ、なにかおかしいってことですか？

>>542
インクルードガードとは？
544 ：540：02/10/05 16:47
インクルードガード。初めて聞きました。
ありがとうございます。
検索して調べて、理解できました。
545 ：デフォルトの名無しさん：02/10/05 16:48
>>543
> インクルードガードとは？

>>542 は、親切にもインクルードガードで「ぐぐる。」って書いてあるんだから、まずはその通りにしたら ?
546 ：　：02/10/05 17:02
じさ
547 ：デフォルトの名無しさん：02/10/05 19:11
>>545
ちょっと遅かったね
548 ：540：02/10/05 21:49
>545
すいませんした。

ついでに、またまたくだらない質問でもうしわけないですが・・・

class Samp
{
private:
int m;
double *p;
public:
Samp(){ m = 0; p = new double; }
Samp(int i) { m = i ; p = new double [i] }
~Samp() { delete [] p }
};

とやった場合、引数なしコンストラクタでのpを開放しようとしたら、

delete p;

となるが、上記のデストラクタでは、なっていない。
これは合法ですか？
549 ：　：02/10/05 22:04
>>548
デストラクタでmで判定してdelete演算子を使い分ける。
もしくはＳＴＬを使う。
550 ：540：02/10/05 22:06
>549
おお！使い分けですか！
単純なことなのに全然気づきませんでした。
ありがとうございます。

STLでうまいことできるんですか。調べてみます。
551 ：デフォルトの名無しさん：02/10/05 22:08
>>548
double なら多分大丈夫だけど、クラスだったりしたらまずいと思う。

まあ、

Samp::~Samp()
{
　if(0 < m){
　　delete [] p;
　} else {
　　delete p;
　}
}

とするか、引数無しの時も m = 1 にして配列を確保してしまうのがいいかと思う。
552 ：デフォルトの名無しさん：02/10/05 22:12
mがnew[]したかnewしたかを記録するためのものとは限らない。
そうしたいならせめてconst bool m;とかにしといてよ。

別にnew[]で統一すればいいのでは？
553 ：552：02/10/05 22:14
あ、mは配列の数なのね。const bool mは無し。
554 ：　：02/10/05 22:23
mが確保したオブジェクトの数ならこうすべきでは？
Samp(){ m = 0; p = null; }
mが１で初期化されるときとｍが０で初期化されるときで
オブジェクトの個数が同じく一つであることに問題が生じる
可能性があるかも。
555 ：554：02/10/05 22:26
または、
Samp(){ m = 1; p = new double[1]; }
556 ：540：02/10/05 22:40
>551
>552
ご意見ありがとうございます。

クラスならまずいということですが、次の場合はどうなんでしょう。

class Array{
private:
int m;
double *p;
public:
Array(){ m = 0; p = NULL }
Array( int i ) { m = i; p = new double [i] }
~Array(){
if( p != NULL) { delete [] p }
}
}

class ArrayDX{
private:
int m;
Array *p;
public:
ArrayDX( int i ){ m = i; p = new Array [i] }
~ArrayDX(){delete [] p}
}

何かいろいろし、ArrayDXのインスタンスを作成し、
メンバのArrayの配列もきちっと作成する。
の場合。ArrayDXでインスタンスを作成し、破棄したら、メンバのArray *pの
デストラクタはきちっと行われるのでしょうか。
557 ：デフォルトの名無しさん：02/10/05 22:52
>>556
> ArrayDXでインスタンスを作成し、破棄したら、メンバのArray *pの
> デストラクタはきちっと行われるのでしょうか。

delete [] p; なら行われる。

つーか、new [] で確保したら delete [] するのが基本。
double で多分大丈夫と言ってるのは、大方の実装が大丈夫そうだからと言うだけのこと。
規格上はまずいよ。
558 ：540：02/10/05 22:56
>>556
ありがとうございます。

それは、オブジェクトポインタがスコープからはずれたら、
デストラクタが呼ばれて、そのなかにあるオブジェクトポインタ
のデストラクタもよばれて・・・・でいいのでしょうか？
559 ：デフォルトの名無しさん：02/10/05 23:02
>>558
> >>556
> ありがとうございます。

自分に礼かよ !! と言う突っ込みは置いといて...

> それは、オブジェクトポインタがスコープからはずれたら、
> デストラクタが呼ばれて、そのなかにあるオブジェクトポインタ
> のデストラクタもよばれて・・・・でいいのでしょうか？

オブジェクトとポインタ って ? よくわかんないけど、

void foo()
{
　ArrayDX X(100);
　...
}

で、foo() の終了時のこと言ってるなら、その通り。
560 ：デフォルトの名無しさん：02/10/05 23:04
>>558
スコープから出れば「オブジェクト(を指している)ポインタ」のデストラクタは呼ばれるが、
「オブジェクトポインタの指すオブジェクト」のデストラクタは呼ばれない。
561 ：531：02/10/05 23:12
>>538-539
どうも有り難うございます。FAQ なんですね。適当な C++ の本を買って
きて手許に置いたほうがいいのでしょうかね。
562 ：540：02/10/05 23:13
>>559
あ・・・。ほんとだ、自分に・・・

>>559
>>560
ってことは

void foo()
{
ArrayDX *X = new ArrayDX(100);
...
delete [] X;
}

の場合は正確でしょうか？

すんません。おなじようなことばっかで
563 ：デフォルトの名無しさん：02/10/05 23:23
>>562
X は配列を指していない。
この場合は
delete X;
が正しい。
564 ：デフォルトの名無しさん：02/10/05 23:57
いい加減STLの使用をデフォルトにしようぜ。
必要なところだけ自分でメモリ管理すればいいじゃん。
Cでいちいち標準関数再実装してるようなバカがいないのを見習おう。
565 ：デフォルトの名無しさん：02/10/06 01:32
double* p = new double [0];

NULLじゃないけどアクセスできないポインタ・・・鬱だ
566 ：デフォルトの名無しさん：02/10/06 01:55
>>565
しかも、使えないのに delete[] p; としないとメモリリークになる。
なお鬱だ・・・・
567 ：デフォルトの名無しさん：02/10/06 01:57
スマソ。pに何か別のポインタを代入しない限りメモリリークとは
言わないんですた。

解放し忘れとでも言うのかな。
568 ：デフォルトの名無しさん：02/10/06 01:59
解放し忘れとメモリリークの違いを小一時間ほど講義していただきたい
569 ：デフォルトの名無しさん：02/10/06 02:01
参加希望者ですが、
講義の場所と日時と費用を教えてください。
570 ：デフォルトの名無しさん：02/10/06 02:08
>>565
そうなの？？？
571 ：デフォルトの名無しさん：02/10/06 02:30
>>568
小一時間も解説するほどではないが。Effective C++にしつこいほど
繰り返し書いてある。

簡単に説明するとすれば、ある領域を指しているポインタがあり、いつ
でも解放できる状態であればメモリリークとは言わないらしい。

有効なポインタが他の値を代入することによって、その元のポインタ
が指していた領域を解放する手段が永久的に失われてしまった時、
初めてメモリリークと言うそうだ。
572 ：デフォルトの名無しさん：02/10/06 02:39
配列の添字にマイナスが使えるようにする方法ってありませんか？
573 ：デフォルトの名無しさん：02/10/06 02:41
>>571
で、解放し忘れとの違いは・・・
574 ：デフォルトの名無しさん：02/10/06 03:05
>>573
解放し忘れであれば、deleteを書いてやればよい。しかし、メモリリークが
起きたポインタをdeleteすると、何が起きるかわからない。
575 ：デフォルトの名無しさん：02/10/06 03:06
>>572
operator[] をオーバーロード。配列はクラスにする。
576 ：デフォルトの名無しさん：02/10/06 03:07
>>574
自己レスです。「メモリリークが起きたポインタをdeleteしても、解放できない。」
でした。
577 ：デフォルトの名無しさん：02/10/06 05:55
>>574意味がサッパリ。
578 ：デフォルトの名無しさん：02/10/06 08:15
>>577
俺はなんとなく分かったけど…。
579 ：デフォルトの名無しさん：02/10/06 08:26
>>578
deleteできないならもう開放済みなんじゃ？
580 ：デフォルトの名無しさん：02/10/06 09:18
>>579
例えばの例。

char* p = new char[100];
p = 0;

pが指していたchar[100]の領域は、p = 0; とすることによって恒久的に
解放できなくなった。
581 ：デフォルトの名無しさん：02/10/06 10:13
>>580
それ自体をメモリリークといいます
582 ：デフォルトの名無しさん：02/10/06 10:17
ああ、「解放し忘れ」は行為で「メモリリーク」は状態か
583 ：デフォルトの名無しさん：02/10/06 10:18
>>581
だからそう言っているのでは？
584 ：デフォルトの名無しさん：02/10/06 10:20
char* p = new char[100];
// ここは（ある意味）開放し忘れ
…
…
p = 0; // この瞬間からメモリリーク

ということなのだと思われ。
585 ：デフォルトの名無しさん：02/10/06 10:23
こう書けばいいかな？

char* p;
{
　　p = new char[100];
}
// 開放し忘れ

---------------------------

{
　　char* p = new char[100];
}
// メモリリーク
586 ：デフォルトの名無しさん：02/10/06 10:24
インスタンスとオブジェクトの違いって何ですか？
587 ：デフォルトの名無しさん：02/10/06 10:25
何度もすまん。
開放→解放
588 ：デフォルトの名無しさん：02/10/06 10:45
>>586
インスタンスはクラスから生成されるもの
オブジェクトはクラスやインスタンスの総称
589 ：デフォルトの名無しさん：02/10/06 10:56
>オブジェクトはクラスやインスタンスの総称

ほんと？
590 ：デフォルトの名無しさん：02/10/06 11:03
objectとinstanceを英和辞典で引けば自ずとわかるかと。
591 ：デフォルトの名無しさん：02/10/06 11:20
違ってたら恥ずかしいんだけど
クラスは「クラスというオブジェクト」という意味でしょうか？
お馬鹿な俺に教えてちょ。
592 ：デフォルトの名無しさん：02/10/06 11:27
>>591
お！そこまで想像できるなら問題ないのでは。
JavaとかC#とかを触るとクラスもオブジェクトだなーというのが
実感できまっせ。
593 ：デフォルトの名無しさん：02/10/06 11:32
インスタンスはメモリ上に確保されたオブジェクトの実態。
これであってる？
594 ：デフォルトの名無しさん：02/10/06 11:38
>>593
誤解を恐れずに言うと、クラスはインスタンスの工場で、
生成されたインスタンスがどんなものかを全部しってる。

メモリに確保されるかどうかは言語や処理系次第ッス
595 ：デフォルトの名無しさん：02/10/06 12:18
>>592
あ，合ってるんですか。嬉しいです。
C++だけの時はオブジェクト＝インスタンスだったんですけど
Reflection触ってから>>591と思うようになったのです。
596 ：デフォルトの名無しさん：02/10/06 12:34
>>594
メモリ上に確保されないインスタンスとは具体的に
どんなやつ？
597 ：デフォルトの名無しさん：02/10/06 12:45
ある本でこんな説明を見たことがある

生地からドーナツを切り抜くところを連想してください。
この場合、生地がメモリ。
ドーナツを切り抜く型がクラス。
切り抜かれた部分そのものがインスタンス。
切り抜かれた部分にドーナツと名前を付けました、名前であるドーナツが
オブジェクト。
598 ：デフォルトの名無しさん：02/10/06 12:46
ポリフォーリズムについて
これって何？
599 ：デフォルトの名無しさん：02/10/06 12:48
>>596
(;´Д`)いやその・・・この手の話って
クラスにしろインスタンスにしろ、操作にたいする振る舞い、あるいは
それらどうしの関係についての話でしかないですヨ。

どのように実装するかについては各言語あるいはフレームワークで決めていただくと。
lisp系ならクラス定義もcell内の情報だろうし(違うかも)、
C++だとクラスそのものは実体が確保されないこともあるわけで。
600 ：デフォルトの名無しさん：02/10/06 12:50
ポリフォーリズムに萎え
601 ：ミッターマイヤー：02/10/06 13:32
C++でデザパタのファクトリーメソッドってどうやるのですか？
デザパタ本はJavaばっかりなので、わかりません。
既出だったらごめん。
602 ：デフォルトの名無しさん：02/10/06 14:32
>>597
最後の一行だけ嘘っぽい・・・
603 ：デフォルトの名無しさん：02/10/06 16:00
ポリフォーリズムage
604 ：デフォルトの名無しさん：02/10/06 16:00
int data(int a,int b);
int data(int a, int b,int c=100);

data(100,200);

どうなりますか？
605 ：デフォルトの名無しさん：02/10/06 16:15

[]演算子はオーバーロードできますが

double ClassA::operator[][](int i, int j)
ってできますか？

もしくはそれに類するクラスを2次元配列のように
あつかう方法とかありますか？
606 ：デフォルトの名無しさん：02/10/06 16:16
>>604
どっちを呼び出せばいいかわからないから、コンパイルエラーになる。
607 ：デフォルトの名無しさん：02/10/06 16:16
失敗するとゼロ、成功するとゼロ以外が返ってくる事がわかっている関数の返値で
（例えば文字列中にある文字が存在するか調べる関数）
失敗したかどうか条件判断を行いたい場合、比較とビット反転とどちらがスマートなんでしょうか？

int result = hoge(arg);
if (!result) cout << "ERROR" << endl; //ビット反転と
if (result == 0) cout << "ERROR" << endl; //比較
608 ：デフォルトの名無しさん：02/10/06 16:22
>>607
==0 のほうがスマート
失敗すると偽、成功すると真が返ってくる関数なら ! のほうがスマート
609 ：デフォルトの名無しさん：02/10/06 16:24
>>607
ビット反転演算子は、'!' じゃないよ、'~' だ。'!' は、論理否定演算子。

[A] > if (!result) cout << "ERROR" << endl; //ビット反転と
[B] > if (result == 0) cout << "ERROR" << endl; //比較

俺なら、成功した時の戻り値が数値的な意味をもっている (例えば文字列中にある文字が存在するか調べる関数で、成功した時は何文字目かを返すとか) なら、[B]
そうでない (単純に成功/失敗しか返さない) なら [A] でコーディングする。

まあ、好みの範疇だと思うよ。
610 ：デフォルトの名無しさん：02/10/06 16:26
>605
二次元までで良いなら、今既にある配列クラスを
その配列クラスを返す[]演算子を持ったクラスで包む

class node　//既にある配列クラス
{
　詳細略
　double operator[](int index);
};

class MyArray　//既にある配列クラスを包括する二次元配列クラス
{
　詳細略
　node& operator[](int index);
　node m_node;
};


>605でやりたかったであろうアクセスを行うと、以下のように解釈される

MyArray[1][5]　→　(node)[5]
611 ：605：02/10/06 16:28
>>610
なるほど。ありがとうございます。

自己解決ですが、こんなんありました。

()演算子をオーバーロードする。
operator()(int i, int j)

こんな感じ
612 ：デフォルトの名無しさん：02/10/06 17:22
「かならず継承してから使って欲しいクラス」ってC++的に書けますか？
デフォルトの振る舞いとかは全部あるんですけど、
絶対に包括じゃなくて継承して使って欲しいんです
もちろん基底クラスのメソッドを直コールするのもNGな雰囲気で・・・

無理なら無理でOKです
613 ：デフォルトの名無しさん：02/10/06 17:25
>>612
コンストラクタをprotectedにする
614 ：デフォルトの名無しさん：02/10/06 17:29
>>612
純粋仮想関数を基底クラスで作る。
615 ：デフォルトの名無しさん：02/10/06 17:29
無料掲示板http://gooo.jp
616 ：デフォルトの名無しさん：02/10/06 17:30
>>612
class ダミー派生クラス : public 直接使われたくない既定クラス {};


ダミー派生クラス obj;
obj.結局直接呼ばれる既定クラスのメソッド();

とかされてもOKですか？
617 ：デフォルトの名無しさん：02/10/06 17:31
>>613
それだと
class Test :public base
としたとき
Test->base::hoge()
とかで基底クラスのメソッドを呼べちゃいませんか？
どうしてもTest->hoge()とさせたいんです

かといって、virtual base::hoge() = 0; では困るんです
618 ：デフォルトの名無しさん：02/10/06 17:32
>616
そうですそうです
結局基底クラスが呼ばれていようと、派生クラスのメソッドにアクセスしてるように見えたいのです
619 ：デフォルトの名無しさん：02/10/06 17:33
>>617
注文の理由が訳ワカメ。
620 ：デフォルトの名無しさん：02/10/06 17:39
インターフェースと実装を分離すればいいんじゃない？
621 ：デフォルトの名無しさん：02/10/06 17:39
>>617
Test->hoge();は桶で
Test->base::hoge();は駄目か・・・

全部のメソッドをprotectedで継承して
派生クラスでpublicなラッパを提供するしか漏れには考え付きませんが。
622 ：612：02/10/06 17:41
class Base
{
public:
　int hoge() {return 1};
};

class Test :public Base
{

};

int main (){
　Base A; //これはコンパイルエラーにしたい
　Test B;
　cout << B.Base::hoge(); //これもコンパイルエラーにしたい
　cout << B.hoge(); //これはSTDOUTに1を流したい
}

ということです
623 ：612：02/10/06 17:42
やっぱりかなり強引なことをしないと無理っぽいですか・・・
まだ設計段階なので無理なら無理でOKなんです
624 ：デフォルトの名無しさん：02/10/06 17:45
クラスで、標準ライブラリの iterator(反復子）のように
*演算子関数を定義したとき、その演算子関数の戻り値のメンバに
-> を使ってアクセスすることは、可能ですか？

class X
{
public:
int m_x;
};

class Y
{
public:
X m_y;

X& operator*() { return m_y; };
};

Y y;

(X&) *y; //普通にアクセス ○
(*y).m_x; // X のメンバ にアクセス。○

y->m_x; //こういう書き方は可能 ？
625 ：デフォルトの名無しさん：02/10/06 17:46
>>612
そういう設計にせにゃならない理由を是非お伺いしたいであります。
626 ：デフォルトの名無しさん：02/10/06 17:46
>>624
無理じゃないかな・・・operator ->()が別にあるし
627 ：デフォルトの名無しさん：02/10/06 17:49
>>623
> やっぱりかなり強引なことをしないと無理っぽいですか・・・
> まだ設計段階なので無理なら無理でOKなんです

何でそんなことが必要なん ?
628 ：612：02/10/06 17:53
>>625,>>627
自由度を狭める事で、逆にインターフェースを簡潔にできないかという目論みです
カスタマイズされることが大前提のクラスなので、なんでもできてしまうのはちょっと困るのです
629 ：デフォルトの名無しさん：02/10/06 17:56
>>626
なるほどー
ありがとうございました。
630 ：デフォルトの名無しさん：02/10/06 18:02
>>628
> カスタマイズされることが大前提のクラスなので、なんでもできてしまうのはちょっと困るのです

そのわりには、「結局基底クラスが呼ばれていようとも...」なの ?

一体誰から何を守りたいのかよく考えた方がいいと思うよ。
631 ：デフォルトの名無しさん：02/10/06 18:04
class TestImpl{
public:
int hoge(){ return 1;}
virtual void LONGLONG_MEANLESS_FUNCTION() = 0;
}
class Test : protected TestImpl{
public:
virtual void LONGLONG_MEANLESS_FUNCTION() {};
};
で、Testを継承させるのはどうだ。
632 ：デフォルトの名無しさん：02/10/06 18:05
カオスヘッダーから地球を守るにきまっとるだろうがヴォケが！
633 ：デフォルトの名無しさん：02/10/06 18:05
>>630
多分

class Test : public Base
が、後々の変更で
class Test : public CustomizedBase
になる可能性もあるから、
直接
pTest->Base::hoge();
とかやられると、
基底クラスを変更したときに困る、とかじゃないかな
634 ：デフォルトの名無しさん：02/10/06 18:06
あ、純粋仮想ﾒｿﾄﾞの名前は、
THIS_CLASS_CANT_BE_INHERITED_DIRECTLY()
とかの方がいいかな。
635 ：デフォルトの名無しさん：02/10/06 18:07
> 基底クラスを変更

ｶﾞｸｶﾞｸﾌﾞﾙﾌﾞﾙ
636 ：612：02/10/06 18:15
>>630
誰からかは不明瞭ですが、守りたいのは「簡潔さ」です
「利用者の大半がカスタマイズするだろうし、もしかしたら自分もそのうちカスタマイズするかもしれんから
とりあえず継承しておけ」というクラスなんですが
かといって、「とりあえず継承はしたけど、どうせここは基底クラスを使ってるんだからTest->Base::hoge();でいいや」
とやられないようにしたい
後で結局カスタマイズした場合に、その部分を直し忘れてエラーになったりしないように

もちろん>>633みたいな怖ろしい事は考えていません
637 ：デフォルトの名無しさん：02/10/06 18:18
>>631
そっちの話 (かならず継承してから使って欲しいクラス) は、>>613 で OK だと思う。
問題は、「基底クラスのメソッドを直コールするのもNG」の方だろ。

>>632
話の内容についてこれないなら書き込むな、ヴォケ。

>>633
クラスの仕様書に、「直コールは止めてくれっ。｣と書いておけば、規定クラス名が変更された時に困るのは変なことしてる奴なんだから別にいいと思う。
どっちにしても、基底クラス名を変更したら継承している所は修正しないといけないしね。
そもそも、基底クラス名なんてそんな簡単に変更しないと思う。
638 ：633：02/10/06 18:22
まぁ、普通のクラスで基底クラスを変更するのはまれだろうけど、
Modernなtemplateプログラムしてると当たり前のように基底クラスは変わるよ。
あんまり怖がりなさるな、おのおの方。
639 ：デフォルトの名無しさん：02/10/06 18:23
＞637
「基底クラスのメソッド直コール」ってのは
＞　cout << B.Base::hoge(); //これもコンパイルエラーにしたい
ってことだろ。
なら、
class Test : protected TestImpl{
640 ：デフォルトの名無しさん：02/10/06 18:24
あ、BaseとTestを間違えてたな。
class BaseImpl{...};
class Base : proteced BaseImpl{...};
class Test : public Base {...} ;
ってことで。
641 ：デフォルトの名無しさん：02/10/06 18:34
>>638
> Modernなtemplateプログラムしてると当たり前のように基底クラスは変わるよ。

だから ? template 使ってるって自慢 (にもなってないけど) したいだけなのか ?
642 ：612：02/10/06 18:38
すみません、雲行きが怪しくなってきたので「多重継承とかしないと無理」って事で諦めます
何か修飾子付けるだけとか簡単な解決方法はあるのかなーと思っただけですので・・・
643 ：デフォルトの名無しさん：02/10/06 18:38
>>641
635と636が怯えてるから、よくあることだと書いたまでですが
644 ：デフォルトの名無しさん：02/10/06 20:36
おまいら、CppUnitとか使ったりしてますか。
645 ：デフォルトの名無しさん：02/10/06 20:48
CppUnit+cocuppaこれ最強。
646 ：デフォルトの名無しさん：02/10/06 22:59
3次元配列の領域を動的に確保する方法を
知っている方教えて下さい。お願いします。
647 ：デフォルトの名無しさん：02/10/06 23:16
>>646
double*** p;

p = new double**[10];
for (int i = 0; i < 10; i++) {
p[i] = new double*[20];
for (int j = 0; j < 20; j++)
p[i][j] = new double[30];
}

double[10][20][30] が使える。
648 ：デフォルトの名無しさん：02/10/06 23:22
>>646
もう少し簡単な方法。

double (*d)[20][30];

d = new double[10][20][30];
649 ：646：02/10/06 23:27
>>647
有難うございます。
2次元配列と同じ感じなんですね。
やはりポインタの理解が足りないな…
650 ：デフォルトの名無しさん：02/10/06 23:28
すまん…ﾈﾀだと思ってた（鬱
651 ：デフォルトの名無しさん：02/10/06 23:33
ここはC++スレですので、C++らしい解決をお願いします
652 ：デフォルトの名無しさん：02/10/06 23:44
vector< vector< vector< double > > >か？
template< int N > class Nd_vector;を自作する話か？
653 ：デフォルトの名無しさん：02/10/07 00:12
std::string の操作についてお聞きしたいのですが、

char hoge[10] = { ... };
string s( 10, '\0' );
memcpy( &s[0], hoge, 10 );

というのは有効な操作ですか? 有効である場合、これは

s.assign( hoge, 10 );

と同じ効果が得られるでしょうか。
654 ：デフォルトの名無しさん：02/10/07 00:22
>>653
なんか2ちゃんでもcppllでもそんな話題ばかり見かけるなぁ。
なんでmemcpyなんてしたいんです?

> char hoge[10] = { ... };
なぜに { } なんだと小一時間…

655 ：デフォルトの名無しさん：02/10/07 00:25
>>653
memcpyした場合の結果は保証されません。
push_backもしくはback_inserterを使うようにしましょう。
656 ：デフォルトの名無しさん：02/10/07 00:34
やはりstd::vector使った方が楽でいいや。operator[]をオーバーロード
して多次元配列のクラス作ろうとしたけど、よくわからん。

std::vector<std::vector<std::vector<double> > > v;

v.resize(10);
for (int i = 0; i < 10; i++) {
v[i].resize(20);
for (int j = 0; j < 20; j++)
v[i][j].resize(30);
}

for (int i = 0; i < 10; i++)
for (int j = 0; j < 20; j++)
for (int k = 0; k < 30; k++)
v[i][j][k] = i * 600 + j * 30 + k;

for (int i = 0; i < 10; i++)
for (int j = 0; j < 20; j++)
for (int k = 0; k < 30; k++)
std::cout << v[i][j][k] << ' ';
657 ：デフォルトの名無しさん：02/10/07 00:36
せっかくsize()メンバ関数があるのだから、このように書いた方がいいな。

v.resize(10);
for (int i = 0; i < 10; i++) {
v[i].resize(20);
for (int j = 0; j < 20; j++)
v[i][j].resize(30);
}

for (int i = 0; i < v.size(); i++)
for (int j = 0; j < v[i].size(); j++)
for (int k = 0; k < v[i][j].size(); k++)
v[i][j][k] = i * 600 + j * 30 + k;

for (int i = 0; i < v.size(); i++)
for (int j = 0; j < v[i].size(); j++)
for (int k = 0; k < v[i][j].size(); k++)
std::cout << v[i][j][k] << ' ';
658 ：デフォルトの名無しさん：02/10/07 00:40
>>653
memcpyじゃなくてstd::copy
659 ：デフォルトの名無しさん：02/10/07 00:43
非コンストにも使えるfor_eachって欲しくねぇ？
resize一気にかますときとか
660 ：デフォルトの名無しさん：02/10/07 00:47
>>657
vector<vector<vector<double> > > v(10 ,vector<vector<double> >(20, vector<double>(30)));
661 ：デフォルトの名無しさん：02/10/07 00:50
>>659
こんなのはダメなのか？

void square(int& elem)
{
elem *= elem;
}

std::for_each(coll.begin(), coll.end(), square);

標準C++ライブラリp317～318より
662 ：デフォルトの名無しさん：02/10/07 00:51
>>660
へえ～、コンストラクタの結果をクラスの型として返せるのか。初めて知った。
663 ：デフォルトの名無しさん：02/10/07 00:52
boost::multi_array<double, 3> array3d;
664 ：デフォルトの名無しさん：02/10/07 00:53
>>662
どういう意味ですか？
665 ：デフォルトの名無しさん：02/10/07 00:53
>>660
んー勘違いしていました。コンストラクタの結果をコンストラクタに
引き渡しているんですね。
666 ：653：02/10/07 00:55
>>654
つまり、memcpy と同じインタフェースを持つ関数があって、
それを使って string の内容を更新したいということなんです。
いったん、配列なり vector なりで受けてから、それを
string にコピーすればいいんでしょうが、2回コピーすることに
なるのがちょっといやかな、と思ったので。

>>655
s.resize(10) しておいてから memcpy でもだめなんでしょうか。
vector みたいに、&s[0] が配列を指す、という保証はないのかな。
667 ：デフォルトの名無しさん：02/10/07 00:55
>>662
ん？
単に要素の初期化をしてるだけだけど。
668 ：653：02/10/07 01:16
>>655,>>658
ああ、そうか、std::copy なら begin() とか back_inserter() が
返すイテレータを使えるんですね。
やっぱり古くさいインタフェースを持つ関数は捨てて、ちゃんとした
ライブラリを作り直そうかな。
669 ：デフォルトの名無しさん：02/10/07 01:58
コンストラクタにテンプレート使う↓のってOKですか?
class X {
publuic:
template<class T> X(T t){ ... }
};
670 ：デフォルトの名無しさん：02/10/07 02:02
あり
671 ：デフォルトの名無しさん：02/10/07 02:03
>>670
さんくす
672 ：　：02/10/07 02:50
void int_return(const int &rf);

とかいう風にconstつけたりします？
っていうかconstついているようなものか
書いていてそう思いました
673 ：デフォルトの名無しさん：02/10/07 02:53
>>672 一時オブジェクトを渡す可能性があるならconst必須
void hoge(const std::string& str);

...

hoge("this generates temporary obj.");

とかいう話ではなくて?
674 ：デフォルトの名無しさん：02/10/07 03:01
>>673
そうか。
参照は,値を書き換えてもいいんでしたね。
constは,必要か
ポインタで渡すのは,文字列か構造体ですしね
675 ：デフォルトの名無しさん：02/10/07 03:02
>>672
リファレンス渡しは値渡しよりも効率が良いが、呼び出し先で引数に
代入してしまうと呼び出し元の変数まで変更されてしまうので、
constをつけて、値が変わる危険性を避けつつ効率を維持できる。
676 ：デフォルトの名無しさん：02/10/07 03:16
関数の引数ならconstポインタでもいいと思うがなぁ。
677 ：デフォルトの名無しさん：02/10/07 03:18
>>676
呼び出し元で引数に&を付ける必要があるけどな。
678 ：デフォルトの名無しさん：02/10/07 03:20
NULLを渡せないから参照なんて嫌だー！

ってそれがメリットか？
679 ：デフォルトの名無しさん：02/10/07 03:21
>>677
それを言ったら、newしたオブジェクトを参照渡しするときは
*をつけなきゃいけないじゃん。
680 ：デフォルトの名無しさん：02/10/07 03:35
漏れは値渡しの最適化とみなせる場合と例外のcatchの場合、それに
構文上必要な場合(コピーコンストラクタや演算子定義)はconst
参照にして、ポリモーフィズムを使う場合やオブジェクトの同一性
が問題になる時はポインタ渡しにしている。
このくらいが妥当じゃないかなあ。
681 ：デフォルトの名無しさん：02/10/07 05:16
>>680
あと>>678も言ってるけどnullが来ることを許可したい時。
682 ：デフォルトの名無しさん：02/10/07 05:19
>>678
またヌルヌル論争になるから null pointer って書いてくれ
683 ：デフォルトの名無しさん：02/10/07 08:46
>>676-679
演算子のオーバーロードするときに、いちいち
&つけるのかっこ悪いじゃん。
684 ：デフォルトの名無しさん：02/10/07 10:42
漏れも680とおんなじ感じかな。
構造体の場合はほとんど全部"値渡しの最適化"とみなせるのでたいていは参照、
std::stringとかみたいな値重視のクラスも参照、
ポリモーフィックなクラスの場合ポインタ使ってるっぽい。
685 ：デフォルトの名無しさん：02/10/07 21:04
例えば

template<typename value_type>
value_type TypeAdjast(const (void*)& value) {
　return boost::lexical_cast<value_type>(value);
}

int a = 100;
string s;
s = TypeAdjast(a);

みたいにして、関数の返値が格納される先（左辺値）の型に応じて
返す型を変える関数って作れるものなんでしょうか？
686 ：デフォルトの名無しさん：02/10/07 21:08
そもそもC++は
int foo();と
string foo();は同時に存在できなかったはずだけど、、
687 ： ：02/10/07 21:25
>>685
s = TypeAdjast<string>(a) のように呼べば作れるけど、
そういうことじゃないよね？
688 ：デフォルトの名無しさん：02/10/07 21:35
>>687
やっぱりそうなりますか・・・

テキストで保存してあるデータを
型に合わせてロードする関数を考えているんですが
std::string LoadDataAsStr();
int LoadDataAsInt();
unsigned int LoadDataAsUInt();
：
：
みたく型毎に関数用意したり、とか
やたら型キャスト使ったり、とかが鬱陶しいので
できるだけスマートに書けるようにしたいのであります

やっぱり左辺値の型情報を渡して
それに合わせてロードするようにするのが一般的ですか
689 ： ：02/10/07 21:45
>>688
TypeAdjast(s, a) とすればいいんじゃ？
adjastってのもかなりかっこ悪いが。
690 ： ◆hMJAPH9PWA ：02/10/07 21:54
>>688
IOStream風でいいじゃん。

class mystream;

template <typename Target>
mystreamr& operator >>(mystream& s, Target& target)
{
// ...
return s;
}

void f(mystream& s)
{
int i;
std::string str;
s >> i >> str;
}
691 ：デフォルトの名無しさん：02/10/07 22:26
１|　10
２|　test string
３|　5.003

というデータに対して

string s1 = GetData(１行目);
string s2 = GetData(２行目);
int a = GetData(１行目);
float f = GetData(３行目);

としたときに

s1 = "10"
s2 = "test string"
a = 10
f = 5.003f

とできるようなGetData()の実装は「無理」って事ですか？
もちろん

int b = GetData(２行目);

は「危険なキャスト」として例外投げてかまわないんですが・・・
692 ：デフォルトの名無しさん：02/10/07 22:34
>>691
危険なキャストっていうか、「不可能なキャスト」と決めつけてしまってもOKなわけですが
693 ：デフォルトの名無しさん：02/10/07 22:37
GetDataの戻り値をVariantな型にして、
そのVariantな型から各型へのキャストを
書けば、実現できるかも。
つまり、
class Variant { string data;
public: operator int(){ ...}
operator double(){ ...}
};
で、Variant GetData(int line);とか。
694 ：デフォルトの名無しさん：02/10/07 22:47
なぜNULLを「ぬる」と読むのかさっぱりわからない。
ずっと「なる」だと思っていたし、周りに聞いてもみんなそう言う。
「ぬる」はここへ来て初めて知った・・・ドイツ系の人が広めたのでしょうか？
695 ：デフォルトの名無しさん：02/10/07 22:48
↑ネタですぅ
696 ：デフォルトの名無しさん：02/10/07 22:48
>>693
ごめんなさいわかりません・・・
最終的な利用方法は
string s = (int)GetData(１行目)
ということですか？

この関数の目的の大部分は、キャストしないで利用できるようにすることなので
もし上記のようなら無理に１つの関数にまとめる必要は無いのです・・・
697 ：デフォルトの名無しさん：02/10/07 22:49
>>694
NULLの所へback_inserterと読みます。
「ぬるぬるの所へバックから差し込む」
698 ：デフォルトの名無しさん：02/10/07 22:51
694の想像力 = NULL;
699 ：デフォルトの名無しさん：02/10/07 22:52
おれはNumberをヌムバーと読んでいる。
700 ：デフォルトの名無しさん：02/10/07 22:56
>>699
「ぬむべる」の間違いでは？
701 ：デフォルトの名無しさん：02/10/07 23:05
＞696
せめてこれくらいのテストはしてから、そういうことを言ってほしい。

#include <stdio.h>
struct Variant{
　operator int() { return 1;}
　operator double() { return 2.0;}
};
int main(){
　Variant v;
　int i = v;
　double d = v;
　printf("%d, %f", i, d );
}
702 ：デフォルトの名無しさん：02/10/07 23:05
一生懸命考えて必死に質問してるのに
クソどうでもいいレスに流されるとホント腹が立つ





はっ・・・漏れの質問も同じくらいどうでもいいのか・・・
703 ：デフォルトの名無しさん：02/10/07 23:05
>>700
すげー
704 ：デフォルトの名無しさん：02/10/07 23:07
>>702
申し訳ない。ところで君の質問はどれよ。
705 ：デフォルトの名無しさん：02/10/07 23:08
>>701
おお・・・すみません・・・

ということは、それくらい明らかな実装だと
既に標準ライブラリや準標準ライブラリに
同じ様な汎用型に関する取り扱いがあったりはしないのですか？

「自分のコードが一番信用できない」ってのがポリシーなので
既にあるならそっちを使いたいです
706 ：デフォルトの名無しさん：02/10/07 23:10
>>704
>>685からの一連のヤツです・・・
707 ：デフォルトの名無しさん：02/10/07 23:14
>>706
すでに>>690までで解決しているのかとおもてた。
708 ：デフォルトの名無しさん：02/10/07 23:15
>>706
ちゃんと流されずに詳しい人にレスもらえてるじゃん。
おれはパスだが、、
709 ： ：02/10/07 23:26
>>693
つーことは、

class GetData {
　const char *s;
public:
　GetData(const char *s_) : s(s_) {}
　operator int() const {return boost::lexical_cast<int>(s);}
　operator float() const {return boost::lexical_cast<float>(s);}
　operator double() const {return boost::lexical_cast<double>(s);}
　operator const char*() const {return s;}
　//operator std::string() const {return boost::lexical_cast<std::string>(s);}
　// 以下省略
};

とかやっておけば、

int i (GetData("123"));
double j (GetData("234"));
std::string k (GetData("345"));

てな感じで呼べるわけやね。
710 ：デフォルトの名無しさん：02/10/07 23:29
ややこしくなってまいりました・・・
じっくり理解して実装してみます
ありがとう
711 ：デフォルトの名無しさん：02/10/07 23:35
なぜそこでテンプレートを思いつかないかなぁ。

template<class T>
operator T() const { return boost::lexical_cast< T > ( s ); }
712 ： ：02/10/07 23:41
>>711
通らないタコなコンパイラがあるんだからしょうがないだろ。
713 ：デフォルトの名無しさん：02/10/07 23:47
＞712
boostは通るのに、711のテンプレートは通らないと？
714 ： ：02/10/08 00:03
>>713
なんといってもVC++だからな。VC6だと全く動かないコードになら
コンパイルできるが、VC7はコンパイルさえ通らん。
715 ：名無しさん＠Ｅｍａｃｓ：02/10/08 00:04
>>705
>「自分のコードが一番信用できない」ってのがポリシーなので
>既にあるならそっちを使いたいです
ワラタ
716 ：はｔ：02/10/08 00:49
EXEからDLLに関数をエクスポートする場合
双方のライブラリをリンクしなきゃいけないと思うんですが
どうやってライブラリを作るんでしょうか？
717 ：デフォルトの名無しさん：02/10/08 00:54
BCB なら、コマンド・ラインから、
implib hoge.dll
718 ：デフォルトの名無しさん：02/10/08 00:54
>>705
CppUnit をお使いなさい。
719 ：デフォルトの名無しさん：02/10/08 00:56
>>716
C++では名前のマングリングが起こるので、序数で呼び出す方がいいかも
しれない。
どうしても名前で呼び出すには、一度アセンブル出力して、そのラベル名
を書く。
720 ： ：02/10/08 01:12
>>716
最初はリンクでエラーになるが、.libは出来ているという罠。
721 ：デフォルトの名無しさん：02/10/08 01:16
そういう時は素直にGetProcAddressつかおうよ
722 ：デフォルトの名無しさん：02/10/08 01:27
class variant {
public:
　variant(const std::string& in_value) :value(in_value) {}
　~variant() {}
　operator const char*() const { return value.c_str(); }
　template <typename value_type>
　operator value_type() const {
　　return boost::lexical_cast<value_type>(value);
　}
private:
　const std::string value;
};

variant GetData(データ格納先) {
　return variant(データ);
}

という実装を試してみたんですが

int a = GetData(データ格納先); // safe
string s = GetData(データ格納先); // abnormal termination
const char* lpstr = GetData(データ格納先); // lexical_cast内部でコンパイルエラー

となってしまいした・・・
引数の場合はテンプレートに対して型を明示してやればオーバーロードできたのですが
キャストオペレータ（て言うのかな）の場合はうまく特殊化できないようなのです
なにか解決策はありますか？

環境はBCC5.5.1+BCC添付のSTL+BOOST1.28
723 ： ◆hMJAPH9PWA ：02/10/08 01:45
ソースを見れば分かるけど、lexical_castでポインタ型には変換できないよ。

//少しだけ簡略化してます
template<typename Target, typename Source>
Target lexical_cast(Source arg)
{
std::stringstream interpreter;
Target result;
if(!(interpreter << arg) || !(interpreter >> result) ||
!(interpreter >> std::ws).eof())
throw bad_lexical_cast();
return result;
}

メモリを確保していないchar*型の変数resultには代入できないからね。

解決策はoperator char*()を定義して中でnew[]すればいいんだけど、
operator char*()を(暗黙的でも)呼び出した場合に必ずdelete[]しなきゃいけないのは大変だから、
std::stringだけ使っておくってのが正解かもね。
724 ：デフォルトの名無しさん：02/10/08 01:55
>>723
それは理解しています（というか身を以て体感しました・・・）
なので、>>722の５行目で

　operator const char*() const { return value.c_str(); }

として、ポインタを要求された場合はvalueの直データを渡すようにさせたいのですが

　const char* lpstr = GetData(データ格納先);

と明示的にconst char*型を要求しても、テンプレートが適用されてエラーになってしまう
という問題です
さらに具合が悪いことに、

　operator std::string() const { return value; }

としても、やはりテンプレートが適用されてしまいます

どうしたらいいんでしょうか・・・
725 ：デフォルトの名無しさん：02/10/08 01:56
ちなみに今boost::anyで実装できないか試していて更に混乱中・・・
726 ：デフォルトの名無しさん：02/10/08 01:57
>>724
template<> char const* operator char const*() const{ return value.c_str(); }

とかでできない？想像だけれども
727 ：デフォルトの名無しさん：02/10/08 02:06
>>726

　エラー E2036: 変換演算子には戻り型を指定できない

コンパイラがおっしゃる意味を理解できないのがツライ・・・
728 ：デフォルトの名無しさん：02/10/08 02:10
>>727
わぉ
すまんすまん
template<> operator char const*() const{ return value.c_str(); }
729 ：はｔ：02/10/08 02:10
>>721
たとえばEXE の中で
void Func(int,int);
と宣言されてたら、
void (*PFunc)(int,int);
と宣言して
PFunc = (void (*)(int,int))GetProcAddress( naninani , "Func");
とする。

こんなんですか？
730 ：デフォルトの名無しさん：02/10/08 02:22
いいえちがいます
731 ：デフォルトの名無しさん：02/10/08 02:23
>>728
ダメです・・・template<typename value_type>が適用されまする・・・
732 ：デフォルトの名無しさん：02/10/08 02:27
そういうテンプレートの使い方をしてはいけないコンパイラだったと
諦めて、 operator long() ... operator char()... operator double()...と
列挙するとか。コンパイラ代えてみるとか。
733 ：デフォルトの名無しさん：02/10/08 02:30
>>729
__stdcall
734 ：デフォルトの名無しさん：02/10/08 02:31
>>729
どうするかは場合によりけりだと。

俺はDLLをプラグインとして使うことが多いから、
DLL内の関数はEXE側がGetProcAddressを使って自力で取得、
その関数を経由してEXE側の関数をEXEに渡す、てのをよく使う。

個々の関数をいちいちGetProcAddressすんのは面倒だから、
エクスポートすんのは、DLLの全機能を提供するクラスのインスタンスを返す関数ひとつだけにして、
あとはそのインスタンス経由でいろいろするのが楽。
735 ：デフォルトの名無しさん：02/10/08 02:32
>>732
了解しました・・・
型列挙で対応します
（BCCタダで使わせてもらってるから文句は言えない・・・）
736 ：デフォルトの名無しさん：02/10/08 02:38
VCなんで試せませないのと、boostわからんのでLokiですが、

template<typename T>
operator T()
{
　return Loki::TypeTraits<T>::isPointer ? spec_ptr<T>() : boost::lexical_cast<T>(value);
}

template<typename T>
T spec_ptr()
{
　return 云々;
}

のようにエラー起きるのだけ特化させるのはどうですか？
737 ：736：02/10/08 02:58
×　VCなんで試せませないのと
○　VCなんで試せないのと

boostだと、
template<typename T>
operator T()
{
　return boost::is_pointer<T>::value ? spec_ptr<T>() : boost::lexical_cast<T>(value);
}
ですかね。
738 ：デフォルトの名無しさん：02/10/08 03:03
あら・・・タイプトレイツって実行時に判断できるんですか・・・
コンパイル時チェックだと思いこんでた
739 ：736：02/10/08 03:23
>>738

コンパイル時チェックですが、関数もテンプレートなので･･･
なので、コンパイル後条件式は消えます
740 ：デフォルトの名無しさん：02/10/08 03:23
おまいら、C++でなにつくってるんだ？
741 ：デフォルトの名無しさん：02/10/08 03:41
>>739
三項演算はマクロじゃないので実行時に判断されませんか？
742 ：デフォルトの名無しさん：02/10/08 04:10
三項演算は定数扱う限りはOKだと思うけど。
743 ：デフォルトの名無しさん：02/10/08 10:21
>740
自己を満足させる心
744 ：デフォルトの名無しさん：02/10/08 12:47
デストラクタで delete 処理するのはいいのですが、割り込み等などで
終了させられた場合、メモリはちゃんと解放されるのでしょうか
745 ：名無しさん＠Ｅｍａｃｓ：02/10/08 13:07
>>744
SIGKILLのことですか？
だとしたらOSがメモリを強制的に開放するんじゃなくて？
746 ：744：02/10/08 14:16
>>745
すみません、環境を書いていませんでしたね。おっしゃるとおり UNIX 系での
シグナルを想定していました。

やはり OS が解放してくれるのでしょうか。そうでないと安心できない気がしますが。
C で書いていた頃はそうでもなかったのですが、C++ で書くようになって気になり
始めました。自動的にデストラクタを呼んでいるわけでもなさそうですし。

あるクラスのインスタンスを一つ生成し、それがイベントループを廻し続けるような
プログラムを書いているのですが、この場合デストラクタが呼ばれることがあるので
しょうか。
747 ：デフォルトの名無しさん：02/10/08 14:17
メモリリークなんてなぁプロセスが終了しちまえば一発で解決なんだぁよ
制限がキツイとか常駐ソフトとかでもないかぎりあんま気にすんなぁ
748 ：名無しさん＠Ｅｍａｃｓ：02/10/08 14:44
むしろ個別にFreeすると終了処理が長引くので、
Freeしないで終わるようにする定石もあるらしい。
Windowsだとちょっと心配だけど、UNIXなら問題
ないのではないでしょうか？
749 ：デフォルトの名無しさん：02/10/08 14:52
ま　た　m a l l o c & f r e e で　す　か。

deleteは忘れるなよ。
750 ：デフォルトの名無しさん：02/10/08 14:59
borland c++ から c++builderへ.rcファイルごと移行したいのですが、どうすれば良い
ですか？
751 ：744：02/10/08 15:33
学生時代以来のC/C++プログラミングなので、ちょっと混乱していました(w

たしかにプログラムが終了すれば、OS が面倒みてくれますね。常駐型の
プログラムを書いているので、別の問題とごっちゃになっておりました。

> あるクラスのインスタンスを一つ生成し、それがイベントループを廻し続けるような
> プログラムを書いているのですが、この場合デストラクタが呼ばれることがあるので
> しょうか。

結局のところ、興味があるのはこの点でして、このタイプのプログラムの場合、その
クラスのデストラクタを書いても意味はないかどうかということです。
752 ：デフォルトの名無しさん：02/10/08 15:56
顔が汚くてもいいから、胸の大きい女性を望むあなた・・・。
753 ：デフォルトの名無しさん：02/10/08 16:13
>>751
プログラムの終了処理はＯＳが面倒見てくれることばっかじゃなしなぁ。
754 ：デフォルトの名無しさん：02/10/08 17:03
>>747
まあそういうVB厨プログラマが大勢いるから
NT系サーバの連続運用は難しいとかよく落ちるとか
１日一回リセットとかの話になるわけだな。
755 ：デフォルトの名無しさん：02/10/08 17:04
>>747 100%pure VB房と認定されますた。
VB房ロゴの使用を許可します。
756 ：デフォルトの名無しさん：02/10/08 17:25
>>747に同意
757 ：デフォルトの名無しさん：02/10/08 19:31
ClassX a;
ClassX b;
ClassX c;

a = b;
a = c　←の時点で、aのデストラクタって呼ばれるのでしょうか？

ClassXの内部で動的にメモリを確保しているような場合、上のような
状況で開放する術はありますか？
758 ：デフォルトの名無しさん：02/10/08 19:33
>>757
デストラクタじゃなくてoperator=が呼ばれる。
759 ：757：02/10/08 19:34
>>758
おお！即レスありがとうございます。
ちょっと悩んでいたんで、かなりうれしいです。
760 ：デフォルトの名無しさん：02/10/08 19:59
しかしEffective C++ にのってる a = a のチェックって誰かしてる奴いるんか？
761 ：デフォルトの名無しさん：02/10/08 20:07
自己代入のチエックってやっぱりthisとrhsのアドレス比較するんかなあ。
762 ：デフォルトの名無しさん：02/10/08 20:14
>>760
メンバがスマートポインタなら a = a でもデータ消失はないから大丈夫。
さらに operator = やコピーコンストラクタも定義する必要なし。夢のハッピーライフ。

でも、スマートポインタ使いまくりって奴もあまりいないが。
763 ：デフォルトの名無しさん：02/10/08 20:28
>>760
Exceptional C++ の項目38に従って必要ならする…
と言いたいところだが、自己代入がボトルネックになる
場面なんて出会ったことないので結局やってないなぁ。

>>762
それじゃあ、デフォルトのoperator=とかコピーコンストラクタが
コピーじゃなくて実装の共有になってしまわんか？それで幸せなら
特に止めるつもりはないが。
764 ：デフォルトの名無しさん：02/10/08 20:29
>>747
ねぇ、それはネタなの？ 本気なの？ 正しいの？ 間違ってるの？
765 ：デフォルトの名無しさん：02/10/08 21:15
>>764
UNIXで仕事してたときに終了時に free をずらずらと書いて開放処理をしていたら
先輩にCPUに無駄な仕事してんじゃないと怒られました。
766 ：デフォルトの名無しさん：02/10/08 21:15
>>760

a = a のチェックは必要なら普通するけど･･･ってのはウソで、
a = a でも問題ないようなコードで済ますことの方が多いか。
767 ：デフォルトの名無しさん：02/10/08 21:20
a = a でも問題ないようなコードって、たとえばポインタなら自己チェックと
スマートポインタ以外の方法あるの？
768 ：デフォルトの名無しさん：02/10/08 21:37
freeは未使用マークをつける
プログラム終了時には確保したメモリ領域はOSに返却される

どちらも「解放」という言葉を使ってるのが誤解を生む元になっているのではないだろうか。

＃freeがOSに返却しないのは「多くの処理系では」という条件付らしいが，詳しくは知らん
769 ：デフォルトの名無しさん：02/10/08 21:42
>>767
T& T::operator=( const T& other )
{
　T temp( other );
　this->Swap( temp );
　return *this;
}

http://www.gotw.ca/gotw/059.htm
770 ：デフォルトの名無しさん：02/10/08 23:20
やってることは一緒だけど、ディープコピー・開放・ポインタ代入、とか。
771 ：デフォルトの名無しさん：02/10/08 23:38
クラス内のフィールドに外部から値を取得することはできるが、
設定することはできず、クラス内部の関数からは設定することが
できることってできますか？

ClassA
{
private:
int m;
public:
ClassA(int m);
}

だと、mを取得することができない。Getなどのアクセサをつかわずに、
mをpulicにしても、なおかつ、設定はできないみたいなのはできますか？
772 ：デフォルトの名無しさん：02/10/08 23:45
C++の仕様ではできない。素直にgetアクセサをつけるべし。
つかpublicなメンバ変数は、レコードのような扱いでないかぎり
あんまりお勧めできない・・・

<Del厨モード>
ちなみにC#ではgetのみのプロパティにて実現可能。
Javaにはないよね（藁
</Del厨モード>
773 ：デフォルトの名無しさん：02/10/09 00:31
template<class T> struct id{ typedef T type; }; // dummy

template<typename Type, class Owner>
class read_only_field
{
public:
operator const Type& () const { return t; }
private:
friend typename id<Owner>::type;
read_only_field& operator=(const Type& ot) {t=ot; return *this;}
Type t;
};

class A {
public: read_only_field<int, A> m;
...
};

…99.5%くらいネタだけどな。
774 ：デフォルトの名無しさん：02/10/09 01:57
void f(std::vector<int> (&vr));
void f(std::vector<int> &vr);
void f(std::vector<int> (&));
void f(std::vector<int> &);

全て同じ宣言ですか？
775 ：デフォルトの名無しさん：02/10/09 01:59
>>774
同じだろう。プロトタイプ宣言の仮引数は型しかチェックされないから。
776 ：デフォルトの名無しさん：02/10/09 02:01
>>775
ﾚｽｻﾝｸｽ。
やっぱりか(；´Д｀)
777 ：デフォルトの名無しさん：02/10/09 12:07
ｳﾜｧｰｲ777!!
778 ：デフォルトの名無しさん：02/10/09 12:55
ｳﾜｰｲ778!!
779 ：デフォルトの名無しさん：02/10/09 13:14
delete >>777-778;
return -1;
780 ：デフォルトの名無しさん：02/10/09 15:19
宿題スレに書いたんですが、レスが無いのでこちらにも書かせてください。

コールバックって、メンバー関数をじかに呼べないんですが、

class Aとclass Bがあって
Bは、コールバックされる関数(SetTimerとか)を使っていて、
さらにそのコールバックされる関数の中でBのメンバー関数を呼び出したい。

BにAのインスタンスのポインターを持たせればできますが、
1. Bの実装でAに依存しない(class Aのクラス定義を読み込まない)
2. Aをコールバックされる関数を含んだ中傷クラスのサブクラスとしない

という条件で、うまい方法ってないですか?

現状はtemplateを使って(public,private等は省略)
class base {
　virtual void operaot()() = 0;
};

template<class T>
class callback : public base
{
　typedef void (T::*F)();

　callback(T* obj, F func) : o(obj), f(func) {}
　void operator()() { return o->*f();

　T* o;
　F f;
};

とやって、AはBにcallbackのインスタンスを渡すようにしてますが、今市…
781 ：デフォルトの名無しさん：02/10/09 15:43
>>780

普通に多重継承で interface (風のもの) 使えば？
782 ：デフォルトの名無しさん：02/10/09 16:51
そりは、条件2にひっかっかって…
実は、class AはCOMのクラスなので、何か仮想関数持ったクラスを継承する
のは問題が起きるのではないかと思うのですが。
そんな事は無いのでしょうか?
783 ：デフォルトの名無しさん：02/10/09 17:37
>>780
デリゲートって知ってるか？
784 ：デフォルトの名無しさん：02/10/09 17:45
デリケートですか？デリケートですか？
785 ：デフォルトの名無しさん：02/10/09 17:47
艦載陣さんですか？
786 ：デフォルトの名無しさん：02/10/09 19:00
デリケートゾーンのかゆみに…
787 ：デフォルトの名無しさん：02/10/09 20:09
はっきり

　ま　ん　こ

と書けやゴルア！
788 ：デフォルトの名無しさん：02/10/09 20:13
股間の痒みにメディナース
789 ：デフォルトの名無しさん：02/10/09 20:32
変態ばっかだな
790 ：デフォルトの名無しさん：02/10/09 20:33
まかいあんこやまらさきむんこは嫌いです
791 ：デフォルトの名無しさん：02/10/09 21:45
クラス内ローカルクラス宣言てできますか？

class A
{
　class B
　{
　　operator int() { return 1; }
　}
　B getB() { return B(); }
}MyA;

int a = MyA.getB();

みたいな
もちろんint b = B();はコンパイルエラーで
792 ：デフォルトの名無しさん：02/10/09 21:46
クラスＢ定義のあとに「;」忘れました・・・
793 ：デフォルトの名無しさん：02/10/09 21:47
Java厨か?
できるよ。
794 ：名無しさん＠Ｅｍａｃｓ：02/10/09 22:14
関数内にもできる。
実はつかったことないけど・・・汗
795 ：デフォルトの名無しさん：02/10/09 22:15
関数内に関数はできないんだよなー。
なんでだろう。
796 ：デフォルトの名無しさん：02/10/09 22:18
High-Cはできたなあ...
797 ：デフォルトの名無しさん：02/10/09 22:20
関数オブジェクトならできるだろう。
798 ：デフォルトの名無しさん：02/10/09 22:58
関数内クラス内に関数を作れば良いのだ！
799 ：デフォルトの名無しさん：02/10/09 23:49
>>797
だがテンプレート引数として渡せないという罠。（なんとなく理由は想像がつく）
800 ：デフォルトの名無しさん：02/10/10 00:22
>>780
AからBの関数を呼んで、BはAの(コールバックされる)関数を呼んで、
さらにそこからBの関数を呼ぶ、ということ？
で、AはBの定義やインスタンスを知っていて、しかもCOMのクラスなのね？
だとすると、多分Aはプラグインか何かだと思うけど、継承を避けるなら
780に類する方法しか無いと思う。ただ、Aを含むオブジェクトの中には
callback<A>もいて、それは仮想関数を持ったクラスを継承している。
WinもCOMも知らないから、何とも言えないけど、780で動いているなら、
継承は出来るんじゃあないかなあ。
構造上理由があって、継承を避けたいということならいいんだけど。
801 ：デフォルトの名無しさん：02/10/10 01:05
Java厨というか、無知なだけです・・・
クラス内クラス宣言が利用に先立ってされなければならない（らしい）という所にひっかかってました

class A
{
　B getB();
　class B;
}; // コンパイルエラー「Bの重複定義」

というやつ・・・

class A
{
　int hoo() { return bar(); }
　int bar() { return 1; }
}

はOKなのに・・・
802 ：デフォルトの名無しさん：02/10/10 15:42
>>782

A が COM オブジェクトなら、ITimerHandler とかのカスタム
インターフェイス（を定義して）持たせておけばよいのでは?

多重継承とCOMについては、一度 ATL のサンプルソース読んでみて。
インタフェイス継承も実装の継承も多用しているから、大分参考に
なるはず。
803 ：デフォルトの名無しさん：02/10/10 16:29
>>801

class A
{
　int hoo(){ B b; }
　class B{};
};

これはOK
違いわかる？
804 ：デフォルトの名無しさん：02/10/10 18:04
Visual C++ 6.0 で以下のようなコードを試しています。

　ofstream out;
　out.open("nowhere\\test.dat");

ところが、open に失敗します。
つまり、ファイルをオープンするとき、書き込み用の場合などは、
ファイルが存在しなくても、自動的に作成してくれるようですが、
ディレクトリも同時に作ってくれたりはしないみたいです。

ディレクトリを作成しつつファイルも作る方法はありますか？
あるいは、単独でディレクトリを作成する標準関数はあるのでしょうか？
（Windows 用の _mkdir などを使うしかないのでしょうか？）
805 ：デフォルトの名無しさん：02/10/10 18:50
>>804
ファイルとディレクトリはWindowsでは全く別々のものなので、
ディレクトリを作ってからopenして下さい。
806 ：デフォルトの名無しさん：02/10/10 19:36
STLのコンテナに自作したクラスhogeへのポインタを追加していって、それをソートするのに
namespace std
{
struct less<Particle*>: public binary_function<hoge const *, hoge const*, bool>
{
bool operator()(hoge* const a, hoge* const b)
{
return a->val < b->val;
}
};
};
std::list<hoge*> hogelist;
・・・//hogelistにnewしたhoge*を追加
hogelist.sort(std::less<hoge*>());
のようにしています。
・stdに手を入れていること
・hoge*に特化したstd::less<hoge*>を使っていること
の2点でよくないような気がするのですが、他の方法はありますか？
807 ：デフォルトの名無しさん：02/10/10 20:11
>>806

STLスレッド part2
http://pc3.2ch.net/test/read.cgi/tech/1026793823/l50
808 ：804：02/10/10 20:15
>>805
うーむ、そうですか。
ディレクトリを作りつつ……というプログラムを C++ でやろうとしたら、
OS に依存したコードを書かなければならない、ということですね。
どうもありがとうございました。
809 ：デフォルトの名無しさん：02/10/10 20:32
>>808
> ディレクトリを作りつつ...
> OS に依存したコードを書かなければならない、

当たり前だと思うけど...、全ての OS に階層ディレクトリがあると思っているのか ?
810 ：デフォルトの名無しさん：02/10/10 20:57
>>804の言うOSとはWindowsとLinuxの2種類だと思う。
811 ：デフォルトの名無しさん：02/10/10 21:55
>>810
> >>804の言うOSとはWindowsとLinuxの2種類だと思う。

>>804 だったら、Windows だけだろ ?

> Visual C++ 6.0 で...
812 ：デフォルトの名無しさん：02/10/10 22:09
>>806
std以外の名前空間で定義すればよい。

namespace hehehe
{
template <typename T>
struct less<T*>: public binary_function<const T*, const T* , bool>
{
bool operator() (const T* a, const T* b) const
{
return a->val < b->val;
}
};
};
813 ：デフォルトの名無しさん：02/10/10 22:09
>>811
あー，ちゃいます。
804が書いた>>808のレスの中で言ってる「OS」のことです。
814 ：デフォルトの名無しさん：02/10/10 22:10
若干修正

namespace hehehe
{
template <typename T>
struct less<T> : public binary_function<const T*, const T* , bool>
{
bool operator() (const T* a, const T* b) const
{
return a->val < b->val;
}
};
};
815 ：デフォルトの名無しさん：02/10/10 22:39
別にlessに手を入れる必要無いじゃん。
直接テンプレート引数にファンクタ渡せば？
816 ：804：02/10/10 22:46
>>809
> 全ての OS に階層ディレクトリがあると思っているのか ?

すみません、かなり勉強不足でした。

少なくとも C++ が走るようなものではそうだと思っていました。
ちなみに、どんな OS だと階層ディレクトリがないのですか？
（検索しても Windows/Unix/MacOS 以外については余り情報が得られないので。）

なお、
> ディレクトリを作成しつつファイルも作る方法はありますか？
に関連して、無効なパスを渡された場合、
１・階層ディレクトリのある環境ではディレクトリの作成を試みる
２・そうでないときは、やはりエラーを返す
というような機能を考えてみたのですが、
やはり無理、またはやらない方がよい、ということですか？
817 ：デフォルトの名無しさん：02/10/10 23:12
>>816
ふるいmvsとか
818 ：デフォルトの名無しさん：02/10/10 23:17
>816
プリンタや自販機のROMの中にもOS入ってたりする。
819 ：デフォルトの名無しさん：02/10/10 23:32
>>815
どういう風に書けばいいの？
820 ：デフォルトの名無しさん：02/10/10 23:38
>809
全てのOSにファイルはあるの?
821 ：デフォルトの名無しさん：02/10/10 23:43
＞819
list::sortには、Predを引数とする版があるだろ。
822 ：デフォルトの名無しさん：02/10/11 00:01
>>821
ああなるほど、std::lessではなくて、適当な名前の比較関数オブジェクトを
渡してやればいいのですね。
823 ：デフォルトの名無しさん：02/10/11 00:22
>>820
組み込みだとディスク自体が無いね
824 ：デフォルトの名無しさん：02/10/11 06:54
ファンクタライクな物をVC.NETで作ってるんですが、
部分特殊化できないと　LokiのTypeListみたいなのはつくれないんでしょうか？
//_Tはクラス. _R は戻り値の型. _Lは引数の型
template <typename _T,typename _R,typename _L>class FunctorX
{protected:
_R(_T::*mem_f1)(_L);
_R (*g_f1)(_L);
_T* obj_ptr_f1;
_T* func_obj_ptr_n1;
enum Mode{other,mem_ptr,ptr,func_obj}m_mode;
void Ini(){
g_f1= NULL;mem_f1 = NULL;
obj_ptr_f1 = NULL;func_obj_ptr_n1 = NULL;
m_mode = Mode::other;
}
public:
FunctorX(_T& ob,_R (_T::*f1)(_L)){
Ini();mem_f1= f1;
obj_ptr_f1 = ptr;m_mode = Mode::mem_ptr;
}
explicit FunctorX(_R (*f1)(_L)){
Ini();g_f1 = f1;
m_mode = Mode::ptr;
}
explicit FunctorX(_T& ob){
Ini();func_obj_ptr_n1 = &ob;
m_mode = Mode::func_obj;
}
FunctorX(){ Ini()}
~FunctorX(){}
825 ：正男 ◆GVV43x.nK. ：02/10/11 06:56
途中まで読んで頭が痛くなってまいりますた
826 ：続き：02/10/11 06:56
_R call(_T& ob,_L a){
if( obj_ptr_f1 != NULL && mem_f1 != NULL && m_mode == Mode::mem_ptr){
return (ob.*mem_f1)(a);}
throw "Functor error";
}
_R call(_L a){
switch(m_mode){
case Mode::mem_ptr :
if( obj_ptr_f1 != NULL && mem_f1 != NULL )
　　　　　　　　　　　　　　　　　　　　return (*obj_ptr_f1.*mem_f1)(a);
break;
case Mode::ptr :
if( g_f1 != NULL )
return (*g_f1)(a);
break;
case Mode::func_obj :
if( func_obj_ptr_n1 !=NULL )
return (*func_obj_ptr_n1)(a);
break;
default:
break;
}
throw "Functor error";
}
_R operator()(_L a){return call(a);}
};
827 ：main：02/10/11 07:01
struct Test
{
template<typename R,typename L> R f(L a){ return a*2;}
Test(){}
~Test(){}
};

int main()
{
Test c5,c5a;
Functor<Test,int,int> t5(c5,&Test::f<int,int>);

cout << t5.call(c5,100);
cout << t5.call(100);

cout << t5.call(c5a,100);//c5 の関数ポインタ経由で c5aを呼び出す???
cout << t5(100);

FunctorX< Functor<Test,int,int> ,int,int> t6(t5);
t6(100);

}
828 ：デフォルトの名無しさん：02/10/11 09:47
>>824
その規模のコードはcppにしてどこかにアップしろ

コメントされてない（しかもインデントすらされていない）コードなんて
ただのゴミ
829 ：デフォルトの名無しさん：02/10/11 13:48
>>828
template苦手だからってキレんなよw

830 ：デフォルトの名無しさん：02/10/11 14:53
>>829
でもそれだけ書かれてもなぁ。
831 ：829：02/10/11 15:51
Lokiスレのほうに書きゃいいのに、とはオモウ。
832 ：しつこく：02/10/11 18:50
TC++PL3rdや>>3のFinal Draftにある文法に
member-declaration
　:decl-specifier-seqopt member-declarator-listopt ;
　|function-definition ;opt
　|::opt nested-name-specifier templateopt unqualified-id ;
　|using-declaration
　|template-declaration
　;
という部分がありますが上から三番目は何に使われてますか？
833 ：デフォルトの名無しさん：02/10/11 20:05
ClassA{
private:
int *a;
public:
ClassA(){a = NULL}
ClassA(int i){ a = new int [i] }
}

みたいなクラスがあって、

ClassA ain = new ClassA[100];

で呼ばれるコンストラクタは引数なしのコンストラクタしか無理ですか？
834 ：デフォルトの名無しさん：02/10/11 20:12
ClassA* ain = new ClassA[100](10);
835 ：デフォルトの名無しさん：02/10/11 22:11
>>874
それほんとにいける？
836 ：デフォルトの名無しさん：02/10/11 22:13
無理でせう。
837 ：デフォルトの名無しさん：02/10/11 23:30
>>874は逝けそうだけど逝けなさそうな微妙なことを書かねばならなくなりました。
838 ：832：02/10/11 23:33
なんだこの低能なシーケンスは！
839 ：デフォルトの名無しさん：02/10/11 23:33
ともっちに手取り足取りC++教えたい
840 ：デフォルトの名無しさん ：02/10/12 01:18
次のプログラムをコンパイルするとエラーが出てしまいます。
Aがシンタックスエラーを起こしていますとか。
どういうことなんでしょう？
本に書いてある通りにやっているのに・・・。
何がいけないのでしょう？

#include <stdio.h>
#include <stdlib.h>

class A {
public:
int id;
};



int main()
{
int i;
A c;

c.id = 100;
for( i = 0; i < 7; i++)
printf( "id = %d", c.id);

return 0;
}
841 ：デフォルトの名無しさん：02/10/12 01:21
初心者が質問するなら、エラーをそのまま貼らないと。それから

> #include <stdio.h>
> #include <stdlib.h>

こんな低脳なコードを乗せている入門本は古すぎるか腐っているので
捨てた方が吉かと。
842 ：デフォルトの名無しさん：02/10/12 01:22
コンパイラはなに？
bcc32では動いたよ。
拡張子は.cppとかにした？
843 ：840：02/10/12 01:28
.cから.cppになおしたらできました。
ありがとうございました。
一体２つはどう違うのでしょう？

844 ：841：02/10/12 01:30
C言語っていう腐れ言語しらんの？>>843
845 ：デフォルトの名無しさん：02/10/12 01:33
ところで、stdlibをインクルードしてる理由は何なのさ？
846 ：デフォルトの名無しさん：02/10/12 01:36
ループを7回まわしている理由モナー
847 ：デフォルトの名無しさん：02/10/12 02:07
クラス内関数のテンプレート化で質問です

class A
{
　template<class T>
　　T foo()
　{ なんたらかんたら }
}myA;

int a = myA.foo<int>();

でコンパイル通ってしまうんですが、
これはどう解釈されてるんでしょうか？

「返値の型だけ異なる」オーバーロードってNGでしたよね？
848 ：デフォルトの名無しさん：02/10/12 02:07
age忘れ...
849 ：デフォルトの名無しさん：02/10/12 02:44
>>847
コンパイラがbccだからじゃない？
850 ：デフォルトの名無しさん：02/10/12 03:55
突然ですが純粋仮想関数のデストラクタは必ず実装しなければならない、
とは知りませんでした。首吊ってきます。
851 ：デフォルトの名無しさん：02/10/12 05:47
最近なかなか寝付けません。どうしたら良いのでしょうか？
852 ：832：02/10/12 06:47
くだらなすぎ
853 ：デフォルトの名無しさん：02/10/12 08:32
>>847
テンプレートはオーバーロードではないからだろ
854 ：デフォルトの名無しさん：02/10/12 10:11
C++で、2次元（以上の）配列に対して、
辞書式順序でsortできるようにするためには、
bool operatorとsortを使えばよいらしいというのは、
分かったのですが、具体的なコーディングが分かりません。
教えてください。
855 ：832：02/10/12 10:20
>>854
何がしたいのか読み取れん。いったい何がわかっているというのだ。
856 ：デフォルトの名無しさん：02/10/12 10:21
ソートっつー概念はそもそも直線的なものにしか成り立たないんじゃないか？
2次元以上の要素をいったいどう並び替えろと？
857 ：デフォルトの名無しさん：02/10/12 10:25
もしかして組み込みの配列？
858 ：854：02/10/12 10:37
辞書式順序です。
例えば、(1,2),(5,6),(5,4),(2,4)というデータがあったら、
第一番目のデータを見て、(1,2),(2,4),(5,6),(5,4)
と並び替え、
一番目のデータが同じ時は、
(1,2),(2,4),(5,4),(5,6)
のように並び替えたいのです。

数学的に書くと
(i,j)<(k,l)←→i<k　
　　　　　　 　i=kのときは、j<l
としたいということです。
859 ：832：02/10/12 10:42
>>858
文字列のソートがどうやっているかわかってるなら、それと同じようにすれば
いい。
860 ：デフォルトの名無しさん：02/10/12 12:52
>>858
> 辞書式順序です。

頼むから、用語はちゃんと覚えてくれ。あやふやだったらはじめから使うな。

> 一番目のデータが同じ時は、
> (1,2),(2,4),(5,4),(5,6)
> のように並び替えたいのです。

というのは、単に複数キーでソートすると言う。
(ちなみに、辞書式というのは概ね文字コード順にソートすることを指す。)

> 数学的に書くと
> (i,j)<(k,l)←→i<k　
> 　　　　　 　i=kのときは、j<l

と言うのがわかっているなら、qsort() の比較関数をそのように書けば良いだけだよ。

でも、そう言うデータなら二次元配列より構造体の一次元配列の方がわかりやすいと思う。
861 ：デフォルトの名無しさん：02/10/12 14:00
>>860
> >>858
> > 辞書式順序です。
>
> 頼むから、用語はちゃんと覚えてくれ。あやふやだったらはじめから使うな。

固定長の文字列とみなせば辞書式と言っても間違いではない。

> (ちなみに、辞書式というのは概ね文字コード順にソートすることを指す。)

別に文字コードじゃなくたっていいんだよ、順序さえあれば。
862 ：デフォルトの名無しさん：02/10/12 14:32
テンプレート型のクラスのコンストラクタを
宣言と実体を別ファイルで書くことは出来なんでしょうか？

ファイル：a.h
template<class T>
struct A
{
A();
};

ファイル：a.cpp
template<class T>
A<T>::A()
{
}

このクラスを別のファイル(main.cpp)で使おうとすると、
外部シンボルが未解決ですと言われます。
何か書き方が間違っているのでしょうか？
一応a.hに実体もまとめて書けばエラーにはならないのですが･･･
863 ：デフォルトの名無しさん：02/10/12 14:39
過去ログを参照願います。
864 ：デフォルトの名無しさん：02/10/12 16:16
>>861
> 固定長の文字列とみなせば辞書式と言っても間違いではない。

ハイハイ、人の指摘に手一杯で、>>858 の

> 数学的に書くと
> (i,j)<(k,l)←→i<k　
>　　　　　　 　i=kのときは、j<l

は見てないのね。

> 別に文字コードじゃなくたっていいんだよ、順序さえあれば。

ハイハイ、｢概ね｣と言う言葉も理解できなかったのね。


ったく、話の流れぐらい読めよ。
865 ：デフォルトの名無しさん：02/10/12 16:34
>>864
何が言いたいのかわからんが「辞書式比較」の定義って、二要素なら
　> 数学的に書くと
　> (i,j)<(k,l)←→i<k　
　>　　　　　　 　i=kのときは、j<l
普通まさしくこれのことだぞ。先頭要素を先に比較して、同じなら残りの要素で比較。
std::lexicographical_compare でも見れ。
866 ：デフォルトの名無しさん：02/10/12 16:35
(　´_ゝ`)ﾏﾀｰﾘ ｼﾖｳﾖ
867 ：デフォルトの名無しさん：02/10/12 16:36
>>849
VCやgccでは無理なんですか・・・

>>853
>>847のコードはfooが呼ばれる度に
class A
{
　int foo() {}
　char foo() {}
　：
　：
};
みたいに展開されると思ってたんですが
違うのですか・・・？
868 ：854：02/10/12 16:37
>>859 文字列のソートがどうやっているかわかってるなら、それと同じようにすれば
いい。

それはそうですが、それをsortとbool　operatorでできますか、ということです。
一から自分でプログラムしてもいいですが、面倒なので。
あまり自信もないし。


>>860
>頼むから、用語はちゃんと覚えてくれ。あやふやだったらはじめから使うな。

別にあやふやでないです。
辞書式順序というのは、正式な言葉のはず。
ただプログラミングの世界ではないのかも。

> 一番目のデータが同じ時は、
> (1,2),(2,4),(5,4),(5,6)
> のように並び替えたいのです。

>というのは、単に複数キーでソートすると言う。

では複数キーでソートするやり方を教えてください。
できればsortのような組み込みのアルゴリズムを使ってもらえると助かります。
869 ：デフォルトの名無しさん：02/10/12 17:08
>>867
class A
{
template< class T > T foo(){}
};
は

class A
{
　template<> int foo<int>(){}
　template<> char foo<char>(){}
};

って展開されると思う。
870 ：デフォルトの名無しさん：02/10/12 17:20
>>868
できるでしょ
bool operrator < で lexicographical_compare つかって sort に突っ込めば？
自分でコーディングする部分なんてほとんど無いよ
871 ：862：02/10/12 17:37
探し方があまいのか結局分かりませんでした。
誰かヒントだけでも…
872 ：デフォルトの名無しさん：02/10/12 17:42
>>871
テンプレートはそういうものだと思ってあきらめましょう。。。
873 ：デフォルトの名無しさん：02/10/12 17:43
>>871
exportキーワードをまともにサポートしている処理系でないと、
テンプレートの宣言と実体を分けて書くことはできない。
874 ：デフォルトの名無しさん：02/10/12 17:43
template<class T> ＜ ん？ T はintかよしよし分かった。。。ん？A()はどこ行った？
struct A
{
A();
};

一方その頃 cpp では。。。

ファイル：a.cpp
template<class T> ＜ おーい、俺はどうしたら良いんだよ～、なんか不安になってきたよ。。
A<T>::A()
{
}
875 ：デフォルトの名無しさん：02/10/12 17:47
>>860の恥の上塗りには笑った
876 ：デフォルトの名無しさん：02/10/12 17:56
>>868
コンテナの比較は辞書式だから固定長ならboost::arrayでも使えば？
877 ：862：02/10/12 18:05
>>872-874
どうもありがとうございます。
いままでコンストラクタのところでしかエラーが出てなかったんで、
コンストラクタさえどうにかなれば可能だろうと考えていましたが、
今テストしてみた結果、実体作るとやっぱりメンバー関数も無理だと
言うことが分かりました。
確かにa.cppの型を解決する方法が無いですもんね…。
（いままでコンパイラが勝手に解釈してくれてるのとばかり…）
素直にあきらめることにします。
878 ：デフォルトの名無しさん：02/10/12 19:19
exportをサポートしてる処理系ってComeau以外にある？

そういえば…Comeauのネット上の試用コンパイラ（？）は
template <template <class> class Container> class HogeにSTLのコンテナを渡せなかったなぁ。
（→試してないけど、template <template <class, class> class Container>になら渡せそうだった。）
これって普通？VC,BCC,gcc,+STLPortだと文句言わずにコンパイルしてくれるんだけど。
879 ：デフォルトの名無しさん：02/10/13 01:18
>>862
もし、テンプレート引数 T に渡す型とかがいくつかに限定されているなら、
それらを a.cpp で明示的にインスタンス化するという手は使えるけど。
template A<int>;
template A<char*>;
とか。
880 ：デフォルトの名無しさん：02/10/13 02:46
STLのイタレータの継承の一般的な仕方がわかりません.

コンテナのbegin,endの代入も苦しいし,
algorithmライブラリを使えるようにするのも苦しい.
_Rb_tree_iterator<...>とか書かないとうまい事いかない
もんなんでしょーか?
_Rb_...とか書くと移植性0になりそうなので,
幸せになれる方法を教えてください.
881 ：デフォルトの名無しさん：02/10/13 02:56
>>880
C++標準ライブラリP285～、§7.5.2「ユーザー定義の反復子」に詳しいです。

class MyIterator
: public std::iterator<std::bidirectional_iterator_tag, type> {
...
};
882 ：862：02/10/13 02:58
>>879
その方法>>877書いた直後に思いついたんですけど、
明示的に宣言出来るところがないんですよ。
テンプレート使ってるコードは全部ヘッダに詰め込むのが基本なんですかね？？
883 ：880：02/10/13 03:32
>>881
その本持ってますが,そこではコンストラクタで
コンテナを受け取るという事をやっていて,
コンテナのbeginメンバ関数からの代入は扱ってません.
884 ：デフォルトの名無しさん：02/10/13 05:46
>>883
boost::iterator_adapter
885 ：デフォルトの名無しさん：02/10/13 11:39
>>882
template A<int>; って書き方は、どこででもできると思うけど。
別にオブジェクトとか関数とかを定義しているわけでもないし。
886 ：デフォルトの名無しさん：02/10/13 16:32
CかC++かどっちか判断できなかったので
こちらで質問させていただきます。
VBから呼び出し可能なDLLを作成しています。
調べていく上でエクスポートの方法は
__declspecでのエクスポートではなく
Defファイルへの記述でのエクスポートが必要ということが分かりました。
それで質問というのはDefファイルっていうのは
Func @1
というような記述をしますよね？
そこでClass CTestのメンバ関数GetFileNameを記述するには
どう記述したらいいでしょうか？
適当に書いてみても駄目でした。
文法的にどういう風に｢クラスののメンバ関数｣のGetFileName
ということを書いたらいいのかわかりません。
教えていただけませんか？
よろしくお願いします。
887 ：デフォルトの名無しさん：02/10/13 16:47
>>886
VC++スレってなかったかな・・・

VBからC++のクラスを直には呼べないよ。ActiveX(COM)にするしかない。
呼べるのはCの関数形式のもの。これのやりかたはFAQなので省略。
888 ：886：02/10/13 16:54
>887
え、defファイル自体VCの話しだったんですね、
スレ違いですね、失礼しました。

Comにしなきゃだめなんですね、
わかりました、ありがとうございます。
ではVBの話しは別にして、
defファイルでクラスごと、または
クラスのメンバ関数のエクスポートの記述方法だけでも
教えてもらえませんでしょうか？
もう半年くらいわからなくて半分以上放置になってる
悩み事なんです。
これで消えますのでよろしくお願いします。
889 ： ：02/10/13 17:34
>>888
普通はDEFファイルを書く必要はないが、
どうしてもDEFでやりたいなら・・・。

DEFファイルではクラスごとエクスポートすることはできない。
メンバごとにエクスポートする必要がある。

例えば、こういうクラスAがあったとすると、

　class A {
　public:
　　A();
　　int a(int, char*);
　};

DEFファイルにはこのように書く。

　EXPORTS
　　??0A@@QAE@XZ @1 NONAME
　　?a@A@@QAEHHPAD@Z @2 NONAME

装飾名はMAPファイルで確認すること。@ordinalとNONAMEは
なくても構わない。
890 ：デフォルトの名無しさん：02/10/13 19:16
Chain of responsibilityパターンみたいな、階層構造を表現するために
親へのイテレータをsecondに持ったマップのようなモノを使いたいのですが
既存のライブラリにそういうモノって無いでしょうか？

要求としては、
・"文字列"と"親を指すイテレータ"を格納できる
・マップ中のある要素に"格納してある文字列"でアクセスできる
・そしてその要素から親まで順番にたどりつつ
・さらに現在の要素に格納されている文字列を参照できる

イメージとしては
　map<string, iterator> chainmap;
のような感じで、例えば
Ａ ─ Ｂ ┬ Ｃ ─ Ｅ
　　　 　 └ Ｄ ┬ Ｆ
　　　　　 　 　 └ Ｇ
という階層構造にしたとして、
　chainmap["D"].PrintUpToParent();
とかすると
　for (it = *chainmap["D"]; it != chainmap.end(); it = it->second)
　　cout << it->first << endl;
みたいな処理をしたいのです
891 ：デフォルトの名無しさん：02/10/13 19:17
あう・・・>>890の出力結果を
D
B
A
にしたいという事です・・・
892 ：デフォルトの名無しさん：02/10/14 16:18
自作のクラスをｆｏｒ文使って配列に入れたいのですが、方法が分かりません。
要するに自作クラスのポインタをスタックに入れる処理がしたいのです。
よろしくお願いします。
893 ：デフォルトの名無しさん：02/10/14 16:21
class Jisaku { /*definition*/ };

Jisaku* jien[N];
for(int i=0; i<N; i++) {
　jien[i] = new Jisaku();
}
894 ：デフォルトの名無しさん：02/10/14 16:23
>>892
std::vector< boost::shared_ptr<Jisaku> > jien;
jien.assign( N, new Jisaku );

>>893
最後の()は不要
895 ：894：02/10/14 16:24
スタックに、か。忘れてくれ。
896 ：デフォルトの名無しさん：02/10/14 16:29
>>894
もしかして普段から()省いてますか？
897 ：デフォルトの名無しさん：02/10/14 16:43
ハイパーカード？
898 ：デフォルトの名無しさん：02/10/14 17:38
>>894
それってjienいっぱいに同じインスタンスが敷き詰められるんじゃ・・・
899 ：衝撃の事実（漏れにとっては・・・）：02/10/15 16:01
class FileWrapper
{
　ofstream* FileHandle;
public:
　FileWrapper(const char* fname) { FileHandle = new ofstream(fname, ios::out | ios::trunc); }
　~FileWrapper()　　　　　 　 　 　 　 { delete FileHandle; }

　FileWrapper& operator <<(ostream& (*pf)(ostream&)) { *FileHandle << pf; }
　template<class T> FileWrapper& operator <<(T arg)　　　　　　　 { *FileHandle << arg; }
};

int main()
{
　// 処理Ａ /////////////////////////////////////////////////////////
　FileWrapper* FileStream = new FileWrapper("testA.txt");
　boost::timer t;
　for (int i = 1; i <= 10000; ++i) {
　　*FileStream << i << ",";
　}
　*FileStream << "\nElapsed time " << t1.elapsed() << " sec." << endl;
　delete FileStream;

　// 処理Ｂ /////////////////////////////////////////////////////////
　ofstream* FileHandle = new ofstream("testB.log", ios::out | ios::trunc);
　timer t2;
　for (int i = 1; i <= 10000; ++i) {
　　*FileHandle << "no " << i << "," << flush;
　}
　*FileHandle << "\nelapsed time " << t2.elapsed() << " sec." << endl;
　delete FileHandle;
}
900 ：衝撃の事実（漏れにとっては・・・）：02/10/15 16:01
環境　Win98SE PenIV1.8GHz DDR512MB
コンパイル BCC5.5.1

で、なぜか処理Ａにかかった時間が平均約0.05秒に対し
処理Ｂにかかった時間が平均約0.5秒・・・その差なんと１０倍

直打ちよりテンプレート化したほうが速いって一体どういう事ですか？

処理順で（boost::timerあたりに）何か違いがあるかもと思って
上下入れ替えてみても、結果はかわりませんでした
901 ：衝撃の事実（漏れにとっては・・・）：02/10/15 16:04
処理Ｂのコード間違えた・・・
　boost::timer t2;
　for (int i = 1; i <= 10000; ++i) {
　　*FileHandle << i << ",";
　}
　*FileHandle << "\nelapsed time " << t2.elapsed() << " sec." << endl;
です
902 ：デフォルトの名無しさん：02/10/15 17:29
＞　FileWrapper& operator <<(ostream& (*pf)(ostream&)) { *FileHandle << pf; }
BCCは、こういうコードを通すのか、、、、return *this;を追加。

bcc:
Elapsed time 0.231 sec.
elapsed time 0.22 sec.
vc6:
　Elapsed time 0.1 sec.
elapsed time 0.1 sec.
903 ：デフォルトの名無しさん：02/10/15 17:33
何でコンパイルするとそのコードが動くの？
904 ：デフォルトの名無しさん：02/10/15 17:35
ああ、bccですか、失礼
905 ：デフォルトの名無しさん：02/10/15 17:44
flushこれの違いだけだね
906 ：デフォルトの名無しさん：02/10/15 20:12
そりゃflushしまくれば遅くなるだろうなあ・・・
907 ：デフォルトの名無しさん：02/10/15 22:41
心底つまらない事実だったな。
908 ：デフォルトの名無しさん：02/10/16 05:58
class A
{
　operator bool() { return false; }
};

int main()
{
　if (A()) return -1;
　/* Do something */
　return 0;
}

とあった場合、mainで呼び出されたAは
return 0;以降でデストラクトされると保証されますか？
909 ：デフォルトの名無しさん：02/10/16 07:19
if文が終わった時点でデストラクトされるっしょ
910 ：デフォルトの名無しさん：02/10/16 08:25
多倍長整数のよかライブラリ（ソースアリ）ってないっすかね。フリーで‥
911 ：デフォルトの名無しさん：02/10/16 08:52
>>909
実は、多重起動を抑止するために
以下のような仕組みを考えてみたのですが、
なんとこれがうまく動いてしまっているんです。
環境依存の恐るべきコードですか？

class ImNotOriginal
{
public:
　ImNotOriginal()
　{
　　hMutex = CreateMutex(NULL, TRUE, "このアプリケーションの名前");
　}
　~ImNotOriginal()
　{
　　ReleaseMutex(hMutex);
　}
　operator bool()
　{
　　return (WaitForSingleObject(hMutex, 0) == WAIT_TIMEOUT);
　}
private:
　HANDLE hMutex;
};

int main()
{
　if ( ImNotOriginal() ) return -1;
　/* 何やらかんやら */
}
912 ：デフォルトの名無しさん：02/10/16 13:18
>>911
そのロジックでは、本当は重複起動を防止できない。

実際に重複起動を防止できてしまうのは、デストラクタが呼ばれないのではなく、
最初に起動したプロセスが CreateMutex() と WaitForSingleObject() で
ミューテックス所有権を 2 つ獲得してしまっている為に、ReleaseMutex() を
2 回呼ばないとミューテックスを解放できないからだ。

WaitForSingleObject() はミューテックスが誰かに所有されているかを確認する
だけでなく、誰も所有していなかったら所有権を獲得してくる。
誰かが所有している場合、その所有しているスレッドが WaitForSingleObject() を
呼んだスレッド自身であった場合は、ロックされずに所有権をもう 1 つ獲得してくる。

ロックされないのは単独スレッドによるデッドロックを防ぐため、所有権をもう 1 つ
獲得してくるのは排他処理の帳尻を合わせるため （処理 A、B で排他が必要な時、
B が終わっていないのに A で排他が終了しただけで B が突入可能になるのはまずい
だろう？）。

ミューテックス所有権の獲得と放棄は必ず 1 対 1 で対応させること、その際
WaitFor*Object() 系 API の取り扱いには十分注意すること。

ミューテックスで重複起動を防止する場合は通常、WaitForSingleObject() を呼ぶ
のではなく、CreateMutex() 直後で GetLastError() の戻り値が ERROR_ALREADY_EXISTS
であるかどうかを調べる。
913 ：デフォルトの名無しさん：02/10/16 17:15
>>912
詳しい説明ありがとうございました

では質問を変えて、operator bool()の実装を
return (GetLastError() == ERROR_ALREADY_EXISTS)
にした場合、コンストラクタ→operator bool()と呼ばれる保証はありますでしょうか？
914 ：デフォルトの名無しさん：02/10/16 17:48
つまりプロセス終了時にミューテックスが自動的に解法されることを利用して

class ImNotOriginal
{
public:
　ImNotOriginal()
　{
　　HANDLE hMutex = CreateMutex(NULL, FALSE, "このアプリケーションの名前");
　}
　~ImNotOriginal(){}
　operator bool()
　{
　　return (GetLastError() == ERROR_ALREADY_EXISTS);
　}
};

というコーディングは可能でしょうか？ということです
あ・・・これだとミューテックス生成そのものに失敗してもfalseになっちゃうのかな・・・
915 ：デフォルトの名無しさん：02/10/16 17:56
我ながら阿呆だ・・・
１度しか呼ばれない事を前提にすれば

class ImNotOriginal
{
public:
　operator bool()
　{
　　HANDLE hMutex = CreateMutex(NULL, FALSE, gc_AppName);
　　DWORD result = GetLastError();
　　return (hMutex == NULL || result == ERROR_ALREADY_EXISTS);
　}
};

これでいいのですね
916 ：デフォルトの名無しさん：02/10/16 18:28
>>913
if(ImNotOriginal()) はまず ImNotOriginal() が評価され、コンストラクタが
呼ばれる。
次に、if は評価式に bool を要求するので、bool に型キャストされて operator bool()
が呼ばれる。
つまり、望み通りコンストラクタに続けて operator bool() が呼ばれるし、必ずそう動く
ものと見なして良いが、結果そうなるだけで言語レベルで保証しているという訳ではない。

>>915
そこまでひらめいたなら、関数化するべきだ。
クラスである意味は全く無い。

どーでもいーけど CreateMutex() って、lpName が "(ﾟДﾟ)ﾊｧ?" でも "\\" でも
"\r\n" でも "" でも成功するんだよなー。
917 ：デフォルトの名無しさん：02/10/18 03:29
C++ってjavaとかperlに比べて標準/準標準ライブラリが貧弱すぎると思うんですが
私が知らないだけでしょうか。

libwwwとboostはつかってますがほかになんかいいのないですか？
918 ：デフォルトの名無しさん：02/10/18 04:17
>>917
loki、common c++ libraryかなぁ…メジャーなのだと(cc++がメジャーかどうかはアレだが)。
欲しい機能に++とかCC付けて検索すると結構APIにヒットしたりするよ。socket++、socketCCとか、
pthreadCCとか。

CやC++は、基本的に「最低限は用意してるから、後は自分で用意しろや」ってスタンスが強いから、
自作するか他人様が作ったライブラリを求めてネットをさまようしかないだろうな。
919 ：デフォルトの名無しさん：02/10/18 08:49
>>917
ACE, Blitz++, FC++ …などなど。
ライブラリじゃないけどflex/bisonとか。
920 ：デフォルトの名無しさん：02/10/18 12:31
TRACEってなに？
文字を表示するもの？
921 ：デフォルトの名無しさん：02/10/18 13:34
>>620
VCのデバッグ窓に文字列を表示・・ジャネーノ？
#二重起動云々はVCスレでやってほしいのう
922 ：男子高校生：02/10/18 14:44
クラスとその周辺の設計ムズイんだけどー
実用的に汎用にすんのが辛いね。
923 ：デフォルトの名無しさん：02/10/18 15:55
>>922
激しく汎用化してしまえ。






マジレスするとそういのうは経験が必要だから、とりあえず適当に組むべし。
そのうち慣れるよ。
924 ：デフォルトの名無しさん：02/10/18 20:26
激しくgenerativeに書け
自分さえも読めない罠にはまって射精するのが漢
925 ：デフォルトの名無しさん：02/10/18 20:28
UNIXで、socketのselectだけできりゃいいんですけど、BSD系のライセンスで
シンプルなwrapper libraryないですかねえ。MT不要、fork不要、realtime signal なぞぜんぜんいらない。

自分で書けってか。


926 ：デフォルトの名無しさん：02/10/18 20:30
>>924
コメントぐらい書けってば！
927 ：デフォルトの名無しさん：02/10/18 20:56
>>926
それじゃ射精できないだろう！
928 ：デフォルトの名無しさん：02/10/18 21:59
(・∀・) ｵﾅｰﾆ!!

　　　　　∧_∧＿___ ｴｯ
　　　 Σ (*ﾟ－ﾟ)　.／＼
　　／|￣〇〇￣|＼／
　　　 |__しぃ++.__|／
.　　　 ￣￣￣￣
929 ：デフォルトの名無しさん：02/10/18 23:15
これってどう？

inline string &operator<<(string &Str, char AddStr) { return Str += AddStr; }
inline string &operator<<(string &Str, const char *AddStr) { return Str += AddStr; }
inline string &operator<<(string &Str, string &AddStr) { return Str += AddStr; }
930 ：3たび：02/10/18 23:19
>>929いらん

TC++PL3rdや>>3のFinal Draftにある文法に
member-declaration
　:decl-specifier-seqopt member-declarator-listopt ;
　|function-definition ;opt
　|::opt nested-name-specifier templateopt unqualified-id ;
　|using-declaration
　|template-declaration
　;
という部分がありますが上から三番目は何に使われてますか？

931 ：デフォルトの名無しさん：02/10/18 23:47
>>930
文法を示されて、一瞬何の事かわからなかった。
すまん、stringは独自クラスではなくてstd::stringなのだが…。k94i
ostreamのように

　str1 << str2 << '(' << str3 << ")";

とかできればいいなと思ったの。
ちなみに上から三番目の第二引数はconst忘れ。
932 ：930：02/10/18 23:59
>>931
+=は自分で作れってこと？
933 ：930：02/10/19 00:03
ごめん勘違い。
934 ：930：02/10/19 00:06
わしの娘であるstringstreamでは不満ということかね？
935 ：デフォルトの名無しさん：02/10/19 00:19
>>930
住人が同じであるいじょう何度聞いても答えは得られないと思われ
所詮2ちゃんはこの程度かと思いながら他のもっとましなところに行くことをおすすめする
936 ：930：02/10/19 00:25
>>935
じつはすでに2chはこの程度かと思っているが、
comp.lang.c++などで聞く気にもなれず自分はこの程度かとも思っている。
937 ：931：02/10/19 00:45
>>934
何か大げさだなと思って。
938 ：930：02/10/19 01:00
>>937
所詮、平民出のプログラマには、stringのような田舎娘がお似合いということね！
939 ：937：02/10/19 01:24
>>938
タカビーな貴族娘に用は無い！
940 ：939：02/10/19 01:26
E-mail 設定し直すの忘れたよ・・・938 スマソ。
「Cから見ればstringも充分アレだし」 と書きたかった。
941 ：930：02/10/19 03:20
comp.lang.c++も
void main()
で盛り上がってた。
942 ：デフォルトの名無しさん：02/10/19 03:38
voidﾀﾝは？
943 ：スーパー初心者：02/10/19 12:10
ムーテックスってなに？
944 ：デフォルトの名無しさん：02/10/19 12:12
(´ゞ)←これ
945 ：デフォルトの名無しさん：02/10/19 13:22
#if abc
#error (・∀・)
#endif

abcと同名のｼﾝﾎﾞﾙは無いはずだけど全ての処理系で通る(falseで)！
大ﾊｹｰﾝ？
946 ：デフォルトの名無しさん：02/10/19 13:24
つかmankoでもchinkoでも何でもOKっぽよ！？(奇跡)
947 ：デフォルトの名無しさん：02/10/19 13:27
ぽよ→ぽいよ
948 ：デフォルトの名無しさん：02/10/19 13:31
>>946
何が。
949 ：デフォルトの名無しさん：02/10/19 13:40
#ifdef と勘違いしているだけだ


とマジレスしてみるテスト
950 ：デフォルトの名無しさん：02/10/19 14:00
ポインタ型に対する const 指定の説明なのだが、

例えばポインタ演算 **p の結合規則は右から左なので、(*(*p)) と同じだ。
それと同様に考えればいい。
つまり、char const * p; は char (const (* p)); で、p そのものは変更できるが
*p が指すものは変更できない。
逆に、char * const p; は char (* (const p)); で、p そのものは変更できないが
*p が指すものは変更できる。
そして、char const * const p; は char (const (* (const p))); であり、これは
p そのものも *p が指すものも変更できない。
なお、const char * p; は char const * p; と全く同一である。

でよろしいか？
951 ：デフォルトの名無しさん：02/10/19 14:00
次スレの予感
952 ：デフォルトの名無しさん：02/10/19 14:15
>>950
よろしい
953 ：デフォルトの名無しさん：02/10/19 14:19
>>950
次スレおながい。
954 ：950：02/10/19 14:43
>>952
ありがとう。

>>951 >>953
これでいい？

C++相談室 part12
http://pc3.2ch.net/test/read.cgi/tech/1035005882/

次スレの 4・・・あんた速えーよ・・・。
955 ：デフォルトの名無しさん：02/10/19 14:49

　　まもなくここは　乂千取り合戦場乂　となります。

　 　 　 ＼∧＿ﾍ　　　　　／￣￣￣￣￣￣￣￣￣￣￣￣
　,,､,､,,,　/ ＼〇ノゝ∩ ＜　0x03E8 取り合戦、いくぞｺﾞﾙｧ！！　　　　　　　,,､,､,,,
　　　　/三√ ﾟДﾟ)　/　　 ＼＿＿＿＿＿＿＿＿＿＿＿＿　　,,､,､,,,
　　 　　/三/| ﾟＵﾟ|＼　　　　　　,,､,､,,,　　　　　　　　　　　　　　　　　　　　　　　,,､,､,,,
　,,､,､,,,　Ｕ （:::::::::::）　　,,､,､,,,　　　　　　　　　＼オーーーーーーーッ！！／
　　 　 　//三/|三|＼　　　　　∧＿∧∧＿∧ ∧＿∧∧＿∧∧＿∧∧＿∧
　　　　　　∪　 ∪　　　　　　 （　　　　）　　　 （　　　　 ）　　　（　　　　）　　　 ）
　,,､,､,,,　　　　　　　,,､,､,,,　　∧＿∧∧＿∧∧＿∧ ∧＿∧∧＿∧∧＿∧∧＿∧
　　　　　　,,､,､,,,　　　　　　 （　　　　）　　　 （　　　　）　　　 （　　　　）　　　 （　　　　）
956 ：Hikky!：02/10/19 17:03
(；ﾟДﾟ)∩　＜ なら俺は01747を取りに逝くぞﾓﾙｧ!
957 ：デフォルトの名無しさん：02/10/20 14:56
957!!
958 ：Hikky!：02/10/20 17:10
957+1!
959 ：デフォルトの名無しさん：02/10/20 17:54
++ 957 ++;
960 ：デフォルトの名無しさん：02/10/20 21:48
960
961 ：デフォルトの名無しさん：02/10/20 22:43
957+4!
962 ：デフォルトの名無しさん：02/10/20 23:39
957+1+1+1+1+1!
963 ：デフォルトの名無しさん：02/10/21 00:12
BOOST_PP_INC(962);
964 ：アフォルトの名無しさん：02/10/21 00:35
>>959
コンパイルエラー
965 ：アフォルトの名無しさん：02/10/21 00:42
long *p = (long *)0x03C0;
p++;
printf("%d", (char *)p + 1);
966 ：アフォルトの名無しさん：02/10/21 00:43
>>964
注意力が足りなかった
967 ：デフォルトの名無しさん：02/10/21 23:03
char _[967];
get = sizeof(_);
968 ：デフォルトの名無しさん：02/10/22 23:07
2*22*22
969 ：デフォルトの名無しさん：02/10/23 00:20
#include <iostream>

for (int i = 0 ; i < 969 ; ++i) {
std::cout << "(･∀･)ﾏﾝｺ!!" << std::endl;
}
970 ：デフォルトの名無しさん：02/10/23 00:42
>>969
なに？そのださいプログラムは。
971 ：デフォルトの名無しさん：02/10/23 01:07
>>970
プログラムというよりただのシークエンスという気がする。
間違いなくコンパイル通らないだろうし。
972 ：デフォルトの名無しさん：02/10/23 01:16
>>971
ﾏﾗにｵﾏﾝｺｷﾓﾁｲｲ!
973 ：デフォルトの名無しさん：02/10/23 01:50
throw itteyoshiException(util::make_container<vector, int>() << 969 << 972);
974 ：デフォルトの名無しさん：02/10/23 02:07
make_containerって何だよ。Java厨の出張?
975 ：デフォルトの名無しさん：02/10/23 03:23
#include <iostream>

int main(int argc, char** argv)
{
for (int i = 0 ; i < 975 ; ++i) {
std::cout << "(･∀･)ﾃｨﾝﾎﾟ!!" << std::endl;
}

return 0;
}
976 ：Hikky!：02/10/24 16:57
＿＿＿＿_　
|＼　　　　 ＼　
|　|￣￣￣￣|
|　|　　´∀`　| ヒキコもこもこ引き篭もり～♪
|　|　 　 鬱　 |
＼|＿＿＿＿| 　
　 人　 Ｙ 　　　
　し （＿） 　　　　
977 ：デフォルトの名無しさん：02/10/24 22:30
>>976
楽しそうだな
978 ：デフォルトの名無しさん：02/10/25 16:07
cout<<"CountDown! : "<<1000 - __LINE__<<endl;
979 ：デフォルトの名無しさん：02/10/25 18:12
http://store.yahoo.co.jp/i879/ys979.html
980 ：デフォルトの名無しさん：02/10/25 18:37
スマートポインタっていっても下のようにいろいろあるわけだけど、

std::auto_ptr ( Standerd C++ Library )
boost::sheard_ptr ( Boost )
Loki::SmartPtr ( Loki )
YTL::smart_ptr ( Yaneura Game SDK 3rd )

みんなは、どれを一番使ってるよ？
ほかにも、イイのがあったら教えてくれ。
981 ： ◆hMJAPH9PWA ：02/10/25 22:09
普通はboost::shared_ptr<>, boost::weak_ptr<>, boost::scoped_ptr<> およびその配列版だと思うが。
982 ：デフォルトの名無しさん：02/10/25 22:14
std::auto_ptrはスマートポインタじゃなかったような気が
983 ：デフォルトの名無しさん：02/10/25 23:02
>>980

Loki のスマートポインタは、いろいろいじれるから、
趣味や勉強にはいいかも。
個人的には期待大

やねうらお の smart_ptr は、面白いけど、どれだけ使う場面があるかは微妙。


やっぱ Boost か。


　
984 ：デフォルトの名無しさん：02/10/25 23:05
CComPtrとか書いたらしばかれますか？
985 ：デフォルトの名無しさん：02/10/26 12:07
fifteen response
986 ：デフォルトの名無しさん：02/10/26 15:09
YTL::oreno_nikubouwo_sakuratanni_buchikomu_haxahaxa_ptr
987 ：デフォルトの名無しさん：02/10/27 14:57
the rest: thirteen
988 ：デフォルトの名無しさん：02/10/27 15:12
早期梅。
989 ：デフォルトの名無しさん：02/10/28 10:47
今日も梅。
990 ：デフォルトの名無しさん：02/10/28 12:22
ten
991 ：デフォルトの名無しさん：02/10/28 12:22
´-`).｡oO(激しく上げちゃった…やばい）
992 ：デフォルトの名無しさん：02/10/28 13:02
記念ﾊﾟﾋﾟｺV(^o^)V
993 ：名無しさん＠カラアゲうまうま：02/10/28 14:28
梅v(^・^)v梅
994 ：デフォルトの名無しさん：02/10/28 15:34
埋め立て中
995 ：名無しさん：02/10/28 18:54
記念カキコ
996 ：デフォルトの名無しさん：02/10/28 20:37
ageちゃったりなんかして
997 ：ぉながいします：02/10/28 20:39

0～99の数字を1秒間隔で表示。１～９で改行、表示する
こんな感じです

１　２　３　４　５　６　７　８　９
10　11　12～～～～～～～～～～～～
～～～～～～～省略～～～～～～～～
～～～～～～～～～～～～～～～～99

これのプログラムを教えてください
よろしくお願いします
998 ：デフォルトの名無しさん：02/10/28 20:41
ってもうスレねーーーー
999 ：デフォルトの名無しさん：02/10/28 20:43
おれ
1000 ：名無しさん：02/10/28 20:43
999ｹﾞｯﾄｽﾞｻﾞｰ
1001 ：１００１：
このスレッドは１０００を超えました。
もう書けないので、新しいスレッドを立ててくださいです。。。