C++相談室

v(^・^)v

あげとくのv(^・^)v

CやめてC++に移ることのメリットとデメリットを教えてv(^・^)v

C/C++って書いたらハッカーを名乗る人に怒られました
どうしてですか？

>>4
そいつ、「ハッカー」じゃなくて「バッカー」じゃなかったですか？
もしかしたら、プロブラマかもしれません。

そのひといわく

CとC++は別のものだから一緒にしちゃだめだよ〜（笑
キミ、もっとべんきょうしたほうがいいよ
いまどきC/C++なんて書いてるようじゃだめだめだね。

ということだそうです。
「別だから」って意味不明です。

|C/C++って書いたらハッカーを名乗る人に怒られました
|どうしてですか？

ザーメンがたまってむしゃくしゃしていたんだよ。
そーゆーもんよ

C++でPerlなどのようなパターンマッチをしてくれる関数は無いんですか？

>>6
＞いまどきC/C++なんて書いてるようじゃだめだめだね。
時代は関係無いぜ。
そいつだってC++でCのライブラリ使ってんだろ？
コンパイラはC/C++両用だろ？
違うなら「別」でいいけど、氏んで欲しいナ！＞バッカー

>>8
Perlよく知らんのだけど、正規表現とか？lexとかじゃダメ？

class A {
public:
class B {
public:
void Set(const A& a);
private:
int m_nCnt;
}
private:
int m_nNum;
};

で

void A::B::Set(const A& a)
{
m_nCnt = a.m_nNum;
}

がコンパイルエラーになります。
コンパイラは「A::m_nNumにアクセスできないよ」
といいます。
そういうものなのでしょうか？

あらら、インデントがなくなってる・・・
見づらくてごめんなさい。

privateだし。
publicにしちゃだめなの？

>>12
publicしてもいいんですが
せっかくクラスをネストさせてるのに
アクセスできないんじゃさみしぃなぁとおもったので。
イテレータっぽいの書いてたんですけど
イテレータって、どうしてもコンテナの内部にアクセスしなきゃ
ならなくて、
なるべく公開するもの少なくしようとしてクラス（この場合イテレータ）を
ネストさせたんですが、上のようなエラーが無常にも出てしまったんです。
ネストしたクラスの特権（特徴）ってあんまりないんですかね？？

MFC的
#define offsetof(s,m) (size_t)&(((s *)0)->m)

class A {
public:
class B {
public:
void Set();
private:
int m_nCnt;
} m_xB;
friend class B;
private:
int m_nNum;
};

void A::B::Set()
{
A* pThis = ((A*)((char*)this - offsetof(A, m_xB)));
m_nCnt = pThis->m_nNum;
}

MFCってなんかすごそう。。。
ヌルポインタから->伸ばすあたりはドキドキものですね。。。

ところで
friend class B;
ならば、そこまでトリッキーにならなくてもいいんじゃないかと・・・
（というか、pThisがどこをアクセスしているのか良く分かりません・・・）

>>15
同じこと思いました。>>10のclass Aの中にfriend B;を加えれば全て解決です。

friend は誤解されることが多いのですが、これは安全のためにあるのですよ。
隠蔽度を高くするためにあるのです。
public な A::GetNum() const; を作るほうがはるかに危険だから、
firend を使うわけですよ。

class A に public インターフェースで m_nCnt を変更する
メソッドをつけるのはためしました？
ネストしたクラスっていうのは書いたこと無いんでわからないんだけど

あーごめん　ボケですな >>17

>>16
friendは安全のためなのですか。
そうだったのですか・・・了解です。
「friendは悪」と思っていたので
friend使わないで良い方法を探していたのですが
（それでネストしたクラスとか試してたんですが）、
friend使うことにします。

>>17
ありがとうございます。
とりあえずfriend使う方針で逝きます。
ネストしたクラスについても知りたかったのですが、
もうすこし自分で調べてみます。
では。。。

C++とJavaを較べると将来生き残ってそうなのはどちらですか？

２つ疑問があるのですが
ＶＣ＋＋６でＤＯＳ画面での実行結果がすぐに閉じてしまう。
あと、コマンドライン引数を打ち込むことができない｡
よかったらおしえていただけますか｡

[プロジェクト]-[設定]-[デバック]-[プログラムの引数]
で設定できると思う。

>ＶＣ＋＋６でＤＯＳ画面での実行結果がすぐに閉じてしまう。
!ボタンなら閉じないと思う。
それか、main()の最後に、_getch()とでも書いておく。

＞２３
ほお。
＞２４
なるほど。

ずっとＣの勉強はＬＳＩＣ８６でやってたんでなれてないです。
また疑問があったら質問しにきます｡
ほんとにありがとうございました｡

CLASS B{
　B();
　~B();
　AA* aa;
}

CLASS A:public AA{
　A();
　~A();
　B b;
}

という二つのクラスがあったとき
b.aaにAのthisポインタを渡したいんですけど、
AのコンストラクタではthisはNULLでした。
thisはコンストラクタが動いた後からしか使えないんでしょうか?

>thisはコンストラクタが動いた後からしか使えないんでしょうか?
そんなことは無い。

>>26
class B
{
private:
　AA *aa;
public:
　B(AA &);
};

B::B(AA &a)
: aa(&a)
{
}

class A : public AA
{
private:
　B b;
public:
　A();
};

A::A()
: b(*this)
{
}

こういうことをしたいのでしょうか？

>>19
>「friendは悪」と思っていたので
>friend使わないで良い方法を探していたのですが

gotoと同じで、無闇に使うのは悪です。
friendを使わなくてもいいのに済むならそのほうがいいですし、
上手く使うにはある程度の技量が必要です。
しかしこの例の場合のように、明らかに friend を
使ったほうが安全な場合もあるため、
無闇に嫌うのもまた問題があるのです。

>>28
ごめんなさい
A::A()
: b(*this)
{
}
みたいなのがちょっと良くわかんないので勉強してきます。

簡単にいうと、
AAは既製のクラスなんですが、
一部機能がわかりにくいので使いやすくまとめたクラスがBなんですが
やっぱり機能を使うには
aa->〜〜()
みたいにAAクラスのポインタを使ってるんです(^^;

単に馬鹿なだけでしょうか(^^;

>>29

これをコンパイル実行してみてください。
この方法は「初期化」と呼ばれる方法です。
「代入」と同じ効果を生むのですが、厳密には異なります。
　（たとえば、メンバフィールドが const 変数であった場合など）
詳しい議論は『Effective C++』の第１２項を参照すると良いと思います。

// 実行結果
// 777

#include <iostream>
using namespace std;
class Test
{
public:
int number;
Test();
};

Test::Test() : number(777)
{
}

int main()
{
Test t;
cout << t.number << endl;
}

>29
A::A():b(*this)は、
Aのメンバ変数bを、thisポインタが参照しているインスタンスの値
（つまり自分自身の値）を引数とするコンストラクタを起動して
初期化する、っていう意味だよん。

class BB{
private:
　AA*　aa;
public:
　void hage(){aa->hoge();}
}
とやるのは、オブジェクト指向の委譲の考え方。別に変じゃないよ。

ただ、そもそもclass Aとclass Bが相互参照している必要があるの
かどうかをチェックしてある？

>>28
申し訳ない、どあほうでした

単にクラスAが準備出来てないタイミングで
機能使おうとしてただけでした････

鬱だ････

>>30 >>31
たった今調べ終わったとこでした
解説ありがとうございました。

簡単に言うとMFCでCView(AAクラス)のスクロール関数を
外（Bクラス）にまとめただけです(^^;

AクラスがCViewの派生クラスで、いろいろと使いまわせないかなぁと(^^;

>32
最近Javaしかやってないので、間違ってると思うが
一応FactoryMethodパターンをどうぞ。
詳しい人突っ込みよろしく。

class B{
public:
　static const int TYPE_AA;
　static const int TYPE_A;
private:
　AA* aa;
　setAA(AA* in){aa = in;}
　B(){}
public:
　B~(){delete aa;}
　static B* create(int B){
　　B* instance = new B();
　　switch(B){
　　　case TYPE_A:
　　　　instance.setAA(new A());
　　　　break;
　　　case TYPE_AA:
　　　　instance.setAA(new AA());
　　　　break;
　　}
　　return instance;
　}
}
//static変数初期化
static const int B::AA=0;
static const int B::A=1;

使用法
B*　bAA=B::create(B::AA);//AAのインスタンスをBに持たせたいとき
B*　bA=B::create(B::A);　//AのインスタンスをBに持たせたいとき

間違った。

//static変数初期化
static const int B::TYPE_AA=0;
static const int B::TYPE_A=1;

使用法
B*　bAA=B::create(B::TYPE_AA);//AAのインスタンスをBに持たせたいとき
B*　bA=B::create(B::TYPE_A);　//AのインスタンスをBに持たせたいとき

ARMだったかプログラミング言語C++かなんかに書いてあったのですが、
「operator T()の定義は避けよう」と有ったのですが
理由がよくわかりません。やっぱり、あいまさの問題が出てくるからでしょうか？

operator T()？そんな定義できるなんて知らんかった。
デフォルトコンストラクタのテンプレート（になるのでしょうか？）
なんか作ってどうするの？

>>36
いや、キャスト演算子だと思う。

避ける理由は良くわかんないですが、
僕は暗黙の型変換がどうも好きになれないので書かないようにしてます。
（明らかに便利＆安全そうなものには書いちゃいますけど）
引数が１つだけのコンストラクタにはexplicit付けてます。

>>35
36のいうとおり、キャスト演算子ね。

避ける理由は
「More Effective C++」,Scott Meyers,安村 通晃 他訳,アジソン・ウェストレイ,1998
ISBN4-7561-1853-4
項目5:ユーザ定義の変換関数に気をつける
を参照してちょうだい。

ちょう要約すると「基本的な問題は、このような関数がしばしばあなたが望みもしなければ
期待もしないようなときに呼ばれてしまうことにある。結果は正しくなくなることもあれば、
診断が気の狂うほど難しくなるような、直感的でないプログラムの振る舞いに
なることもある。」

　wide characterを使った処理をしたいのですが、
wofstream に wchar_tで出力しても、ofstreamにcharで出力しても
結果がまったく変わりません。バイナリモードでファイルを開いても
だめです。例えば、L'A'を出力したときに、0x4100がファイルに
入っていればいいんですけど。
この厨房をお助けください。

　すいません。39です。処理系を書くべきでした。
　環境はWindowsNT4でVC6です。ただ、質問がVC関係ではないので
ここを選ばせてもらいました。よろしくおねがいします。

>>39
うん、だから入出力時にマルチに変換してる。
ライブラリの問題以前に規格やフォントの問題もあるし。
linuxだとwctomb関数がマニュアルにある。
(マルチスレッド云々と状態の切り替えの話に注意して読んで）

みんなC++を使うのだage

DOSの16bitの環境で動作するANSI C++に追従してる処理系ってあります？
DJGPPみたいに、DPMI上で動く様なのは除外してください。
つまり80186で動く様な物です。
テンプレートはでかくなるので無くても良いですが。
（すると、ライブラリの大半が使えない？）
「例外」程度は使いたいです。

BCC45

>>44
Borland処理系は4以降からDPMI使ってるみたいなのでだめです。

>>45
TC++1.0
一番初期のヤツね。ディスク３枚組みのヤツ。
正真正銘16BitDOSでC++。
80186オプションもちゃんとあるぞ。

>>46
43の「ANSI C++に追従している」という意味は、多分
RTTIやnamespaceや例外やテンプレートのような後発の仕様、
および STLその他現在の標準C++ライブラリをサポートしている
という意味だと思うが....俺は知りません。
しかしテンプレート使うとモノがでかくなりがちであり
pureなDOS環境ではちと厳しいのでは。

複数のクラスから使いたいサブルーチン（memcpy類似のアプリ固有
のよく使う処理）って、どういう名前空間に置きますか？
アプリのメインのクラス内にpublicで置くと、そのクラスのインス
タンスをexternするか、子クラスにポインタを渡していかなければ
ならず、すっきりしません。
かといって大域に置くのも何かＣくさくて嫌なのです。

singletonにすればー．

>>47
43はテンプレート無しで良いっていってんじゃん。よく読め。
RTTIって使ってる奴いんの？その辺はどうだか知らん。

>>48 はstaticなメソッドを知らないらしい。

>>50 Embedded C++ だね、それ。
RTTI を使っているやつは存在する。
オブジェクト指向初心者は多重継承を下手に使って失敗する。
オブジェクト指向中級者は多重継承を嫌って使わない。
オブジェクト指向上級者は多重継承を上手く使って楽をする。

ちなみに俺は中級者。

ATL固有の話になってしまって申し訳ないのですが、
CWindowImpl<>::Create()
ってオーバーライドしても平気なのでしょうか？
オーバーライドする必要があるのですが、virtual宣言されていないので
どうなってしまうのでしょうか。

実際に使ってみたところ問題なく使用できているのですが、
正しいのか間違いなのか、教えてください。

>>52
virtualをちゃんと勉強しよう。
ライブラリ的には問題ないと思う（信じたい）けど、
52の使い方次第。
virtual宣言すると、派生元のクラスのポインタで呼んでも、
派生クラスで生成してれば派生クラスのメンバ関数が呼ばれる。
（デストラクタだとちょっと違うが）

オーナードローボタンクラスを作ってたのですが、
生成するたびにBS_OWNERDRAWを指定させるのもなんだかな、って思ったので、
CreateをオーバーライドしてBS_OWNERDRAWをしていしてから
CWindowImpl<>::Create()に渡しているのですが、
この場合問題なさそうですね。

>virtual宣言すると、派生元のクラスのポインタで呼んでも、
>派生クラスで生成してれば派生クラスのメンバ関数が呼ばれる。

これはわかっていましたが、オーバーライドさせるときは無条件で
virtualと思ってたので、質問しました。
やっぱりプログラミング言語C++買うべきですね。
あれってCと違ってべらぼうに高いんですが(^^;

高いのは理解できなくなもないが、
分厚くてでかいのがきつい。
持ち運び不便。

１行目
なくな→なく

おいら、多重継承は前まで絶対しないことにしてたんだけど、
Javaを覚えてからは、C++で多重継承するときは必ず片側は
完全抽象クラスのみにするようになった。
関数実装の多重継承は禁止。これで安心。僕って上級者？？？

ボーランドサイトでTurboC++1.01が見つかりましたので、これで我慢します。
ちなみに例外は使えない様です。4.0からかな？
ついでですが、RTTIや名前空間とかは使わないです。>47
#C++はもっとCみたいにコンパクトな言語にならないですかね。

いままでわたしはCでOO風に書いてきました。
CでOO風に書く利点としては、Cさえ動けばどんな環境でも使える事ぐらいですが、こういう事やってる（やってた）人います？
不便な点は、Cではinlineキーワードが標準で使えないから、アクセサの効率を上げる為に、処理系毎に__inlineだの、static __inline__だのをマクロ定義しなきゃいけないとか、色々面倒が多いですが。
それと、他人にソースを渡す場合は困りますね。
いちいち書き方の説明する様な事をしなくちゃいけないんで。
そういう時はC++でラップして渡しています。（二度手間ですが）

RTTIって何に使うの？用途が思い浮かばない。デバッグ？

callback してきたオブジェクトをいつ delete するか悩んでいます.
例えば...

class B {
public:
　B(A* a) { a->onCallBack(); }
};

class A {
public:
　B* createB() { return new B(this); }
void onCallBack();
};

とかなってる場合,
B のインスタンスはいつ delete すればよいですか?
A::onCallBack() に B* を乗せて
void onCallBack(B* b) { delete b; }
とかするのはだめですよね.

つまり, callback 後は必要ないオブジェクトの破棄をいつ行うか?
ということなんですが, いい方法あるでしょうか?

>59
多分CでOO風に書くって、1ファイル1クラスに見立てて、ファイルスコープ
のグローバル変数をインスタンス変数に見立てて、そのファイルの関数を
唯一のそのグローバル変数へのアクセス手段にするようにするとかだよね。

CでOO風に書いても、クラスとインスタンスの関係は実現できないので
ポリモルフィズムが表現できないと思うんだけど、其の辺は無視？
単なる概念モジュールの階層構造化を指してOOと呼んでるのでしょうか？

>60
ポリモーフィズムの意義を勉強せよ。

>61
よう分からんが、Bのインスタンスはスマートポインタで
ラップして値で持ちまわるようにしたら？

>>62
RTTIでポリモフィズムとなると、
typeid演算子を使って、実際のクラスを判別するんですか？
かえっておかしなことになるような。

なんか勘違いしてます？

>>62
グローバル変数は一切使いません。
インスタンスはスタック、またはヒープに確保します。
シングルトンパターンの実装やリソースカウンタなどはstaticな変数を使いますが。
多態が必要な場合、typeid(実はenumやint)と関数のポインタテーブルを使って実装します。(かなり面倒ですが。)

>>60
RTTIはtypeidよりはdynamic_castでよく使うんじゃないかしら。

用途としては、抽象クラスのポインタ(参照)しかとれない場合(たとえば
抽象クラスのポインタのコンテナをイテレートするとき)に、なんらか
(派生クラスでしか定義されていないメンバを呼びたいとか)の理由で
ダウンキャストしなくちゃいけないときが一番多いかしら。
なるべく使いたくないけど、compositeパターンなんかを使うと
ある程度は使わざるをえなくなることが多いわ...

なるべくdynamic_castを使わずにすむように心がけながら設計
してるけどね。

>>61
まず所有関係に注意しながら設計を見直すのが最初だと思うわ。多くの場合は
きちんと考えれば、どのインスタンスをいつ破棄すれば良いかは明確にできると
思うけど。
それが難しい場合(スレッド間で受け渡しするインスタンスなど)は、63の言うとおり
何らかのスマートポインタを使うのがいいんじゃないかしら。
でもうまく使わないとバグの温床になるわよ。気をつけてね。

わかったからそのネカマ言葉をやめてくれ

>67
C++を知らない奴が、スマートポインタに関数内のローカル変数の
アドレス渡して、その後原因不明で落ちる！と大騒ぎするのを
多々目撃しております。

>>66
RTTIってdynamic_castも含めるのね。dynamic_castなら使っていますので解かります。
てっきりRTTI=typeidで得るclass type_infoのことかと思い込んでいました。
親切な回答ありがとうございました。

では改めて質問。
typeid演算子、ならびにclass type_infoって何に使っていますか?

デバッグ用機能です

>>69
やりがちよね。
class Foo {
protected:
Foo();
public:
virtual ~Foo();
public:
static SmartPointer<Foo> create();
};
みたいにして、スマートポインタの使用を強制するようにしてるわ。

>>70
めったに使わないわ。おもにassertで使うわね。
派生クラスじゃなくて、ぜったい特定のクラスのインスタンスが
欲しいときとかに assert( typeid(*ptr)==typeid(Foo) );とか。

ミリ秒間、何かの処理をさせるみたいな時に使う時間をはかるもの
タイマーって言うんでしょうか？
そういったタイマーで、一般的に使われる関数を教えて下さい

>>73
時間を計るなら clock かな？

winapi -> SetTimer()

精度が必要ならマルチメディアタイマー

>>63
B を作るオブジェクトは最後まで死なないので
スマートポインタは使えなさそうな気がします.
なんか間違ってるかな.

>>67
設計見直しですか.
いや, そんな気はしてんだよなぁ.

もちっと考えてみます.
2人ともありがとっ

なるほど
ありがと、７４・７５・７６

class A
{
public:
　　A();
private:
　　const int m_data[10];
};

で、class AのコンストラクタA::A()を書こうとして困ってしまいました。
A::m_data[10]の初期化はどのように書けば良いのでしょうか？
constにしているのは困っているところを強調するためなのでご了承ください。
メンバ配列の初期化ってムリなんですかね・・・

>>79さん
const を外して
A::A(){
  for( int i=0; i<10; i++)
    m_data[i] = i;
}
です。

・・・だと思います・・・自信なし・・・。

あああ〜〜〜〜
やっぱし違うと思います。すいません。無視してください。

A() {
　int i;
　int * p = (int *)m_data;
　for( i = 0; i < 10; i++ ) p[i] = 0;
}
こんなんど？

>>80,82
質問のしかたがまずかったかもしれません。
やりたいこととしては

A::A()
: m_data(????)
{
　//ここには書きたくないのです・・・
}

のように初期化列の中に配列の初期化を書きたいなぁと思ったのです。
普通のメンバ変数だったら

class B
{
public:
B() : m_data(0) {}
private:
const int m_data;
};

みたいに書けるのに、配列はどう書けばよいのやら・・・
どうあがいてもムリ？？

配列はできないような…？std::vectorじゃだめ？

>>84
std::vectorほどの柔軟性は必要なかったりしてるんです。
動的にメモリ確保されても困るので・・・
具体的には今３Ｄのプログラム組もうとしていて、
４次元ベクトルのクラスとか作ろうとしたとき
struct Vector
{
　　Vector(float x, float y, float z, float w);
　　float m_data[4];
};
てな具合にしたのですが
m_data[4]の初期化で困ってしまったということでした。

やっぱり配列はどうしようもないようですね。
あきらめて80,82さんのようにコンストラクタの{}中に書きます。
ありがとうございました。

つうか、配列でそんな書き方できるほうが危ないんだよ。
もうすこし勉強しないとわからんかもしれんが。

最近、vectorやlistを独自の使ってるのを見ると、
素直にSTL使ってくれって思うぜー。
メモリは先に必要な分だけ確保しておけば問題ないぜー。

初期化列の中に、初期化する変数書く利点ってなんだ？
配列は初期化できないし…？

利点というよりそこに書かなきゃならない場合があるだけです。
逆に言えば初期化列に記述できないものはそもそも初期化列
で初期化する必要がないという事。
つまり今回の例は「ここに書きたくない」なんてゴネてないで素直に
{}に書けつーことです。

デバッグ用に内部データがデバッガで見やすくかつ鬼のように
チェックの厳しいSTLの実装ってどこかにない？

>>87
キミ、ちょっとズレてるよ。

>>89 利点というよりそこに書かなきゃならない場合
ってのはどういう場合なのん？

デフォルト以外で初期化したい基底クラスや
デフォルトコンストラクタを持たないオブジェクト、
参照やconstオブジェクト、
効率のためデフォルトの初期化を行ないたくない場合とか
その他いろいろあるっしょ

{ } 内では、できない初期化があるってことなのか…。

配列自体を病める方に一票。

Ｃでは
struct ta sub()
{
struct ta a;
return a;
}
は禁じ手ですが(autoのstructを返すため)
Ｃ＋＋では
CString xxxxx()
という関数がいっぱいあるのはなぜでしょう？
Ｃ＋＋ではクラスのリターン値は保証されるのですか？

>>96
C++でもauto領域のリターンは御法度だ
ソースはみたか？
CString xxxx()のなかでauto変数領域返してるか？

御法度じゃないぞ。代入コンストラクタって言葉知ってるか？

returnで代入コンストラクタが働くって意味かい?

>returnで代入コンストラクタが働くって意味かい?

そうよ。

AnyClass obj;
obj = anyFunc(なんかの引数);

とかで、anyFuncがAnyClassのautoオブジェクトをreturnしてたら、
1.AnyClass::AnyClass(const AnyClass&)でリターン用臨時オブジェクトが作られる。
2.AnyClass::operator=(const AnyClass&)で臨時オブジェクトがobjへコピーされる。
3.臨時オブジェクト消滅
てなことが舞台裏で行われるのです。

処理系の実装によっては、もちょっと最適化されるかも知れんけど。

でも、96みたいなのも近頃のCでは
御法度じゃなかったんじゃない？

struct ta* func() {
　struct ta taObj;
　return &ta
}

は、おもくそまずいけど。

ちがった、

struct ta* func() {
　struct ta taObj;
　return &taObj;
}

だ。

ちなみに
AnyClass obj = anyFunc(なんかの引数）
ってやったらどうなるか考えると面白いぞ

>>96
101も言ってるけど、それが禁じ手なんて初めて訊いたよ。
どこのダレがどういう理由で禁じ手にしてるか教えてくれ。

コピコンちゃんとつくるの忘れてるくせに
オブジェクトリターンかましたあほが広めてるんじゃないの？
>>104

おそらく，
　・構造体はでかいからポインタでやりとりしたほうがいい
　・autoなオブジェクトへの参照を返してはいけない
が，どこをどう勘違いされたのか
　・autoな構造体オブジェクトは参照でかえせないから，
　　リターンしてはいけない
と勘違いされたんじゃないかな。C言語でもautoオブジェクト
を値で返す分には支障はないよ。

原理がわかってないとこういう勘違いが起こるんだろうね。

>>105
ありそうだな。でも96は、
「Ｃでは…は禁じ手ですが…」
と言ってんだよね。

　　　　　　　うぇーん、Ｃ＋＋なんかきらいだー
　　　　　　　　￣￣￣∨￣￣￣￣￣￣
　　　　　　　　　 　∩＿∩
　　　　　　　　　　（ ´Д⊂ヽ
　　　　　　　　　⊂　　　　ノ
　　　　　　　　　　 人　 Ｙ
　　　　　　　　　　し （＿）

>>107
む、確かに。

101、102！
余計な口挟むんじゃねぇ！C厨房ゴﾙｧ！

なんつってな、無視したんだよ、虫。

番号間違えた。
よって意味不明。
逝ってきま〜す。

もりあがってるところ申し訳ないのですが、
>>93
constなメンバ変数の初期化は初期化列に書くしかないわけですよね。
で、僕が最初に質問してたんですが、

class A
{
public:
　　A();
private:
　　const int m_data[10];
};

みたいな作りにしなきゃいけないってことになっら
A::m_data[10]はどのように初期化すればよいのでしょう？
>>82 みたいに強引にやるしかないんですかね。。。

初期化のときだけconst_castしたら？

そうですね・・・あきらめます。
あぁ、どうも配列だけC++の中で異質な感じがする今日この頃。。。

96の言い分も少しは正しい。(かった?)
まず、昔のCコンパイラは構造体の(ポインタではなく)インスタンスを返せない物があるって事。
返せても特別な領域(strtokと同じ様な場所)に一旦コピーするものもあったから、そういう処理系ではスレッドセーフにもできなかった。
よって、そういった処理系での互換性をも保とうとしているプログラマから見れば、構造体を返却値に持つ関数を定義する事は「禁じ手」であると言える。
現在のANSI-Cに準拠する処理系でのみ動作を期待するプログラムならば、スタックにコピーするので問題ない。
こんなんでどう？>96,その他

>113
まあねー。クリティカルセクションじゃなけりゃSTL使うわな。

>>114
まぁ，確かに。

>>113 ,(111,79)
うーん，要素数をテンプレート引数に取るテンプレートな
スマートアレイじゃだめなの？

const配列メンバはstaticじゃなきゃ。
よって、素直にクラス使っとけ。

クラス内のconstは実装部で宣言して初期化もそこでする。
effective c++、ずばり一章。

class aaa{
public:
static const int const bbb[10];
void showprivate(void)
{
for(int i=0;i<10;i++)
cout << ccc[i] << ":";
}
private:
static const int const ccc[10];
};

const int const aaa::bbb[]={0,1,2,3,4,5,6,7,8,9};
const int const aaa::ccc[]={10,11,12,13,14,15,16,17,18,19};

int main(int argc, char* argv[])
{

for(int i=0;i<10;i++)
cout << aaa::bbb[i] << ":";

cout << endl;

aaa c;

c.showprivate();

cout << endl;

return 0;
}

>>116
template <class T, size_t N>
struct CArray { T m_data[N]; };
みたいな感じのを配列の代わりに使えってことでしょうか？
んんん、、、問題を先送りにしている感じがしないでもないですが
改善になるのかな？
class A
{
public:
　　A(const CArray<int,10>& data)
　　: m_data(data)
　　{}
private:
　　const CArray<int,10> m_data;
};
で無事constな配列の初期化ができました（なのかな？？？）

>>117 >>118
staticなconstの配列だったら悩まなくてもokですね。
でも今回の場合staticではないconstな配列の初期化で悩んでたので・・・

>>115
思う存分STLが使える開発っていうのも一度やってみたいです。。。
（でもきっとSTLの実装が気になって思う存分使えないんだろうなぁ＞自分）

>>119
そうそう，そういうの。メモリ上の配置も素の配列と変わらないから
いけると思うんだけど。

そこまで初期化式にこだわる理由がわからない・・・

>>120
たしかにCArrayのコピーコンストラクタで初期化できるようになったのは
改善だと思うのですが、class A に
A::A(int a0, int a1, int a2, int a3, int a4,
　　　int a5, int a6, int a7, int a8, int a9)
みたいなコンストラクタも欲しいなぁとなると、またconst_castの
お世話になってしまいますよね・・・
CArrayの初期化の方法が、コピーコンストラクタと配列の初期化の
方法しかないからしょうがないんですけど・・・

まあ、あまりダダをこねないで、
配列と仲良くやっていこうと思ったのでした。

>>121
気になるとこだわってしまう性格でして・・・すみませんでした。

>そこまで初期化式にこだわる理由がわからない・・・

79氏は，リアルタイム処理やゲームプログラミングをなさってるんじゃないかな？
初期化式で初期化すれば，デフォルトのメンバ初期化をスキップできて
効率がいいし，STLを使わないのも，メモリ領域を静的にとりたいのか，もしくは
開発環境が組み込み用とかでSTL自体が整備されてない環境とか？

<stdio.h>　ってスタンダードアイオーヘッダーって読みますよね。
今日学校の教師に　<string.h>　の読み方を　「スタンダードリングヘッダー」って教わりました。
これって「ストリング」って読むんじゃ無いですか？
自分は間違いだと確信有るんですが。

それと教師に指摘してあげるべきだったでしょうか。

>79氏は，リアルタイム処理やゲームプログラミングをなさってるんじゃないかな？
むむむ、、、なんか書きこみにクセとかありました？？
んーとりあえず退散します。ありがとうございました。

>>125
stdio.h ... スタジオ・ヘッダー
と読んでいました。学生の頃。

というか、Ｃ的話題？

>>125
そういうのは、わかっていても言わないの。

みなさんありがとうございました。そしてごめんなさい。
Ｃの所は引き合いに出すために適当に書いてしまいました。
101さんのようなことはまずいと言いたかったのです。
知りたかったのはCStringの戻り値のみなので
理解できました。
もっと勉強します。

質問なのですが
http://demo.and.or.jp/makedemo/mini_class/file_search/index.html
にあるソースをbcc5.5.1でコンパイルしたのですが
エラー E2285　'output_filename::operator () <_NAME,_MORE_INFO>(string,_WIN32_FIND_DATAA)' に一致するものが見つからない(関数 search_file<string,output_filename>(string,string,const bool,output_filename &) )
*** 1 errors in Compile ***
というエラーが出て困ってます。どうすれば回避出来るのでしょうか？

ネタなんだろうけど・・・
#include <windows.h>
って行は先頭辺りにある?>130

あ、#endifが無い様だね。そのソースとヘッダもう一度よく見てみると良いよ・・・>130

>131、>132
#include <windows.h>はあります。
#endifもエラーで出たのですぐに書き加えました。
それでもやっぱりエラーになるんですよね。
なぜなんでしょうか？記述ミスがまだあるんでしょうか？

>>130
テンプレートメンバ関数は、コンパイラによっては正確にコンパイルできないことが
多かったわ。
テンプレートメンバ関数を無くして書き直してみたらどう?
動けばメンバテンプレート周りのコンパイラのバグ。
動かなければその他の原因ね。

#この程度の機能をテンプレートメンバにする必要性は感じないけどね。

>>134
それはもう既にやってみたんですが、一応ちゃんと動きました。
やはりbccのバグなんでしょうか？
バグならあきらめるしかないですね・・・。

>>135
バグだと思うわよ。
短いコードでバグが出せるなら、サポートに送っておくといいわ。
次のバージョンで直る「かも」しれないしね。

あとは
・テンプレート引数の数を減らす
・テンプレート引数を明示する
とかして、コンパイラが探索しなくちゃいけない範囲を限定してあげると
通ったりすることもあるわよ。でも不毛な努力になることが多いから
お勧めはしないわ。

>>136
わかりました。出来たらサポートに送ってみようと思います。
不毛な努力の方も試してみます。
ありがとうございました。

>>130
テンプレートメンバ関数の引数をconstにするとうまくいったよ。

template<class _NAME, class _MORE_INFO>
void operator()(_NAME &filename, _MORE_INFO &info)

を

template<class _NAME, class _MORE_INFO>
void operator()(const _NAME &filename, const _MORE_INFO &info)

でどう？

ちなみにこれはテンプレートメンバ関数が原因ではないかも。
下のコードでも同様なエラーになります。

template <class T>
T add(T& lhs, T& rhs)
{
　　return lhs + rhs;
}

int main()
{
　　return add(1, 2);
}

これも同様に引数にconstを付けるとokになります。
この動作って、bcc固有？ C++の仕様？
手元にあるコンパイラがbccしかないので確認のしようがない・・・
どなたかhelp・・・

>>138
おお！const付けると上手く行きました。ありがとうございます。
自分もbccしか使ってないので
VCとかで確かめられないのがつらいです。

VC++ ではconst無しでも通るみたいっす。>>138-139

質問です。レベル低くてすいません。
ファイルポインタをファイルの先頭に移動するために
ifstream::seekg() を使用しましたが、うまくいきません。

ifstream ifs("filename");
<-- 読みこみ処理 -->
ifs.seekg(0, ios::beg); // <- ポインタを先頭に
<-- 読みこみ処理。でも読めない…

間違ってますか？

>>138
C++の仕様上、非const参照の初期値は左辺値でなければならない。
だからエラーになるのが正しいと思う。
エラーにならないコンパイラは古いソースとの互換性を
考慮してるのではないかな。

>>142
なるほど。 >>138 の add(1,2) の「1」とか「2」は
左辺値ではないですね（右辺値?）
>>130 の例では、filesrc.hの65行目の
op(strCurrentFolder+"\\"+FindData.cFileName, FindData);
の第１引数「strCurrentFolder+"\\"+FindData.cFileName」が
左辺値ではないんですね。

侮りがたし＞bcc

>>141
オープンには成功しているわけですね。
お使いの処理系は？　C++の規格だと，ios::begじゃなくて
iso_base::begですよ。古いヘッダを使ってるとか？

あ，ごめんなさい。タイプミスです。

iso_base::beg
↓
ios_base::beg

>>79

効率はどうでもいいなら，こんなのはどうですか？

#include <iostream>
#include <cstdarg>
#include <cstddef>
#include <algorithm>
using namespace std;

template<class T, size_t sz> class Array {
T buff[ sz ];
public :
Array() {}
Array( size_t n, ... ) {
va_list ap;
va_start( ap, n );
for( size_t i = 0, lim = min( sz, n ); i < lim; i++ ) buff[i] = va_arg( ap, T );
va_end( ap );
}
template<class T2, size_t sz2> Array( const Array<T2, sz2> & a ) {
size_t lim = min( sz, sz2 );
for( size_t i = 0, lim = min( sz, sz2 ); i < lim; i++ ) buff[i] = a[i];
// sz < sz2 の場合は例外を投げても良いかもしれない
}
// コピーコンストラクタとコピー代入演算子はデフォルトで十分

T& operator[]( size_t i ) { return buff[i]; }
const T& operator[]( size_t i ) const { return buff[i]; }
// 添え字範囲が範囲外なら例外を投げるat()を定義しても良いかもしれない
operator T*() { return &(buff[0]); }
operator const T*() const { return &(buff[0]); }
};

template<class T, size_t sz>
Array<T, sz> AIL( T first, ... ) { // ArrayInitList
Array<T, sz> temp;
va_list ap;
va_start( ap, first );
temp[0] = first;
for( size_t i = 1; i < sz; i++ ) temp[i] = va_arg( ap, T );
va_end( ap );
return temp;
}

template<class T, size_t sz, size_t n> // 一応用意
Array<T, 0> AIL() { Array<T, 0> temp; return temp; }

struct A {
typedef Array<int, 10> myArray;
const myArray array;
A( const myArray & a ) : array( a ) {}
};

int main() {
A obj1( AIL<int, 5>( 10, 20, 30, 40, 50 ) ); // <- こんな感じで引数をグループ化します
for( int i = 0; i < 10; i++ ) cout << obj1.array[i] << endl;

A obj2( AIL<int, 10>( 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 ) );
for( int i = 0; i < 10; i++ ) cout << obj2.array[i] << endl;
return 0;
}

>>141
ひょっとして，１回目の読み込みでios_base::eofbit
が立ってませんか？

シーク前にclear()を呼んでみて下さい。

ifstream ifs("filename");
<-- 読みこみ処理 -->
ifs.clear(); // <-ここ
ifs.seekg(0, ios_base::beg); // <- ポインタを先頭に
<-- 読みこみ処理 -->

ifs.clear()を使用することでうまくいきました。
どうもありがとうございます。
処理系はVisualC++6.0 SP4 on NT4.0です。

ios_base を使おうとしたら、シンボルエラーで使えなかったので
ios::begのままです。
調べてみると、インクルードファイル(.h)にはios_baseクラスは
見つからなかったのですが、どうしてでしょうか？

>>148
うまくいって良かったですね。

>ios_base を使おうとしたら、シンボルエラーで使えなかったので
ios::begのままです。
調べてみると、インクルードファイル(.h)にはios_baseクラスは
見つからなかったのですが、どうしてでしょうか？

拡張子のつくC++用の標準ヘッダファイルは，規格化以前の古い
仕様です。その古い仕様のライブラリでは，ストリームクラスの
最も基底なクラスはiosでした。

というわけで，VisualC++6.0 SP4 on NT4.0がC++の標準規格に
準拠していて，事情が許すのなら，<iostream.h>ではなく，
<iostream>を使って，標準規格にそったライブラリを使うことを
すすめます。

私の悩みを聞いてください。このようなコード(もちろん簡略化したもの)

char input_buffer = new char[1000];
char output_buffer = new char[1000];

strcpy(input__buffer,"ABCDEFG");
strcpy(output__buffer,input_buffer);

delete input_buffer;
delete output_buffer;

を実行し、input_bufferとoutput_bufferをウォッチリストにいれて観察
するとoutput_bufferの中身が消されずリークができてしまいます。どうして
でしょうか？わたしは初心者以下だからでしょうか？ハロプロのコンサートに
向けていち早くこのコードを完成させなくてはなりません。教えてくれた方に
は私の処女上げます。辞退なさっても結構ですけど。

とりあえず delete [] input_buffer; delete [] output_buffer;
としてみよう。

inline 関数を C++ ファイルに extern でなく
static リンケージで定義する方法がわからなくて悩んでいます。
よろしければどうか教えて下さい。

--- header
class Hage {
private:
　inline void f();
}
--- c++ file
inline Hage::f() { ... };
---
と定義すると friend のために .global なやつも
コンパイルしてしまうのでサイズが膨れて勿体無いです。

こういうのも考えたのですが
static inline Hage::f( class * phage, ... )
{
　phage->.. = ;
}
もっと綺麗に書けないでしょうか？

>>１５１
試したわよもう。でも不思議と何も起こらない。よかったら
試していただけないでしょうか？

>>150 >>153
突然ですが、
char input_buffer = new char[1000];
char output_buffer = new char[1000];

を
char *input_buffer = new char[1000];
char *output_buffer = new char[1000];

こうしてみたらどうです？

教えてください。
C++、またはWinAPIで、
IEのバージョン取得をしたいのですが。。。

>保田圭
>>151>>154この両方を追加すれば解決

>>152
うーん，いってる意味がよくわかりません。
「friend のために .global なやつも
コンパイルしてしまうのでサイズが膨れて勿体無いです。」
という部分が不鮮明で。friendが登場するなら，それも示して
いただけますか？　あと，「global なやつ」ということですが，
これは，「クラスの外で定義されたメンバ関数」という意味でしょうか？
（「クラスの外で定義されたメンバ関数」はスコープ的にはグローバル
ではないので）

これで上手くいかないなら、俺にはわからん。
ちなみに delete は確保したメモリの中を 0 で埋めてから
開放したり、ポインタを NULL にしない。

char * input_buffer = (char *)new char [1000];
char * output_buffer = (char *)new char [1000];

assert( input_buffer != NULL );
assert( output_buffer != NULL );

strcpy( input_buffer, "ABCDEFG");
strcpy( output_buffer, input_buffer);

delete [] input_buffer;
delete [] output_buffer;

// input_buffer, output_buffer は NULL にはならない。

説明不足でした、すみません。(^^;)

152の f() のようにインライン関数の中身をヘッダファイルでなく
C++ ファイルに定義すると、見た目すっきりしますよね。
それに外部から呼び出すことはないので private として
このオブジェクトファイルで f() を完結させたいと思っています。
（外部にリンケージしないようにしたいなぁと・・）

もし他のオブジェクトファイルから f() を呼び出そうとしても
private なので呼び出せません。でも実際にアセンブラリストを
見てみるとインライン展開される一方で、外部からもアクセス
できるように .global な関数も生成されていました。
ここからは私の推測なのですが、ヘッダファイルで定義されていない
関数にアクセスしようとすると "Unresolved External" あたりの
エラーをだしても良い（私としてはここはこれが好ましいのですが）
のですが、コンパイラが friend で他の翻訳単位からこの関数を
使用してくることに備えて、.global で外部から呼び出せる名前の
関数を生成しているのかな・・と思いました。

ヘッダファイルのクラス宣言で f() を宣言しているのが問題に
なのでヘッダファイルから削って C++ ファイル側に static inline で
定義したのが下のほうの関数です。でも、こうするとクラスの変数に
触れないんですよね。(^^;;;) それでクラスのポインタを受け取って
アクセスするようにしているのですが、アクセスには private やら
問題山積なような。

こういった問題を上手く書く方法があれば・・どうかご教授して
いただきたく質問させていただきました。長くなってごめんなさい。
処理系は gcc 2.95 です。

こうやって、HageImpl::f()別に作ったらだめでしょうか。
Proxyパターンですな。

もしHage::f()使わなければ、HageImplはインスタンスも
作られないので、なにかとお得。

class Hage{

HageImpl* impl;

Hage(){impl = null;}
virtual ~Hage(){if(impl)delete impl;}

inline void f(){getImpl()->f();}

HageImpl* getImpl(){
if(!impl)impl = new HageImpl();
return impl;
}
}

>>160
関数定義をヘッダーファイルに直接書いて、

g++ -O

じゃない？

>>159
補足説明，ありがとうございました。以下，ヘッダとソースファイル
が次のようだとして話を進めます。

--- header "hage.hpp"
class Hage {
public: // <- アクセス制御はコード生成には根本的に影響を与えないのでpublicとしておく
　inline void f();
};
---

--- c++ file #1 "hage.cpp"
inline void Hage::f() { ... };
---

--- c++ file #2 "main.c" (Hage::f()は使わない)
#include "hage.hpp"
int main() {
　Hage h;
　return 0;
}
---

--- c++ file #3 "g.c"
#include "hage.hpp" (Hage::f()を使う)
void g() {
　Hage h; h.f();
}
---

>152の f() のようにインライン関数の中身をヘッダファイルでなく
C++ ファイルに定義すると、見た目すっきりしますよね。

こうすると，hage.cppの翻訳単位ではインラインになる可能性がありますが，
g.cではインライン展開されず，通常の関数コードとしてhage.cppの翻訳単位に
追加で生成されます。g.cの翻訳単位からは，通常の関数呼び出し手続きを
つかって，このhage.cppの翻訳単位に追加生成された関数コードを呼び出す
だけです。

もしかして，「.global な関数も生成されていました。」というのは，この
通常の関数コードじゃありませんか。

いろいろ状況を見ると，ヘッダファイルにインライン関数の定義を書けば
解決するように思えるのですが....。

--- header "hage.hpp"
class Hage {
public: // <- アクセス制御はコード生成には根本的に影響を与えないのでpublicとしておく
　inline void f(){ /* 定義もここで */ }
};
---

う，ちょっと説明がまずかったですね。

>こうすると，hage.cppの翻訳単位ではインラインになる可能性がありますが，
g.cではインライン展開されず，通常の関数コードとしてhage.cppの翻訳単位に
追加で生成されます。g.cの翻訳単位からは，通常の関数呼び出し手続きを
つかって，このhage.cppの翻訳単位に追加生成された関数コードを呼び出す
だけです。


とはつまり，インライン指定した関数は，必ずインライン展開されるとは
かぎらず，インライン展開できないときのために，通常の関数コードも
生成しておく。ということです。つまり，上の例ではmain.cにf()の通常の
関数コードも追加される，ということです。インライン展開が必ずしも
可能でない状況の例としては，インライン関数のポインタを得るよな場合
なんかがありますね。

皆様ご教授いただきありがとうございます。
ソースリストの見やすさと手間を天秤にかけて考えてみました。
クラスの変数を使う場合は、皆様のおっしゃるとおりヘッダファイルに
定義してしまうほうが一番良さそうですね。
そう書くことにしました。

個人的には表に出したくない関数の定義はその翻訳単位で定義できるほうが
美しいと思うんですが・・（他の人が使わない関数なのに、インライン化
するために他の人も見るヘッダファイルにずらっと書くのは分かりづらい
のではないかと・・）

>>161
関数が必要になったときにインスタンスを生成して呼び出すプロクシ型
なんですね。これならメモリを有効に使ったり、必要以上に多くの
オブジェクトが生成されずにすみそうです。
152は生成コードが大きくなってしまっているのでたぶんこの方法では
生成コード自体は小さくならないかもと思うのですが
（間違ってたらごめんなさい）でも、この方法はとても実践的ですね。

>>162
はい。たぶん それがただしいと思います。
ただインライン関数が数百行になってくるとなんとかしたくて・・。

>>163=164

解説ありがとうございます。

>もしかして，「.global な関数も生成されていました。」というのは，この
通常の関数コードじゃありませんか。

はい、そうです。うーん、、そういえば inline って「できるなら展開する」
なんですよね。とすると friend のため、っていうのは外れですね。
そういえば for ループがあると展開しないコンパイラもあるとか・・。

高速化するために C++ のファイルからヘッダファイルに移して inline にする
と見づらくなっちゃうので、、良し悪しかもしれないですね。

理解が曖昧なので誤解していた部分が、多々あったみたいです。
ご意見で大変勉強になりました。ありがとうございます。

>>158さんありがとう
まだそのコード試してないんですが、そのコードの意味を教えていただけないですか？
おそらくＣｈａｒポインタ１０００個のＡｒｒａｙとしているんだと思うんですが
そうすると
strcpy( input_buffer, "ABCDEFG");
の部分で何が起きてるんでしょうか？input_buffer[0]にABCDEFGが入るんですか？
それともinput_buffer「0」にＡ、input_buffer「1」にＢ。。。となってくれるん
でしょうか？

データベースを使用するアプリケーションの場合、（に限らないのですが・・・）
ある特定のデータベースを指すパス＋ファイル名などの情報は、どういう構造で
保持するのが、定石なのでしょうか。
ヘッダファイルに記述し、データベースにアクセスするクラスに、読み込ませ、
他のクラスからは、データベースにアクセスするクラスを呼ぶとか、いうのが
いいのでしょうか。
定数の定義する位置がいまひとつ分かりません。理屈的にもすっきりする扱い
方とは、どういったものなのでしょうか

URL文字列をキーとしたハッシュテーブルで良いんじゃない？
だめかい？

>>168
何を言っているのかわからないけど、
クラスを設計するときは、
アクセスだとか処理の単位ではなくて
オブジェクト単位で考えたほうがいいよ。
とりあえずUMLでクラス図を書いてみれ。
考えがまとまるぞ。

>>168
INIファイルの中身みたいな、初期定数をメモリ上にしまっておく場所
っつう意味でいいのかな？
連想配列が一番楽だけど、サポートしてない言語ではmapを使おう
（連想配列と殆ど同じ）。
（キー=値）のセットをvectorみたいなの（ぜんぜん違うけど外見上
はそんなもん）で持ってて、キーで問い合わせると値が帰ってくるって
いうコレクション構造を言語仕様でサポートしてる言語っておおいと思うぞ。

Perlの連想配列、C++のSTLのmap、Javaのjava.util.Mapとか。
（VC++のgetPrivateProfile云々あたりをいちいち呼ぶとかはアホっぽい
ので使わんで欲しい。会社のソースにそう書いてあってゲンナリした…
んなもんデータモデルにキャッシュしろよ。）

そんなのを、OOP言語ならSingletonクラスにしとくとか、
そうでないならしょうがないからグローバルにおいとくとか。

Unix関係でマルチプロセスなら共有メモリっつうのもあるかも。

>>170
オブジェクト単位で設計するところと、処理単位でまとめるところの
バランスが（言葉は適切でないと思いますが、オブジェクト指向設計と、
３層構造のバランスが）、アプリのミソだと思っているのですが
（まぁ、今までそれだけ改修，改造の多いプロジェクトにかかわってきた
のが問題なのかもしれませんが。）、理解できるように、もっと頑張ってみます。

>>171
ありがとうございます。
Ｃ＋＋だと、その配列はどういうところに記述して、各ソースから
参照できるようにするのが、定石か・・・あたりも教えて欲しいのですが。

>172
STLのmapの使い方はSTL本とかいっぱいあるから
そこで良いよね。

それを置いておくところだけど、
初期データクラスを作る、つうのが一般的でしょ。
mapをクラスのprivate staticのメンバにして、mapへの
問い合わせ関数と、初期化（ファイル読み込んでmapへデータ
を登録する）関数はpublic staticにしておく。

class Property{
private:
static std::map<string,string>* datamap;//最近C++触ってないのでうろ覚え
public:
static void init(string filename){}
static string get(string key){}
}

初期化時
Property::init(なんかファイル名);
使うとき
string value = Property::get(キー文字列);

mapがプログラム内に1個しかいらんのなら、これでええんちゃう？
2個以上の固定数なら、Singletonパターン拡張してヒープに
固定数インスタンス作るよう変更するほうが良いかな。
（やり方はデザインパターン本読んでください。）

ＶＣ＋＋で、ＭＤＩアプリを作ろうと思っています。
まだまだ初心者の身ですので、ＡｐｐＷｉｚａｒｄを使って
ＭＤＩの大枠を作った後、子ウィンドウとして、数種類のフォームを
使いたいので、CFormViewを追加しました。
ただ、追加できただけで、この追加したフォームの表示の仕方が
さっぱり分かりません。
どうすれば、この追加したフォームと、元のフォームを表示することが
できるのでしょうか。
メニューＡを選べば１つ目のフォームを、メニューのＢが選択されたら
Ｂ２つめのフォームが・・・としたいのです。

うう・・・みなさん、ＭＤＩアプリは作られてないのでしょうか・・・
助けて下さい・・・

>>175
VBやっとけ。
WinAPI覚える前にMFC使うな。

>>176
あんたもできねーんだろ（藁
俺もできないから、設計で逃げてるよ

>>175
あきらめなよ

delete this　みたいに、自分自身をdeleteするのってどうなんでしょうか？
なんか気持ち悪い気がするんですが。こういう書き方ってよく使われるんですか？

>>178
モードレスダイアログを消す時とかのMS推奨方式ですね。
でも、やっぱ気持ち悪い、グェ〜。

C++じゃないんだが、スレ立てるほどでもないので、、、
#include "stdio.h"
って、
#include <stdio.h>
と何か違うの？

>>178
Ore*　Ore::２ちゃんに書き込む()
　{
　　発言を書く;
　　return ( 逝っていい ? this : NULL );
　}

として
delete pOre->２ちゃんに書き込む();
とやる手が紹介されていたよ。

>>180
#include でヘルプ検索しろ。
どのディレクトリから stdio.h というファイルを探すか、がちがうのだ。

ソースを検索するパスが違う。
"" だと作業ディレクトリ、<> だとシステムのディレクトリ。
という理解でだいたい問題ないと思うけど
仕様者のフォロー望ム

:@

（　´_ゝ`）ageとこう・・・

なんてタイムリーな。自分もちょうどそこで躓いてます。
解決策は見つかりましたか？
その後どうなったか教えてください。

ANSI C++に完全準拠しているコンパイラってありますか？
C++ Builderが良いところいっているらしいけれど。

>>185
残念ながら、その後は日常業務が忙しくて解決してません。
（日常業務でＰＧを開発することが無いもので・・・）
１８５さんは解決しましたか？
どなたか、アドバイス下さい。よろしくお願いします。

#pragmaって何に使うんですか？

>>188
規格で定義されていない、処理系固有の機能を
指定するためだぴょん。

コンパイラのマニュアル読め＞188

>>174
同じく行き詰まって他の仕事やっちゃってます。
AddDocTemplate()使うと、追加したテンプレートが、
ファイル新規作成時にMFCがデフォルトで出すしょぼいダイアログから
選択できるようになることはなったのですが、
あれを出さずに185さんがおっしゃるようにメニューから
選びたいんですけどね。
どなたかHELP願います。

185さんって俺のことじゃないか。失礼

>>186

>C++ コンパイラ：現在のANSI/ISO C++ 標準に準拠した仕様（C++テンプレート、例外処理、多重継承、RTTIをサポート）
http://www.metrowerks.co.jp/Products/Desktop/Pro4.html

「現在の」？

>業界標準に完全準拠した高効率なC++言語クロスコンパイラ
http://www.aicp.co.jp/product/dc.html

「業界」の標準？

>ISO/ANSI C++ Standard に合致しています。
http://www.adac.co.jp/japanese/products/pdf/c++.pdf

「合致」（笑）

>ANSI X3J11/ISO WG21に準拠した業界最高水準のC++コンパイラ
http://www.microsoft.com/japan/developer/vstudio/vs6/pages/page05.htm

「最高水準」ねぇ

>最新のANSI C++によるビジュアル開発
http://www.borland.co.jp/cppbuilder/prodinfo/

「最新」とは曖昧な…

>>191
C***App::OnNewFileをオーバーライドすれ。

>193
サンクス。Visual C++はnewしたときに例外を投げないとか、なんとか。
つーわけで完全準拠じゃないみたいですね。

追加したテンプレートへのポインタをメンバ関数に出しといて
メニューで呼ばれたときのコマンドハンドラで
そのポインタ->OpenDocumentFile(NULL);
ってやればできました。有り難うございます。

ＭＤＩの事を書かれている人に質問！
新規作成を選んだ時に出てくるダイアログに書かれている名前は
どうしたら変更できるのでしょうか？
っていうか、あそこに出てくる名前ってなに？

>>197
CDocManager::OnFileNew()見たら
CNewTypeDlgと言う名前でダイアログ出してて、
そいつのシンボルはAFX_IDD_NEWTYPEDLGで、実体は
:\Program Files\Microsoft Visual Studio\VC98\MFC\INCLUDE\l.jpn\AFXRES.RC(173)
に切ってあった。
結局194さんの言う通りオーバーライドするしかないんじゃない？

POSITION curTemplatePos = GetFirstDocTemplatePosition();

while(curTemplatePos != NULL)
{
CDocTemplate* curTemplate =
GetNextDocTemplate(curTemplatePos);
CString str;
curTemplate->GetDocString(str, CDocTemplate::docName);
if(str == _T("Hello"))
{
curTemplate->OpenDocumentFile(NULL);
return;
}
}

ＶＣのサンプルを見たら、これでテンプレートに登録したウィンドウを
表示できるようです。

curTemplate->GetDocString(str, CDocTemplate::docName);
if(str == _T("Hello"))

の、CDocTemplate::docNameが、新規作成の時にどのテンプレートを使用するか
選択するダイアログに出てくる名前と等しいような気がします。
とはいっても、このdocNameを変更する方法は判らない。
これがわかれば、何とかなる？

AddDocTemplate()の一つ目の引数にあるIDR_MDI_xxxxxxという文字列の
（\nから始まっているので、１つめは無いとして）２つめがdocName、
３つめが新規作成を選択した時にでてくるダイアログに表示される名前（文字列）だね

ＭＳＤＮのCDocTemplate::GetDocString に書かれてた。
このStringTableに新しく文字列を追加してAddDocTemplate()するときに
使えば、色々なテンプレートに色々な名前を付けれるのでは？

>>197,199,200
>新規作成を選んだ時に出てくるダイアログに書かれている名前
というのはダイアログ自体のことじゃなくて、選択するテンプレートのタイトル文字列
のことを言ってるんですね？（ちょっと勘違いしてました）

っていうかもう答え出てるんでしょ。

>新規作成を選んだ時に出てくるダイアログに書かれている名前
>というのはダイアログ自体のことじゃなくて、選択するテンプレートのタイトル文字列
>のことを言ってるんですね？（ちょっと勘違いしてました）
そうです。
これについてはもう答えが出たけど、
よくよく画面をみると、ウィザードで作ったＩＤＲ＿ＸＸＸＸＸＸＴＹＰＥを
使ったテンプレートを開くとメニューバーに「ウィンドウ」とかが追加されるのに
自分で追加したＩＤＲ＿ＸＸＸＸＴＹＰＥを使ったテンプレートを開くと
メニューバーが変化しないのです
どして！？

またしても自己レス
IDR_XXXXTYPEのストリングだけでなく、メニューも必要なのですね
VC++の事なので板違いですね
自粛します

かなり初心者な質問ですがよろしくお願いします。
LAMEのソースファイルをbolandC++Compiler(無料のやつ）でコンパイルしたいのですが
どうしていいか全く分かりません。
１から教えて下さい。

C++というかCの質問なのですが、

テキストファイルから文字列読みこむときって
scanf("%s", s);
みたいにやりますよね。このとき配列ｓには、リターンか
スペースかタブまでの文字列が入ります。そこをなんとかして、
スペースやタブは無視してリターンまで（１行全部）をｓに
読みこむ方法ってありますか？

＞205
バイナリで開いて自分で分割する
'\r''\n' の２文字が改行コード。
通常は２文字続いてるが改行コードの違うマシン（ＵＮＩＸ、ＭＡＣ）
で作られたファイルはどっちか一方のみ。

>>206

やっぱそれしかないんでしょうか・・・

fgets()ではだめか？

本を見て学習しているのですが
下のコードはdynamic_castの実験を行うものなのですが
#include <iostream>
#include <typeinfo>
using namespace std;

class B
{
virtual void f() {}
};

class D1 : public B
{
void f() {}
};

class D2 : public B
{
void f() {}
};

int main( void )
{
B *p;
D1 ob_1;//今回は使用しません
D2 ob_2;

p = dynamic_cast< D2 *> ( &ob_2 ); //ここが問題のようです
if( p ) cout << "成功しました。\n";
else cout << "失敗しました。\n";

return 0;
}

--------------------構成: test_01 - Win32 Release--------------------
ｺﾝﾊﾟｲﾙ中...
test_01.cpp
C:\Windows\ﾃﾞｽｸﾄｯﾌﾟ\プログラミング\プログラム\test_01.cpp(26) : warning C4541: 'dynamic_cast' が /GR- を使用したﾎﾟﾘﾓｰﾌｨｯｸ型 'class D2' で使用されています; 動作結果は保証されません。

このような警告が出てきてしまい、実行すると
何らかのメッセージが出てきて止まってしまいます。
何が原因なのでしょう、誰か教えて下さい。

MSDNでC4541を調べてごらんなさい。ちゃんと書いてあるから。

＞＞ミトコンドリ子さん
ホントだ書いてありました。
そこに書いてある通りに設定を変えたら
出来るようになりました。
それにしてもＣ４５４１って普通解らないですよね
どうやって知ったのですか？
エラーメッセージには書いていないようだし．．

あら、アナタの書き込みに「warning C4541」って書いてあるじゃない。
もっと注意力を養ってちょうだい。

ええさっき気がついたんです。
これは便利です、さっきも有効利用しました。

ミトコンドリ子さんもしかして
貴方はネカマですか？

>>205

string buff;
getline(cin, buff, '\n');

C++なら素直にこうしろや。

cinは適当なストリームに書き換えてくれ。

えーと、質問させてください。
入力ストリームから一定のバイト数(10Kバイト程度)のデータを読み込んで、
それをstringオブジェクトに格納したいのですが、その場合、

char buf[10000];
ifstream file("hoge.dat");
file.read(buf, sizeof(buf));
string str(buf, sizeof(buf));

のように、いったんchar配列に読み込んでからコピーする方法しか
わかりません。なんか無駄なことをやってるようで気持ち悪いです。
データをstringに直接readするとか、char buf[]をそのまま使って
stringオブジェクトを構築することはできないでしょうか。

>>217
stringstream

うう。。すいません。いまちょっと検索したら
stringstreamっていうと数値<=>文字列変換の例しか出てこないんで
よろしければもう少しヒントをくだせえ。。。

>>219=217
あ、わり、stringstreamかんけーないや。
何勘違いしたんだろう・・・鬱だ・・・。

>>220
いえいえどーも。レスありがとうございました。

引用厨房モード(プログラミング言語C++ 第３版 p.685)

template<class Ch, class Tr, class A>
basic_istream<Ch, Tr>& operator >> (basic_istream<Ch, Tr>&, basic_string<Ch, Tr, A>&);

template<class Ch, class Tr, class A>
basic_ostream<Ch, Tr>& operator << (basic_istream<Ch, Tr>&, const basic_string<Ch, Tr, A>&);

template<class Ch, class Tr, class A>
basic_istream<Ch, Tr>& getline (basic_istream<Ch, Tr>&, basic_string<Ch, Tr, A>&, Ch eol);

template<class Ch, class Tr, class A>
basic_istream<Ch, Tr>& getline (basic_istream<Ch, Tr>&, basic_string<Ch, Tr, A>&);

<<演算子は、ostreamに文字列を書き込む。>>演算子は、空白文字を終了子とする単語を文字列に読み込み、単語を保持するために必要なサイズに文字列を拡張する。冒頭の空白は読み飛ばされ、末尾の空白文字は文字列の中にはセットされない。

getline()関数は、eolを終了子とする行を文字列に読み込み、行を保持するために必要なサイズに文字列を拡張する。行終了子はストリームから取り除かれるが、文字列の中にはセットされない。stringは入力にあわせて拡張できるので、ストリームの中に終了子を残しておいたり、文字配列用のget()やgetline()のように読み込む文字数を指定したりする必要はない。

もともとJava使いで、最近C++のSTLに
手を出し始めたのですが、
stlのvector = java.util.Vector
stlのmap = java.util.Hashtable
このような認識でいいのでしょうか？
mapってのが聞きなれないので、
いまは、ラッパークラスで包んで
Hashtableって名前にして使ってます。

>>223
mapというのは抽象的なデータコンテナを表す名前なのに対して、Hashtableというのはその実装方法を表す名称です。
mapテンプレートクラスは二分木で実装されているようです。一般的にはハッシュ表の方が二分木より高速に検索できますが、それぞれの型ごとにハッシュ関数を用意する必要があります。mapテンプレートクラスでは <演算子さえ定義されていればどんな型でも使えますし、仮に<演算子がなくてもハッシュ関数より簡単なless関数だけ用意してやれば済みます。

>>224
そうそう。
C++のmapのほうが概念的にスマートだよね。

>225
インタフェースとしてはテンプレートがあるぶん良さげだけれど、
(mapの)実装まで決まってるのはやーねー。
インタフェースと実装が分離されているほうがスマートじゃない？

>223
つーか、MapはJavaにあるぞ。
インタフェースだけれど。

>>224さん
詳しい説明ありがとうございました。
大体理解できました。
STLのコンテナの概念がわかってないことが
バレバレで恥ずかしいです。

JavaのHashtableが、ハッシュ関数（Objectクラスの
hashCode）をオーバーライトしたものにしか有効で
無いのに比べ。
mapは、どんな型にでも適応できるということですね。
<演算子というのがいままで使ったことが無いのですが、
小なり演算子ですよね…
==演算子で無いのには何か理由が？
operator <()にてこれを再定義しておけば、良いと

>>227さん
開発をずっと1.1.6ベースでやっていたのでMapって
使ったことが無かったんですよ。
（1.2からサポートでしたよね？）

自己レスですが、
よく考えたら、2分木だから <演算子を定義しなければ
ならないってことですかー
アホだ…＜自分

>>228
そかそか。collection API は Java 2 からだからね。
でも、一応は collection API は単体で配布してる。

C++初めて半年以上になるけどいまだに ostringstream のバッファのクリアの仕方知らない・・・
string::eraseに値するようなメソッドって無いっすか？

みんなストリーム入出力って使ってるんだろうか・・・。

>>231
stringstream strstr;
strstr.str("");

newをオーバーロードして、メモリが確保された場所を
デバッグ表示させたいのですがいい方法はないでしょうか？

// こんな感じにオーバーロード出来ると嬉しい。が、無理だし。
void *operator new(size_t size, char *file, int line)
{
printf("%s:%d: %d byte allocate\n", file, line, size)
return malloc(size);
}

>>228
JavaのMapの実装はHashtable方式だけじゃないぞ。
SortedMapの実装でTreeMap（2分木Map）もコアにあるぞ。
Map継承して自分で実装かくのも良いかもね。B*ツリーMapとか。

ところで、クラス名の頭には「C」ってつけるけど、構造体にはどうしてますか？

クラス名の頭に「Ｃ」なんて付けるか？

頭にCついているのはMFCのクラスじゃない？
僕はつけたくないけれど。

>>235
僕は、
class CMusic
とか
typedef TMouse
とかしてます。

>>232
結構未サポートなんだ。それ欲しいんだが。

インラン関数って何？

sexy()

>>235
MFC汚染済みか・・・哀れな。

>>238
>typedef TMouse
パスカル人が見たら、こんらんして仲間を攻撃しだすかもな・・。

つーか、そもそもクラスと構造体でプレフィクス分ける意味あんのか？

クラス名の頭にC、メンバ変数の頭にm_て
付けなさいって林せんせえが言ってたんですが。

これは違うのですか？

Windowsで普通のウインドウやエディットコントロール等Window系
の物をいじる基底クラスなんか作ってます。

そのクラスの中のメンバ変数でHWNDをもたせて
SetWindowTextとかをメンバ関数内で呼び出したりしています。
ようはAPIにかぶせたりしているだけです。
主にこのクラスから派生させて各種コントロール用のクラスとかを
作ろうと思っているのですが・・・

このような（に限った話ではないんですが）基底クラスのメンバ関数って
全部virtualにしちゃまずいんでしょうか？

「virtualにしない理由」があんまり思いつかないんで
全部virtualにしているのですが。
常套手段はどうなんでしょうか？

どのようなときに困るか等も一言教えていただけると助かります。

>>244

virtualメソッドの機能理解してればおのずと分かるだろ。
多態されると困るメソッドはvirtualにはせんわな。
あと、なんでもかんでもvirtualにすると、VMTが巨大化して重くなる（藁

なんつったりしてな。別に全部virtualでいいと思うよ。

>>244
Effective C++が詳しいかと。
「継承した非仮想関数を再定義してはならない」
とあります。理由も書いてあるんで読んでみては。

逆にいえば、派生クラスで再定義して欲しくないものは
非仮想関数にする、って感じかな。

あとは実行時の効率の問題。

＞VMTが巨大化して重くなる（藁

別にインスタンス毎にVMTが作られるわけじゃないでしょ
VMTへのポインタを持つだけだからサイズは関係ないんじゃ？

>>233
なんで無理なの？
そんな感じでいいんじゃ？

C++で構造体が"デフォルトパブリッククラス"になっていると
聞いたのですが、これって意味のあること？
クラス使うならクラスでいいじゃん。
おれにはよく分からん。

>>249
だからクラスなんだよ。
で、デフォルトパブリックにすることで、セマンティクス上では
struct と同じになってる。もう構造体は使わないってこと。

>>250
シンタックスもだろ。

最近、難しいのはC++ではなくMicrosoft VisualC++だということがわかってきたんですが、
どうしてMicrosoftはあんな厨房めいたコンパイラを売ってるのですか？
そしてなぜそれがこんなに広まってしまっているんですか？
全てが私の理解を超えています。

↑うおお、奇しくもＣ＃相談室とならんどる!!!!
これも時代の流れか…。

質問です。
newで確保したクラスは必ずdeleteしなくてはならないのでしょうか？
アプリが終了することが前提ならdeleteしなくてもオッケー？
それとも、malloc/freeと同じ問題ですか？　それだったらｽﾏｿ。

deleteしないとデストラクタが呼ばれないけど。
それでも良いならいいんじゃない。
ひょっとしてデストラクタの意味がわからないんだったら、
もう一度本読み直した方がいいと思うけど

ついでに言うと、newしたインスタンス（あんたのいうクラス）は
アプリが終了してもdelete呼ばない限りデストラクタ呼ばれないからね。

>>248
あんな感じで出来そうなんですが、
newのプロトタイプが、
void *operator new(size_t size);
なので引数を追加するとオーバーロードされないんですよ

>>257
なんで？233ので引数付きnewを定義しといて、あとは普通に
ClassA* pA = new( __FILE__, __LINE__ ) ClassA;
とかすれば解決な気がするんだけど。

>>258
あんたすげーよ。
その通りにやったらうまくいったよ。大感謝。

newのオーバーロードなんてした事ないよ。俺って厨房
リーク発見とかだよね？ BoundCheckerでいいじゃん（泣）

僕のサイトにC言語会話講座と言うのを作ったので、見にきてください！

http://web.kyoto-inet.or.jp/people/namao/index.html

>261
indexを見た瞬間、アダルトサイトだと思ったのは俺だけ？

g++で自己参照型クラスとかメンバにSTLのvectorとかiteratorを含んだクラスのオブジェクトを
ダンプ、シリアライズする方法ってどうしたらいいんですか？なんかいいライブラリとかあるのかな？
JavaのSerializableインターフェースみたいな感じで使えるとありがたいんだけど。

複数のステートメントがあるマクロを定義する時に

#define MACRO do{ 処理１; 処理２; … }while(0);

と書いているものを見かけたのですけど、これって中かっこでかこっているのは当然だと思うんですが、doとwhile(0);って何か意味があるんでしょうか。

すみません、よく見たら

#define MACRO do{ 処理１; 処理２; … }while(0)

だった。そして解決しました。

template <typename T>
inline btw<T>::btw( const T &val)
　　: m_val(val)
{
}

template <typename T>
inline btw<T>::btw( const T &val)
{
　　m_val = val;
}

では、前者の方が良いらしいのですが、
何がどういいのでしょうか？
どなたかご教示ください。

>>266
上が初期化で下が代入。

>267
それはわかるのですが、
動作は変わるのですか？

>>266
前者は、
・代入演算子が呼ばれないので効率がよくなる場合がある。
・constメンバを初期化できる。
かな。「Effective C++」に載ってたね。

>>269
では、ディープコピーが必要でない場合は前者の方が良い。
という事ですね、
Effective C++も見てみます！
ありがとうございました。

class CData
{
int a;
public:
CData(int n) : a(n) { printf("set a=%d\n", n); }
CData() : a(0) { printf("set a=0\n"); }
CData &operator=(int n) { a = n; printf("set a=%d\n", n); }
};

class CFoo
{
CData data;
CFoo::CFoo();
};

CFoo::CFoo()
: data(1)
{
}

CFoo::CFoo()
{
data = 2;
}

>>270
こんなテストコードを書いてみたけど、
EffectiveC++ を読んだほうが早いかもしれないな……。

スーパー親切な回答ありがとうございます！
今からやってみます！

>>1
死ね

うるう年の考え方おしえて

>>274
スレ違いです。
あとFAQは自分で調べてね。

相談なんですが、
Cと、おジャ魔女どれみって関係あるんですか？
おジャ魔女どれみ←C
おジャ魔女どれみ＃←C＃
もーとおジャ魔女どれみ←C++
関係ないよね？

>>276
すごく面白いことを書いたつもりで、
モニターの前で有頂天になっている無様な姿が目に浮かぶようだよ。

vector<int> *v = new vector<int>(1);

..

cout << v[0];

でエラーでますよね？

cout << v->operator[](0);

とするしかないのでしょうか？

cout << v[0][0];

newする(どこかに保存する)必要が無ければ、素直に
vector<int> v(1);
でいいし。

それとも、望む動作はこっちか？
ostream& operator <<(ostream& stream, const vector<int>& v)
{
　　for (vector<int>::const_iterator it = v.begin(); it != v.end(); ++it) {
　　　　stream << *it << endl;
　　}
　　return stream;
}

ありがとう。
>>279のように要素にアクセスしたかったのれす。
new しないで逝ってみようとおもいます。

ん
cout << (*v)[0];
じゃだめなの?

>282
ありがとー。演算子の優先順位･･･。

cout << *v[0]

とかやってエラーだしてました。

>>277
ワラタ

前々から疑問に思ってること、質問させてください

Aというクラスと、それをリストで持っている管理クラスBがある。
なんてことはよくありますよね。で、管理クラスBが、Aのメンバを
keyに使い、Aのリストをソートするという場面も日常的にあると思います。

現在はA->getKey()みたいなのでkeyを返しているのですが、メンバ一つを返す
だけの関数使うのってどうもスマートじゃない気がして、いつも不安にかられて
います。こういう管理を実現するスマートな設計って無いものでしょうか。
（もちろんfriendは勘弁で）

>>285

Ａ側にKeyの比較関数を作っといて、
ソートの時はＢ側でそれを呼ぶとか。

STLだとかのリファレンスってどこかで落とせますか？

C++って、なんで実行時型情報からインスタンスを生成できないのでしょうか？
MFCのCRuntimeClassを使えばできるけど。あれはマクロでめんどくさい。
実装してない理由でもあるのでしょうか？

>>288
リンク時に、必要なライブラリの選択が出来ずに、
実行ファイルが巨大化するからだろ。

AのStatic メンバにＢを持たせるのは駄目か？

>>289
なるほど。

でも、よく考えたら実行時に保持すべき情報が多くなるからかな？
例えば、クラスのサイズとか、コンストラクタへのポインタとか。
全てのクラスについて保持すると莫大になる。

4: virtual string aMethod() = 0;
と宣言すると

Borland C++ 5.5.1 for Win32 Copyright (c) 1993, 2000 Borland
a.cpp:
エラー E2462 a.cpp 4: 'virtual' はテンプレート以外のメンバー関数だけに適用できる
エラー E2303 a.cpp 4: 型名が必要
エラー E2139 a.cpp 4: 宣言に ; がない

と出ます。g++だったらコンパイルとおるんですけれど、
どっちが正しいの？

stringをstd::stringに直す

>293
ありがとう。あたまに using namespace std
と加えておきました。

レスありがとうございます
>>286
おおなるほど、それなら無様にメンバさらすの避けられますね。
実際作るとなると･･･バブルソートで実装する位しか思いつかない自分が
憎いです(^ ^;んーこれをSTLこみで作れたら最高ですねぇ。
>>290
Aが関連するのが、Bのクラス（あるいは唯一のインスタンス）なのか、それとも
Bのインスタンスなのかによりますよね、たぶん。前者なら有効そうですが…、
やはり往々にして後者の場合が多いですからねぇ。というか私の状況説明不足です。ｽﾏｿ

OOPって何ですか？

OOPで検索してね。

ちょっと質問があります。
参照カウンタ付のオブジェクトを扱うスマートポインタを実装したんですが、
このスマートポインタに対して&演算子を使うと格納しているオブジェクトの
ダブルポインターを返すようにした所、listなどのSTLコンテナに格納出来なく
なってしまいました。
こんな感じのエラーが出ます。
error C2664: 'destroy' : 1 番目の引数を 'class foo ** ' から 'class ref_ptr<class foo> *' に変換できません。
同じ事を_com_ptr_tもやっているのですが、_com_ptr_tはこの問題が生じません。
_com_ptr_tの定義を眺めてみたんですが、どうして_com_ptr_tはＯＫで私のが駄目なのかわかりません。
よろしくご教授お願いします。

>>298

スマートポインタの & 演算子を、rep へのポインタの取得に書きかえちゃったんだから、
「スマートポインタへの参照」ができなくなっちゃったということでは？

>>299
うい、そういうことなんです。
でも_com_ptr_t（COMスマートポインタのテンプレートクラス）でも同じ
事してるのにエラーにはならないんですよ。
一体どうして？

いまは結局ダブルポインターを返すメンバ関数で対処してるんですけど、
スマートポインタといえど、普通のポインタとほぼおんなじ感じで使え
たほうが良いじゃないですか。
引数としてダブルポインターを要求して、そのポインタに製作したイン
スタンスをセットして返す関数とかに、
　　foo(&rptr); // rptrはスマートポインタ
てな感じに書けるようにしたいなぁ、って事だったんですけど。

CAdapt

Borland　C++　Builderの初心者向けのヤツ、
定価２００００だそーですが、
実際小売店ではどのくらいの値段でしょうか？
とりあえず買おうかと。メモ帳とお別れしたいの(笑)

BCBのエディタには期待しない方がいいぞ。>303
VisualC++6のエディタの方がマシ。

＞３０４
そうなんですか。
まあエディタはどうでも良いと言えばいいんですが(笑)

ゲームプログラミングをしてみたいのですが、
専門書(と言うより入門書)やら解説サイトの内容を見ると
すべてアプリを使用しているので。
Visual　C++の方が向いてるならそっちにしてみます。
しかしいくらくらいですかね？学割きくのかな？

>>305
DirectX は VC++ に基本対応なので
ゲーム作るならそっちのほうがいいかもね

google.com で Visual C++ アカデミックパックで
ひいてみそ

オープン価格みたいですね。
店頭にいかなきゃわからないか・・・。
約２００００で販売してるサイトがありましたが。
秋葉原はそれより安いかなー。

＞３０６
おお、どーもです。調べてみます。

>>305
３年前に学割で買ったVC++6.0Professionalが12000円だったかな。
今はもっと安いかも。MS製品、学生なら恐れることないよ。
逆に社会人には(T-T)

ageちゃった

ちなみにヤマダ電気(^ ^;
秋葉原出ればもっと安いかもね

>>302
>CAdapt
??? 301へのレス？
とりあえずMFCにはそんなクラス無いみたいだけど……

文字列は char* と std::string のどっちを使うべきですか？

両方

使い分け方はどうしたら良いのでしょうか？
(C++になってstd::stringだけで統一されたのかと思ったのですが、
const char* という記述を良く見ます。)

string に統一なんて全然されてないよ。
使い分けの方針は「できるだけ string を使う」。

「統一」というのは単に自分が電波を受信していただけです･･･。
"できるだけ string" となると char* と混在して混乱しませんかねぇ。
どっちをつかっても移植性に問題がでることはありませんか？

string(const char *) があるから混在してもあまり
意識しないで書けるよ。というかどの辺で混乱するのか
よくわからないなあ。

片方で統一できるのなら統一してしまった方が良いと思いまして。

使い分けがいまいちわからないのでもう少し質問させていただきます。

GoF の「デザインパターン」を読んでいてあるクラスが文字列を
const char* _name;
で保持しているのを見つけたのですが、
これが string じゃないのはなんででしょう？
string の方が記憶域を多く使うことくらいしか原因が思いつかないのですが･･･

読者にstringの知識を強いてまで使うメリットはなかったんでしょう。
例えばstringを使えばコード量が1/10になるんだったら使ったと思います。

>319
ありがとうです。できるだけ string を使うということで解決しました。

ちわ〜
みなさんにはくだらない事なのかもしれませんが、ファイルにpassがかかっていて
passがわかったんですけど、passが全角ひらがなでpassを入力するとこは英字しか
入りません。どうやってpassを入れるんですか？
教えてください。お願いします。

>>321
メモ帳などに全角ひらがなでpassを書いた後、それをコピー
passを入れるところでctrl+v

ゴホン、あー、あー、んじゃいくかね
二度とここにくるんじゃねぇ、スレ違いの上に板違いじゃボケ
ちくしょうめ、オレがpassの代わりに呪いかけてやる
（ ﾟДﾟ)ﾉﾉ〜x〜x〜x〜x〜x<ｲｯﾃﾖｼ>

VC++6使ってるのですけど、これが通ってしまうのってどうも納得いきません

class Foo{
};
class FooFoo : public Foo{
public:
    int no(){ return 10; }
};

main(){
    Foo* foo = new Foo;
    int result = ((FooFoo*)foo)->no(); //resurt = 10
    delete foo;
}

newしたのがFooFooクラスならまだ納得いくのですが…
インスタンスも無いような派生クラスの関数なんぞ
呼び出しちゃえていいのでしょうか？

>int result = ((FooFoo*)foo)->no();
ここを
int result = ((FooFoo*)NULL)->no();
にしたって動くんだからさ。（実験してない）

別ファイルを読み込んで、デフォルトの引数として、５を表示
させたいのですが、メインファンクションで、引数なしで呼び
出すと、Carという名前のクラスを実行してくれません。
呼び出しで、Car tk(78);の様に、引数を入れるとちゃんと
実行されます。なにが間違ってるのか、わかる方いれば教えて
ください。

//ファイル１
#include<iostream.h>
class Car
{
int a;
public:
Car(int num = 5){cout << num;}
}

//ファイル２
#include"toyota.cpp"
void main()
{
Car ty();
Car tk(78);
}

Car ty();
だと引数無しのデフォルトコンストラクタが呼び出されそうな気がするので、
Car ty;
でどーでしょうか。

Car ty();
と書いたら、ty という関数の宣言になっちゃうからね。

>int result = ((FooFoo*)foo)->no();

>インスタンスも無いような派生クラスの関数なんぞ
>呼び出しちゃえていいのでしょうか？

よくない。C++でCのキャストを使うのは厨房。

FooFoo *p = dynamic_cast<FooFoo *>(foo);
if (p) result = p->no();
が正しい。

int result = static_cast<FooFoo *>(foo)->no();
ならコンパイルは通らない。
int result = dynamic_cast<FooFoo *>(foo)->no();
なら、NULLになるから間違いなく例外割り込みが発生するだろう。

Cのコードを混ぜて、C++の問題だと思うなよ。

>>326
それはおかしいだろ。
Car::Car() と Car::Car(int num = 5) は共存できず、
コンパイルエラーになるから。
共存するコンパイラは ANSI に準拠していないはず。

>>326
>>327
>>329
ありがとうございました。大変感謝してます。Car tyにしたら、
ちゃんとできました。助かりました。

> FooFoo *p = dynamic_cast<FooFoo *>(foo);
このクラス定義で dynamic_cast は使えないぞ、普通は
> int result = static_cast<FooFoo *>(foo)->no();
> ならコンパイルは通らない。
通るだろ普通

>322のギコさん
　　どうもすみませんでした。。。こうゆう質問どこでするかわかんないので。。。
　　教えてくれてありがとうございます。。。

>>328
や、確かにCの問題かもしれませんね。ただ継承がらみでもありますし、さすがに
酷いなと思いまして。そもそもno()はstaticですらないのに…。これが私の
理解不足によるもので、本来なら説明可能なものなのかどうかを問いたかったのです。
>>331
static_castですら通りますねー。こうなるとエラーくるまで防ぐ手だてはない
のでしょうか…。こんなコード書かなければいいのですが…腑に落ちない。

>>324 というか
>int result = ((FooFoo*)NULL)->no();
ばっちり動きましたヽ(´д｀)ノなんだか悩んでたのがバカみたい、
おかげで吹っ切れました。「まぁ、いいや」で逝くことにします。

異なるクラスのオブジェクトををSTLのvectorで関連付けて運びたいのですが
仮想関数のオーバーライドがうまくいかないみたいなんです。
VC6.0++ですが、以下のようにしてvectorに格納した各オブジェクトに
おまえは誰だ？と聞いてもみんなBaseだよとしか答えてくれません。
各自が自分の名前を言って欲しいんですが・・・。
配列ならばうまくいったんですが、vector でうまくやる方法はないでしょうか？
class Base{
public:
virtual void who(){ cout << "Base"; }
};

class A : public Base{
public:
void who(){ cout << "A"; }
};

class B : public Base{
public:
void who(){ cout << "B"; }
};

class cV{
std::vector< Base > data;
public:
cV(){
data.push_back( A() );
data.push_back( B() );
}
void show_who(){
cout << "cV";
for( std::vector<Base>::iterator i=data.begin() ; i!=data.end() ; i++){
i->who();
}
}
};

main(){
cV v0;
v0.show_who();
};

>>334
Base型ポインタの配列ではなく、Base型の配列に派生クラスのインスタンスを
つっこんじゃってるからですよ。やってることは要するに

Base base;
A a;
base = a;
base.cV();

なわけです。cV使ってるのはどうみてもBaseだから、当然BaseのcVが呼ばれます。
でも本当にやりたいのはこれですよね。
Base* base = &a;
base->cV();

ま、もう必要ないだろうけど一応
class cV{
    std::vector< Base* > data;
public:
    cV(){
        data.push_back( new A() );
        data.push_back( new B() );
    }
    void show_who(){
        cout << "cV ";
        for( std::vector<Base*>::iterator i=data.begin() ; i!=data.end() ; i++){
            (*i)->who();
        }
    }
    ~cV(){ /*vecotor型dataにあるのを全てdelete*/ }
};

基本クラスポインタの配列やリストを使って派生クラスをdeleteする場合は
基本クラスのデストラクタをvirtualにすることをお忘れなく

> vecotor型data
(^-^;

334です。できました。激多謝！＞335

再起法をつかって2のｋ乗を求めるプログラムなんですが、
エラーは出ないけども、数値を入れると強制終了になってしまいます。
何が原因でしょうか？どなたか教えてください。
よろしくお願いします。
#include <stdio.h>
int fact(int n)
{
if (n != 0)
return(2^n+fact(n-1));
else
return(2);
}
int main(void)
{
int x;
scanf("%d",x);
printf("%d",fact(x));
return(0);}

>>338
scanf("%d",&x); //&が抜けてる

>>338
再帰

>>339
あ・・・どうもです・・・
なさけない・・・

2^n>>338

やさしい。ｲｲ

いまさらだがVisual　C++のStandardEditionの
アカデミーパックは、秋葉原のソフマップで
税抜き８９８０円だったことを報告したいと思います。
っつーか買いました。

Ｃ＋＋ではないですが
DWORD dw;
dw = 0xFFFFFFFF;
printf("%d", dw);
とすると-1が出てきます
0xFFFFFFFEとすると-2が出てきます
どうして？unsignedじゃないの？？%ldでもだめ

よろしくお願いします

>>345
%dはdwのビットイメージをsignedで解釈するから。
%uを試してみれ。

>>344
なんだか自分を責めたい気分。あと一言いっておけば…、と。

>>344
学割なら+3000円くらいで、Pro版買えたのにね

344じゃないけど
Proだとなんかちがうんですか？

>>349
MFCのスタティックリンクができたりとか。
最適化もStandardだとダメだったっけ。（あんまり覚えてない）

http://www.microsoft.com/japan/developer/vstudio/vs6/pages/image0500.htm

＞３４７
いやーどーなんですかねー？
別にプロを目指してるわけでもないので
スタンダードで良いだろう程度に考えてましたが。
まず不便を感じられるようになりたいですね。

発展してるのでage

>>352
うん、杞憂だったよ。どうせなら…って程度だし、きみなら大丈夫だと思う
勉強なら別に問題ないし、そろそろ次もあるしね

Windows環境でCSVファイルを読まないといけないくなりました。
一行をcharの配列にいれて、一文字ずつカンマを調べようかと思ってますが
何か効率的なやり方や、csvを読むクラスがあれば教えてください〜。

ポインタの参照渡しってどうやるのでしょうか？

int a, b, *ptr;
ptr = &a;

printf("ptr = %X, &a = %X, &b = %X\n", ptr, &a, &b);
func(&ptr, &b);
printf("ptr = %X, &a = %X, &b = %X\n", ptr, &a, &b);

------------------
// この関数のダブルポインタ引数をポインタの参照渡しにしたい。。
void func(int **pptr, int *pb)
{
　*pptr = pb;
}

よろしくおねがいしまちゅ。。。

int a, b, *ptr;
ptr = &a;

printf("ptr = %X, &a = %X, &b = %X\n", ptr, &a, &b);
func(ptr, b);
printf("ptr = %X, &a = %X, &b = %X\n", ptr, &a, &b);

------------------
void func2(int * &ptr, int &b)
{
　ptr = &b;
}

で出来ましたです。。

>>355
それでだいたい問題ありません。
あとはファイルを読み込む際のバッファリングなどに気を配りましょう。

C++の例外の必要性がわかりません。
戻り値で値を返せば例外なんて必要ないんじゃないでしょうか？
どうしてわざわざ、Throwなんて機能があるんですか？

ヽ( ´ー｀)ノ オブジェクト思考と例外は相容れない関係なんだよ。>359

ヽ( ´ー｀)ノ >>360思考→指向。どっちでもいいけどね。

>>360
大嘘。凄く関係有るぞ。

ヽ( ´ー｀)ノ ちゃんと読め。>362

>>359
例外クラスを継承してポリモーフィズムできるから、
例外処理はおいしいんだよ。
EFileErrorクラスを継承して、EFileReadErrorやEFileOpenErrorとかを作るんだ。
例外に価値を感じないということは、例外クラスを継承するという考えが欠落しているか、
ポリモーフィズムを理解できていないか、どっちかだろうね。

>>360-363
なんだか会話が成り立っていません。

>>359
Throwしたものが、メソッドコールスタックのどこででも拾えるんだぞ？
オブジェクト指向うんぬんを除外しても、超便利だぞ？

STLのfor_eachとかのアルゴリズムに渡す関数オブジェクトって値渡しで
定義されてますよね(egcs,VC6)？
関数オブジェクトの中で渡された引数の集計を行って、あとから結果を引出したいことが
よくあって、参照渡しに修正したアルゴリズムを作って使ってますが、
なんか漠然と気持ち悪いと思ってます。

…こういった使い方ってどうなんですかね？(質問まで漠然としててスマソ)

コンストラクタの中での致命的なエラーとかはどうするよ？
例外で通知するしかないだろ。

オブジェクト指向との関連はわかりませんが、
例外の必要性(便利性？)はわかりました！みなさん、頭イイですね！！
私も例外の理解が浅かったのがいけませんでした。

クラスでの例外を考えると夢が広がりますね。
あとコンストラクタでのエラー通達方法も初めて気づきました。
皆さんのおかげで、とても幸せになれそうです。

>>366
参照(やポインタ)のほうが値渡しより
役立つことが少し多いと思う。大抵どんな場合でも。
その話もまた一例なんじゃないかと推察します。

>例外
なんてゆーか、プログラム実行の流れと
エラー通知の流れとを、別々に作ってくれた
ってのは凄く嬉しいと思うってのが1つ。

あと例外「クラス」ってのも美味しいよね。
例外の種類分けを、エラー番号なんていうダサダサのやり方より
数段マシな方法で管理できるのは、随分よい。

>>369
激しく同意

gea

>あと例外「クラス」ってのも美味しいよね
別に例外でクラスオブジェクトを投げる必要はないし、returnで
クラスオブジェクトを返さない理由もないんだけど。

>>372
じゃ一生そうやってろ

>>372
必要性、おおありだよ。
例外クラスの継承図しだいで、
リカバリーのしやすさが飛躍的に高まる。

int& MyMethod(int n){ return n; }
こういう戻り値がint&とかの関数の意味がわかんない。
これってどういうことなの？
関数が参照？？？
誰か教えてください。

上の場合はローカル変数の参照を返す事になるので激意味無い
というかやったらヤバイが、
int& MyMethod(){static int n=0;return n;}
とかだと
MyMethod()=3;
みたいにしてnに代入できると思う。

参照返しは、メンバ変数を返したり、演算子をオーバーロード
するときによく使います。これを使ってるソースは標準C++
ライブラリやMFCの文字列あたりを参考にするといいでしょう。

・例外機構と
・エラーの返り値を数値じゃなくてクラスにすること
は全く関係がないと主張してるんだけど。
元レスのエラーコードよりクラスまんせー、っていうのは例外がなくっても
成り立つでしょ？

>>378
例外ってのは、適当な例外ハンドラが見つかるまでスタックを辿る機能があるだろ。
そこにポリモーフィズムを組み合わせて、あるときは基底クラスで、
またあるときは派生クラスでキャッチするのがおいしいんだ。

エラーの種類毎に細かくリカバリしたいときは、できるだけ派生クラスを、
エラーが発生した場所と近いところでキャッチする。
あまりエラーの種類を厳密に判別する必要が無く、たとえば
エラーメッセージを表示して終わりとかいうばあいは、
基底クラスをmainに近いスタックでキャッチするようにすれば、
ファイルの読み込み処理毎にリカバリ処理を書く必要が無くなる。

こうしたことはエラークラスがうまく継承されてないと実現できないし、
またスタックを辿る機能がなければ、基底クラスのキャッチを
呼び出し元に任せることもできない。

だからポリモーフィズムと例外は切っても切れないんだよ。

>>376-377
つまり、最初から関数の「外」に有った変数を返せ、
ってことだよね？この理解で合ってるっすか？

メンバ変数も、関数そのものの中のものじゃない、っと。

>>379
とても興味のある回答です、
単純なものでいいので具体的なコードお願いできない？

>>378
>・例外機構と
>・エラーの返り値を数値じゃなくてクラスにすること
>は全く関係がないと主張してるんだけど。
>元レスのエラーコードよりクラスまんせー、っていうのは例外がなくっても
>成り立つでしょ？

うーん。面白い主張だが、なんかノリがちょい違うなあ。
切っても切り離せないってのは確かに嘘だが、
合体させないより合体させるほうが「ごりやく」が
大きいのも確かなんで、まぁ。

例外クラスのInstanceをわざわざ自分で作って自分で返し値として返す
ってのは、可能であってもあんまりメリットないなあ。
ふつーしないじゃん。ソース汚くなるだけ。
成り立つけど成り立たせても意味が無いという。

てゆーか言語お仕着せの例外クラスが無い世界の人は
こういう考え方もするんだなってのが新鮮だった。
すまん。俺の常用言語には例外クラスが有るんで(^^;、
そんな面倒なこと考えたことも無かったよ。

>>377
メンバ変数にアクセスするのは普通にメンバアクセス関数を
作ればいいですよね。
ということは、参照返し関数は演算子のオーバーロードくらいにしか
使うことはないんだね。

どうもありがと！

>>381
探してみたけど、ぴったりこれだというページは見つからなかった。
簡単に書くなら、こんな感じか。

foo()
{
　char *p1 = new char[256];
　char *p2 = new char[256];
　char *p3 = new char[256];
　char *p4 = new char[256];
　foo();
　foo();
}

bar()
{
　try
　{
　　foo();
　} catch(bad_alloc &e)
　{
　　cout<<"メモリがねぇぞゴルァ！"<<endl;
　} catch(exception &e)
　{
　　cout<<e.why()<<"だってさ"<<endl;
　}
}

あとはstlのexceptionの継承図でも眺めてね。
Javaでも可。

例外クラスを継承構造にするのは、エラー処理の責任の問題。
誰が何のエラーに責任を持つのかはっきりさせることができる。

言い換えれば、責任がもてないエラーはキャッチしなくてもいい。
もしくはキャッチした後で、責任がもてないと判明したら、
より強い責任を持つはずの呼び出し元にthrowする。
こうすることで、各関数が持つ責任を減らすことが出来る。
サンプルコードの例では、fooはメモリ確保エラーの責任を負っていないし、
負ったところで何もできないはず。

エラーコードを使う方法は、呼び出した関数が返したエラーに
必ず責任をもたないといけなくなる。
サンプルコードの例では、fooはメモリ確保１つ１つを、
正しいかどうか管理する、無駄な責任を負う。
呼び出し先のエラーコードを呼び出し元へ伝達することも
一つの責任だ。

そしてmain関数は、他の関数が責任を取れなかった
全ての例外に対する責任を負わないといけない。
エラークラスは必ずstd::exceptionを継承しているなら、
これをキャッチしてエラー内容を表示することができる。
だからintやstringを安易に投げてはいけない。
...では、main関数でキャッチしても、十分な責任を負えない。

>>384
しまった、再帰が永久ループになってる。
単にメモリを確保する関数をさらに呼び出している、
と書きたかっただけなので、
以下のように読み替えてください。

foo()
{
　char *p1 = new char[256];
　char *p2 = new char[256];
　char *p3 = new char[256];
　char *p4 = new char[256];
　foo2();
　foo2();
}

foo2()
{
　char *4 = new char[256];
}

>>385
もうちょっとおちつくアルよろし。
>char *4 = new char[256];
char *p4 = new char[256];

ちょいごめん。
Perlの連想配列って、C++だと何になるの？

mapかもな

ハッシュのこと?

http://www.amris.co.jp/cpp/c16.html
mapの解説>>387

初期化にどうしても引数が必要なオブジェクトを
Singletonパターンでスマートに実装する方法ってありますか？
初期化メソッドを用意するしかないんですかね、ﾔﾊﾟｰﾘ

>>389
ハッシュテーブルをmapの実装手段にすることはあるけど…
連想配列の実装を、2本のvectorにしようと、2本の配列にしようと、
場合によってはBツリー使おうと、それは実装者の自由でしょ。

ハッシュ=mapつうのは、なんか勘違いしてるぞ。

>392
一応フォローしとくとさ、389は単にPerlの連想配列ってハッシュのこと？
て聞いてんじゃねーの？最近（？）名前が変わった（連想配列→ハッシュ）らしーから。

すんません。
言葉足らずでした。
393さんの言うとおりです。

>>392
ハッシュ値が得られないからmapの実装にハッシュは使えないと思う。

コンパイル時に配列の大きさがわからないという場面に出くわしたので、STLのvectorクラスを使うことにしました。
STLのvectorクラスは自分で作った構造体などは使えないんですか？
vector <oreno_kouzoutai> hoge;
などとやったらエラーが70出てきて、しょぼんとなりましたよ。

エラーの内容をMSDNで調べろ。話はそれからだ。

３時間調べてわからなかったら、エラーの内容を正確に書いて再投稿せよ
話はそれからだ。
適切な回答が得られるかは、君の質問文作成スキルによるがな...

C++の例外処理について質問があります。
どうもいまいち例外の使い方（上手な使い方）がわからないので困っています。

まずthrowする物について。
C++の本を見るとたいてい例外でエラー用のクラスをthrowしています。
そしてこれらの例外クラスはエラー別に分かれていると思います。
例外用のクラスを使って安全に開放するというのはわかります。

しかし、この例外クラスは何処に記述したらよいのだろうか？
と悩んでいます。

今は仮にAというクラスがあった場合Aクラス用の例外クラスを
Aクラスを記述してあるヘッダに記述しています。
しかし、エラーの種類別にクラスを作っているとそれだけ
名前空間を占有する事になります。（何かいまいち）

仮にnamespaceを使ったとしても、例外を受け取るのは
Aクラスの外の場合も多いと思うので、結局そのAクラスのヘッダを
インクルード & using...する事になると思います。
するとエラー用のクラスが多くなってごちゃごちゃしてしまいます。
さらにその他のクラスと同じような例外を通知するのに
同じような例外クラスを何個も作るのはいまいちなきがします。

それならばと各クラス共通の汎用的な例外クラスMemoryError等を作成したとします。
（例外専用ヘッダ＆ソース作成。開放等はデストラクタ任せで主にエラーの通知に使う）
すると自作のクラスライブラリすべてでその例外クラスヘッダをインクルードする事になります。
それだと、各クラスのソース的なまとまりというかなんというか（説明下手でスイマセン）
そういうものが薄れてしまってやっぱりいまいちなきがします。

ながくなったので続きます。スイマセン

つづきです。

自作例外クラスヘッダ等を複数のクラスからインクルードするのは抵抗があります。
それならば標準でついている例外クラスを派生させずにそのまま使うとします。
（標準ヘッダならある程度なっとくできるので）

しかしそれでは本当に文字列ぐらいしか通知できません。
わざわざクラスにする意味が薄れてしまいます。


例外にクラスを使うのは主にリソースの開放等安全に終了させるための物
だと思っています（まだよくわかってないですが）

そこでまた疑問が湧いてきます。
ある処理の途中で例外が発生した場合その例外以前で確保したメモリを
開放したり、安全な処理をさせなくてはなりません。

そしてそれらの事は例外クラスを使わなくてもデストラクタによって
適切に行われるのが理想だと思います。
するとやはり例外をクラスで投げる必要があるのだろうかと考えてしまいます。

そこでまた悩みが増えます。
オブジェクトが自分自身のデストラクタで安全に終了させるのが理想だと書きました。
そのためにはちょっとしたバッファをnewで確保する時にもSTLのauto_ptr等を
使用したり、ほぼすべての物をクラスで管理するべきなのだろうと悩みました。


まだつづきます（長文スイマセン）

>>398-399
３行で要約しろ。話はそれからだ。

続きです。
ここから書く事は若干別問題という気がしますが一応聞いてください。

結局のところC++はクラスとSTLを中心に作っていくのが正しいのだろうと
感じました。

・・・・しかし
この辺ちょっとあやふやなんですがSTLって一応C++的に標準なんですよね？
ところがSTLをサポートしていない環境というものがあります。

そこでauto_ptr的なものを自作するとします。
しかしそこでまた
「自作の汎用クラスをその他のクラスでインクルードするのはソース的なまとまりが無くなるような気がする」
という悩みが出てきます。
なんかC言語で作っている時とあまり変わらないような気がしてくるのです。

例外とはいかに使うのが正しいのかどなたかアドバイスをください。
お願いします。


・・・・・・STLを使えない具体例とはWindowsCEなのです。
そこでまた例外とSTLについて悩みが出てきました。

まだつづくんですがちょっとこれまでの質問とは別分野になるのでいったん切ります。

>>398-399 >>401
３行とはいわない。
４行で要約しろ。話はそれからだ。

>>400

長すぎですよね。（ごめんなさい）

1：例外の正しい使い方とは？
2：デストラクタで安全開放するのなら例外でクラスを投げる事にどのような有効利用があるだろうか？
3：例外用のクラスを多数追加する事に抵抗があるのですが普通なのでしょうか？

>>397
Roger. ・・・って俺(396)に向かって言ったんですよね？どちらにせよ、少し調べるのをさぼってました。
ｽｲﾏｾﾝ。

>>402
400を見る前に401を書いていました。
（書いてる間に更新していなかったので時間差が・・・）

ごめんなさい。

age

age

age

age

age

>>406-410

?

恐らくkylix相談室を荒らしたのと同一犯。

解決しました。vectorはテンプレート引数を比較するコードがあるのを発見しました。(というか、コンパイラが
教えてくれたエラー内容そのものです。何やら長いエラーメッセージだったので、読み飛ばしていました・・・)
するってえとvectorは、構造体は駄目なんですね。仕方なく構造体へのポインターにすることにより回避しました。

って言うか、これは完璧な一人相撲ですね。こういう幕引きは辛いものがあります・・・。

>>413
struct Foo{ int m_nFoo };
std::vector<Foo> vecFoo;

はコンパイル通るだろ? なら「vectorは、構造体は駄目なんですね」とか言うな。

>>413
構造体でも大丈夫だろ。
比較が必要なら比較のコードを書けばいいし、
クラスでも比較のコードを書かなかったら同じエラーが出る。

struct hoge
{
　int a, b, c;
　bool operator==(const struct hoge &x) const { return a == a.x && b == b.x && c == c.x; }
　bool operator!=(const struct hoge &x) const { return !(*this == x); }
　bool operator>=(const struct hoge &x) const { どっちが大きいのか、それは君が決めるしかない }
};

bool operator==(const struct hoge &x, const struct hoge &y)
{
　return x.a == y.a && x.b == y.b && x.c == y.c;
}

できればどなたか>>391にも引導を渡していただけませんか。
人に言われるまであきらめきれないので･･･

>>417
今どうやって Singleton の実装してる？

>>417
俺にもわからん。
やっぱstaticな初期化メソッドを作って、それを呼んでもらうのが普通だよね。

プロキシ経由でしかアクセスできないことにして、
最初に生成されたプロキシが、
シングルトンのオブジェクトを作るというのはどう？

だけどそんな複雑にしてまで安全を確保する必要性があるのかなぁ。
気持ちはわからなくも無いけど。

Game Programming Gems に載ってた方法だと、こんなのがある。こいつを
継承したクラスのインスタンスを、適当なところで new, delete する。

----------
template <typename T>
class Singleton
{
        static T* m_Singleton;
        Singleton(const Singleton&);        // コピー禁止
public:
        Singleton()
        {
                assert(m_Singleton == 0);
                int offset = (int)(T*)1 - (int)(Singleton <T>*)(T*)1;
                m_Singleton = reinterpret_cast<T*>(reinterpret_cast<char*>(this) + offset);
        }
        ~Singleton()
        {
                assert(m_Singleton != 0);
                m_Singleton = 0;
        }
        static T& GetSingleton()
        {
                assert(m_Singleton != 0);
                return (*m_Singleton);
        }
};

template <typename T> T* Singleton <T>::m_Singleton = 0;
----------

>>418
一般的なやり方だと思います。いわゆるprotectedメンバに
コンストラクタをおき、次のメソッドのみでオブジェクトを返すような。
Class * Class::instance = NULL; //staticメンバ
Class* Class::getInstance(){
    if( instance == NULL ){
        instance = new Class;
    }
    return instance;
}
まさか毎回getInstance( value );ってわけにもいきませんし…
>>419
レスありがとうございます。
> staticな初期化メソッドを作って、それを呼んでもらうのが普通
やはりこれですかね、ただ折角Cから移行してきた所なので悔しくて（笑
また初心者ながらにSingletonをサブクラス化したとき面倒そうかなと。
> プロキシ
なるほど、試してみます。

>>420
すいません、書き込んでて気づきませんでした
これはすごい、ちょっとじっくりみさせていただきます

>>421
私なら条件変数を使わず、ローカル static 変数を使います。これだと
インスタンスを作成するタイミングは明確（初めて関数が呼ばれたとき）
ですが、インスタンスを壊すタイミングが明示的に指定できないので困
る場合アリ。

で、結局 >>420 に行き着くんだけど。

class Class {
public:
        static Class& GetInstance()
        {
                static Class obj;
                return (obj);
        }
};

#define g_Class Class::GetInstance()

>>420
なるほど、二つ目のインスタンスが作成される可能性をことごとく潰して
いるんですね。しかもテンプレートで使い回しがきき、どんな引数をとる
クラスであろうと対応できると。感動しました、C++にきて良かったです。
>>423
ふーむ、こんなやり方もあるんですね。NULLチェックが省けちゃうとは。
どのみちSingleton使うのは実行時の変更がなさそうなシステム領域のクラスが
多いから壊すタイミングに留意する必要はなさそうですしね。素晴らしい。
初期化なしのSingletonパターン適用クラスを作るときに使わせて頂きます。

識者のご指摘を伺えて今日は幸せでした。レス下さった方々に深く感謝です。

幸せage

class A
{
void f1();
void f2();
void f3();
};
このクラスにメンバ関数ポインタf0を追加して、
f1、ｆ2、ｆ3をｆ0を介して呼び出すようにしたいのですが
こういうことってどうすれば出来るのでしょうか？

class A {
void (A::*f0)();
void test() { f0 = &f2; (this->*f0)(); }
};

>>427
その方法でうまくいきました。ありがとうございます。
ですがこうするとエラーになります。
なぜでしょうか？

// コンストラクタ
A()
{
f0 = &A::f1;
}

void main()
{
A* a = new A;
(a->*f0)();
delete a;
}

(a->*a->f0)();

うまくいきました。
何度もありがとうございました。

>>398
>>399
>>401

誰かこの質問に愛の手を
壁|_-)

>>431
正しい引用の仕方>>398-401

>>431
3 行とは言わないが、10 行程度にまとめて、論点を明確にせよ。
話はそれから。

>「自作の汎用クラスをその他のクラスでインクルードするのはソース的なまとまりが無くなるような気がする」

気にすんな。
以上。

>>434同意
C++はクラスをインクルードするのを前提に設計されたのだよ。
コンパイラの都合(性能の話)だそうだ。
どうしても隠したいならラッパーを作るしかないようだ。

>STLをサポートしていない環境
STLのヘッダをインクルードするだけで使えるものもあるが..だめか?
http://www.stlport.org/download.html
(SGI風iostream以外は大丈夫だったと思うぞ)

あまり悩むな。

ちょっとお聞きしたいです。
クラスをエクスポートするDLLを作っているんですが、クラスのデータメンバにSTLを用いたものがいくつかあるん
です。しかしそれが問題らしく、stringやvectorの変数を宣言する行で警告を食らいます。警告内容はstringやvector
をエクスポートしろ、というものですが、これは無視していいんですか？

>>436
DLLってWindowsでしょ？
こんなことしていいの？
リンクするランタイム違っただけで死んでしまわない？

typedef list<PROCESSENTRY32> ProcessEntriesList;

つー、リストを

for_each(pel.begin(),pel.end(),&addProcessEntry);

つー、アルゴリズムに

void __fastcall TForm1::addProcessEntry(PROCESSENTRY32 pe)

を上記のように&渡ししたら動いちゃった・・・
いや、関数オブジェクト書くのがかったるくて適当書いたんだけど、
動いたことに驚いたのは初めて。（動いてて驚くソースは仕事で頻繁に見るけど）

これって処理系依存？BCB5なんだけど。

追加情報。

addProcessEntry() って関数名だけど、単にリストを順処理させてる関数です。
なんかリスト追加する関数と誤解されそう。
名前付けセンスないなぁ俺。

>>438
どこでも動く、非常に普遍的なコードに見えるっす。

>>438
for_each(pel.begin(),pel.end(),&addProcessEntry);
この行がTForm1のメンバ関数の中にあるなら、
規格の範囲内で、コンパイラには依存しません。

要するに、
this->(&addProcessEntry(pe));
が成立すれば大丈夫ということ。

>>438
「処理系依存」をどう捉えるかによって答えが異なる。

すなわち、「C++ の言語仕様の範囲内」なのか、
「(たとえば)VC でもビルドできる」のか。

前者だとすると(Win32 API な処理系と仮定しても)、
一部分だけ言語仕様から逸脱している。 → __fastcall

後者だとすると(勿論、必要な宣言がすべて正しく揃っているとして)、
「VC でもビルド可能」(たぶん)。

ただし __fastcall は C++ の言語では定義されていないので、
今仮に VC でもビルドできたとしても、
__fastcall な大域関数のアドレスを取得できるかどうかは、
将来の VC でも同じという保証はないと思う。

ちなみに(当たり前のことだけど)、
もし TForm1::addProcessEntry が仮想メンバ関数なら、
たとえその行が TForm1 のメンバ関数の中にあっても、
コンパイルエラーになるはず。
…だよね? >>441

などなど、もっと詳しい条件が定義されないと、「言語仕様内/外」とか、
「VC でもビルドできる/できない」は、一概には言えないと思う。

>>437
どういうことですか？すいません、まずい理由をもう少し詳しく教えてもらえるとありがたいところです。

>もし TForm1::addProcessEntry が仮想メンバ関数なら、
>たとえその行が TForm1 のメンバ関数の中にあっても、
>コンパイルエラーになるはず。
>…だよね? >>441

コンパイルエラーにはならないよ。
ちゃんと仮想関数としてコールされるから、
TForm1を継承してaddProcessEntryを書きかえたら、
書きかえたほうが呼ばれる。

__fastcallのことは、すっかり見落としてた（藁。
C++Builder使いなので許しておくれ。

メンバの宣言のとき
privateって使ってます？
protectedとprivateの使い分けがいまいちわからない。
皆さんの意見を聞かせてください。

とりあえず、Ｃ＋＋の入門書読み終えたんですけど
次はどんな本を購入すればいいんですか？
題名、著作者、出版社をできれば教えてください

>>445
必要がない限りprivate。

>>446
http://www.amazon.co.jp/exec/obidos/ASIN/475611895X/qid%3D985068930/249-3030546-3461946

>>448
た、高いっす

>>449
「プログラミング言語 C++」はバイブル。C++ でプログラムを組むなら、手元に
置いておかないと話にならない。

7000 円分の価値はあるから、さっさと買え。

>>450
わかりました。
在庫切れみたいなので
デッカイ本屋行って買ってきます

>>440-442

for_each() の実装が

template <class InputIterator, class Function>
Function for_each (InputIterator first, InputIterator last, Function f)
{
while (first != last) f(*first++);
return f;
}

だから

(&addProcessEntry)(*first++);

ってやってる事だと解釈したんだけど…
同じ事は C だと（Cと比べるのも問題あることは分かってるけど）

for_each(first,end,addProcessEntry)

と渡しといて、

(*addProcessEntry)(*first++);

で受けるよな〜（確か）と、いう点が疑問なんです。
関数のアドレスに関して、C++ではどういう解釈をすれば良いのかに悩んでいるのが現状です。
関数オブジェクト渡しならば()をオーバーロードしてるから分かるんですが。

そこらへんの解釈を理解するにはARM買って読むしかないのかな？

fileのラッパークラス CFileを作ってと演算子のオーバーロードで

file >> MyClass; // load

見たいのをやりたいんですけど、 >> 演算子だと 右辺に新しいクラスが
来るたびに CFileクラス定義に追加しないといけないですよね？

グローバル関数で operator >> を定義 するのと
MyClass << file;
と逆向きにしてMyClass内でoperator<<を定義 するのとどっちがいいかな？

前者は operator>>関数が無数に出来るので、VC++とかのツールで見にくい(探し難い）
後者は 普通の使い方と逆ですよね？？

どういう方法がいいでしょうか？

あ、後者は
file >> MyClass >> MyClass2

とか、連続して書けないから駄目か

すいません、friendの使い方について教えてください。

class A
{

classB
{
int i;
};

friend class B;
int i;
};
これだと問題なしなのに、

class A
{
friend class B;

classB
{
int i;
};

int i;
};
これだとfriend宣言が無視されます。エラーは出ません。

同様に、
class A
{
friend class B;
int i;
};

class B
{
int i;
};
これも無視されます。
何が悪いのでしょうか？
VC++5.0ラーニングエディションです。

>>455
空のクラス宣言を前置せよ。

class B;
class A {
friend class B;
ほげほげ
};
class B {
ほげほげ
};

>>456
アドバイスありがとうございます。
それを試したのですが、
同じようなソースなのに出来る場合があったり、
出来ない場合があったりします。
コンパイラが狂ってるのかなあ？

あとちなみにこういう場合はどうなんでしょうか？
class A {
friend class C;
ほげほげ
};

class B {

class C {
ぼげぼげ
}

ほげほげ
};

Bの中のCは、Bの外(たとえばA)から見るとB::Cになるんでは？

class B {
public:
class C {
}
};

class A {
friend class B::C;
};

なら分からんでもない。
しかしキモいなあ。

>>457
クラスのプロトタイプ宣言をしても駄目か？
class A;
class B;
class C;
を先頭に表記。

というか個々に定義して継承するか包含しないか？

>>458-459
度々お答え申し訳ないです。
>>458さんの方法でうまくいきました。
クラスのプロトタイプ宣言で class B::C;
と表記出来ればいいんだと思うんですが、こればかりは駄目みたいですね。
納得しました。ありがとうございました。

＞というか個々に定義して継承するか包含しないか？
自分がネストしたがるのは、単にデベロッパスタジオのワークスペースのツリーが
見栄えが良くなるからです。それだけ。＾＾；

const int x = 3;
const int y = 3;
int hairetu[y][x] = {
{1, 0, 0},
{1, 0, 0},
{1, 0, 0},
};
void proc(int x, int y, int **data)
{
int i, j;
for(i = 0; i < y; ++i){
for(j = 0; j < x; ++j){
data[i][j] = 0;
}
}
}
int main(int argc, char* argv[])
{
proc(x, y, (int**)hairetu);
return 0;
}
↑このプログラム実行時にエラー出ちゃうのですが
出ないようにする方法教えて下さい。

二次元配列を、
関数の引数として渡す方法が、分からないのです。

>>460
新しいフォルダ作ればいいのに

>>438

void __fastcall TForm1::addProcessEntry(PROCESSENTRY32 pe);
が静的メンバ関数でないのなら、
for_each(pel.begin(),pel.end(),&addProcessEntry);
は完全に間違っている。

次のような特別バージョンが生成されると考えることができたとしよう。

typedef void (TForm1::*FUNCTION)(PROCESSENTRY32);
typedef std::list<PROCESSENTRY32>::interator INPUTITERATOR;

FUNCTION A_for_each(INPUTITERATOR __first, INPUTITERATOR __last, FUNCTION __f)
{
// 束縛されていないメンバ関数へのポインタからは呼び出せない。this->が天から振ってくることはない。
while (__first != __last) __f(*__first++);
return __f;
}

束縛後のメンバ関数へのポインタの型 というものはない。


関数オブジェクトの最も簡単なものが関数ポインタである。
__fastcallが暗黙にstaticを主張しているとコンパイラが考えるのは突飛だろうか。

次のような特別バージョンが生成される。

typedef void (*FUNCTION)(PROCESSENTRY32);
typedef std::list<PROCESSENTRY32>::interator INPUTITERATOR;

FUNCTION A_for_each(INPUTITERATOR __first, INPUTITERATOR __last, FUNCTION __f)
{
while (__first != __last) __f(*__first++);
return __f;
}

>>463
そうなんです、&func が何で関数ポインタ？というのが疑問なんです。

ちなみに、疑問にお答えします。
静的メンバ関数ではありません。
しかし、for_each() はメンバ関数で実行しているので見えてます。
正確には &(this->func) でしたね。
指摘されるまでうっかり忘れてました。

多分この疑問も分かってしまえばな〜んだ、となるでしょう。

>>461

配列が int hairetu[y][x] なのに、どーして
> void proc(int x, int y, int **data)
> proc(x, y, (int**)hairetu);
なんだよっ!

コンパイラの警告を無視するな(したはずだろ?)。

>>461
template<Temp>　//Tempは何らかの二次元配列
void
Proc(int x,int y,Temp data){
//省略
data[i][j];

}
と関数を定義して
proc(x,y,hairetu);
でコール。

本当は板違いだが++なレスで答えたぞ。

>>465-466
わいもようわかりません。
こんなかんじだしょか。

#include <iostream>
using namespace std;
const int x = 3;
const int y = 3;
int array[][x] = {
{1, 0, 0},
{1, 0, 0},
{1, 0, 0}
};

template<class T>
void proc(int x, int y, T (*data)[3])
{
int i, j;

for(i = 0; i < y; ++i){
for(j = 0; j < x; ++j){
data[i][j] = 0;
}
}
}

int main(void)
{
proc(x, y, &array[0]);
return 0;
}

>>464

>しかし、for_each() はメンバ関数で実行しているので見えてます。
見えない。for_eachはマクロではない。メンバ関数への
ポインタがthisに暗黙に束縛されることはない。

>正確には &(this->func) でしたね。
不正確だ。束縛された非静的メンバ関数へのポインタは
()オペレータ以外に使えない。
多くの場合コンパイラはthis->を無視するだろう。

>静的メンバ関数ではありません。
その関数に非静的メンバ変数を参照する文を追加するとどうなるだろうか？
確かにstaticでないなら、実装依存というより
マクロ的に実装しているコンパイラの不具合と言えるかもしれない。

>>466訂正：
template<Temp>　-＞ template<class Temp>
Proc(int x,int y,Temp data){　-＞　proc(int x,int y,Temp data){

>469
質問君なわいにもわかりました。ありがとうございます。

どうも、お久しぶり。
で、連想配列(ハッシュ)ですが、C++自体にはないが、
プログラマーの考えでどうにかなる、というものでしょうか？

だからmapじゃだめなの？>>471

だから STL にあるって...
大抵の環境では std::hash_map が用意されてる。
でも std::map でも普通は十分だし、
hash_map の方が遅いケースもある。

了解。

C++標準にstd::hash_mapは存在しない。
SGIのSTL実装には含まれる。

DirectXを用いてラインからリアルタイムに音波形表示するにあたって何かよい方法ってありますか？
MSC++4.0とDirectXSDK8.0なのですが・・・

>>476
DirectX8は、VisualStudio5.0SP3以上じゃなきゃ
駄目じゃなかったけ？

>>466さん
エラー無しで、完璧に動いてくれましたです。
有難うございますぅ〜

>>478
それじゃ結局多次元配列の使い方はわからないままじゃん。
いーのかそれで。
つっても俺もわからんかった。
これで正解なの？

const int x = 4;
const int y = 3;
int hairetu[y][x] = {
{1, 2, 3, 4},
{1, 2, 3, 4},
{1, 2, 3, 4},
};
void proc(int x, int y, int* data)
{
int i, j;
for(i = 0; i < y; i++){
for(j = 0; j < x; j++){
*data++ = 0;
}
}
}

int main(int argc, char* argv[])
{
proc(x, y, (int*)hairetu);
return 0;
}

>>478、>>479
君らC-faqって知ってるか？

>>480
C-faq？
Cの参考書ですか？

>>481
その何でも人に聞こうという姿勢を何とかしようよ。
検索すればすぐに見つかるんだからさ。世の中親切な人ばかりじゃないよ。

C-FAQは、↓参照
http://piza.2ch.net/test/read.cgi?bbs=tech&key=989929288&st=1&to=1&nofirst=true

>>482-483
親切な人、有難う。

＞477さん
あれ、そうでしたっけ？
そうしたらＳＤＫの７で製作しますがどんなもんでしょうか？

>>468
>見えない
それは、呼びもと（もしくは展開元）側では見えても、for_each()内部では見えないはずだ
という意味なのでしょうか？
464はメンバ関数内で別のメンバ関数を見ているのだから見えるという意味で書きました。

>非静的メンバ関数へのポインタは()オペレータ以外に使えない
そ・・・そうなのか。知らなかったです。

やっぱりARM買って読んどかないとまずいかな。

>>468
>その関数に非静的メンバ変数を参照する文を追加
フォーム上のリストボックス（当然非静的メンバ変数）に->add()してますから、既に存在してます。
あ、だったら当然に動的メンバ関数じゃなきゃ駄目じゃん。
・・・は、今ごろ理解が進んだ。
そうか、動的メンバ関数なら隠された引数(this)が必要なはずだから、関数ポインタだけ渡しても
呼べるはずが無い。
だから変だと言われていたわけですね。

おかしいですね・・・ソースの必要部分載せときます。
コンパイルオプションの警告設定はデフォルト指定の選択モードですが、コンパイル・リンク
などのエラーなしです。

// ProcessEntriesList定義
typedef list<PROCESSENTRY32> ProcessEntriesList;
// ProcessEntries
class ProcessEntries {
private:
public:
ProcessEntriesList& ProcessEntries::getEntriesList(ProcessEntriesList& EntriesList);
};
ProcessEntriesList& ProcessEntries::getEntriesList(ProcessEntriesList& EntriesList)
{
EntriesList.clear();

HANDLE ph = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (ph<0) return EntriesList;

PROCESSENTRY32 pe;
AnsiString str;

pe.dwSize = sizeof(PROCESSENTRY32);
Process32First(ph, &pe);
EntriesList.push_back(pe);

while (Process32Next(ph, &pe)) EntriesList.push_back(pe);
CloseHandle(ph);
return EntriesList;
}
// TForm1定義
class TForm1 : public TForm
{
__published: // IDE 管理のコンポーネント
TListBox *ListBox1;
TTimer *Timer1;
void __fastcall Timer1Timer(TObject *Sender);
private:
void __fastcall addProcessEntry(PROCESSENTRY32 pe); // ユーザー宣言
ProcessEntries pe;
public: // ユーザー宣言
__fastcall TForm1(TComponent* Owner);
};

// メンバ関数
void __fastcall TForm1::addProcessEntry(PROCESSENTRY32 pe)
{
AnsiString str;
ListBox1->Items->Add(str.sprintf("%d : ",pe.th32ProcessID) + pe.szExeFile);
}
void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
ListBox1->Clear();

ProcessEntriesList pel;

pe.getEntriesList(pel);
for_each(pel.begin(),pel.end(),&addProcessEntry);
}

　まだＣ++の勉強始めて4日ぐらいなんですけど、Cに比べて機械語との
対応関係が見えにくいってことはないですか?　慣れればそんなことない
んかな。っていうか、そんなこと考えるような時代じゃないのか?

ttp://www.csc.titech.ac.jp/~j91831/document/callback.html
なるほど。確かに、addProcessEntryは、普通のメンバ関数ではなかったのだ。
addProcessEntryは、__fastcall指定によって、
こっそりとレジスタからthisポインタを取り出し、あたかもメンバ関数のように動作する。
コンパイラからは、普通の関数、静的メンバ関数に見えるに違いない。

この動作は、TForm1ポインタをコンストラクタ引数に取る関数オブジェクトを使用するのに似ている。
__fastcall指定がほとんど決定的で、__fastcallを使っている以上、
そのテクニックを使っても当然だという人もいるだろう。

ちなみに、VC++では、__fastcallにこれほどの意味はなく、もちろんエラーとなる。

>>489
見えにくいだけで、見ることは出来る。
むしろ、オブジェクト指向言語の中で、
最も「マシン語コードがどうなるか丸見え」のはＣ＋＋。

Ｃ言語しか使ったことがない人は、
動きが把握できなくて不安になるかもしれない。
それは単に新しい言語だから知らないことが多いというだけで、
わかってみれば大した事は無い。

>>490
メンバ関数とはいえ、addProcessEntry()はコールバック関数ではないので、
オブジェクトインスタンスは存在しないはず・・・
こ、こりはもしかしてEAXレジスタのゴミ（この場合thisポインタ）が偶然に効いて
実行できたという話でしょうか？（呼び元のTimer1Timer()はコールバック関数だけど）

>>492
addProcessEntryもTimer1Timerも静的メンバ関数という意味で
コールバック関数であり、メンバ関数ではない。
もはや君に言うべき言葉を見つけられない。
addProcessEntryは静的メンバ関数である。
暗黙にthisポインタを使用することができることがまさに
非静的メンバ関数であると主張できるが、コンパイラが
そうとは思っていない以上、さらに、__fastcall指定が
存在していることから、非静的メンバ関数ではない。
何度でも言うがaddProcessEntryは静的メンバ関数である。

>>493
静的メンバ関数か否かは突き詰めればthisポインタ参照可能か否かに左右されるの
では無いのですか？（もしくはthisポインタ参照不要）
どう実装しているかは関係ないと思われますが。

現に静的メンバ関数にしてしまうと、当然に
E2231 メンバー 'member' はオブジェクトなしでは使用できない　　コンパイラエラー
が発生してコンパイルできません。
というようにコンパイラは非静的メンバと認識しています。

以上から__fastcall宣言は静的メンバ関数とは無関係な宣言と思われます。

>>494
それは私の言ったことを逆から言っているように見える。
私は、束縛なしに利用できるのだから静的メンバ関数に違いないと主張する。
束縛なしに非静的メンバ関数へのポインタを使用できるなら不正である。
これがメンバ関数ではないことを証明するかどうかは確かに不明瞭のように見える。
しかし、考えてほしい。もし正確にメンバ関数ならば、__fastcall指定がなぜ必要なのか？

束縛なしに利用できるなら、その関数へのポインタは、文字通り静的である。
そこで表現を和らげ、実装として静的メンバ関数である、というのは同意できると考える。
実際、これは水掛け論のように思える。__fastcall指定の存在自体がそれを暗示する。

ここで質問に答えなければならない。
__fastcallゆえ、Timer1Timerを呼ぶ際に、thisポインタがレジスタへプッシュされる。
その中で、for_eachに、ある関数へのポインタを渡す。
ある関数へのポインタは、__fastcallゆえ、残っていたthisポインタをそれが何かを気にせずポップして使用する。
これはTimer1Timerから呼ぶ以上、レジスタにたまたま残っているわけではないので、
実装として完全に正しいだろう。
言語としては、束縛なしに非静的メンバ関数へのポインタを使用することは不正である。

>>495
>これはTimer1Timerから呼ぶ以上、レジスタにたまたま残っているわけではないので
なるほど。最適化のせいとすればゴミとは意味が変わってきますね。了解しました。


しかし、__fastcallのせいとも言えないのではないかという状況になってきました。
以下のコードを見てください。
これがBCBだと何故かやっぱり動いてしまうんです。

#include <stdio.h>
#include <list.h>
#include <algorithm>
typedef list<int> IntList;
class ForEachTest {
IntList il;
public:
ForEachTest() {
for ( int i=0 ; i<10 ; i++ ) {
il.push_back(i);
}
}
void PrintList(int i) {
printf("%d\n",i);
}
void DumpList() {
for_each(il.begin(),il.end(),&PrintList);
}
};
int main(int argc, char* argv[])
{
ForEachTest fet;
fet.DumpList();
return 0;
}


ちなみに手元のUNIX機では当然にコンパイルできません。
bash-2.02# g++ -v
cc -v
gcc version 2.7.2.1
bash-2.02# g++ ForEachTest.cpp
/usr/include/g++/algo.h: In function `void (ForEachTest::* for_each(class list<int>::iterator, class list<int>::iterator, void (ForEachTest::*)(int)))(int)':
/usr/include/g++/algo.h:65: warning: argument passing to `ForEachTest *' from `int' lacks a cast
/usr/include/g++/algo.h:65: too few arguments to function



経緯はともかく結論として、&addProcessEntryをfor_each()に渡すのは、やっぱり
怪しすぎるコードである。
ということだけは間違いないですね。

intel系のアセンブラコードを読めれば、BCBの謎は解明できると思うのですが、私は読めないので
どうにもお手上げです。

>>496
なるほど私は、ただ踊らされているだけのようだ。
addProcessEntryは__fastcall指定のコンパイルオプションが
あったとしてもメンバ関数である。
だが依然として、実装として静的メンバ関数であることは
それほど間違っていないと言う。
私は__fastcall指定をなくすコンパイルオプションがあると信じるが、
for_each(pel.begin(), pel.end(), &addProcessEntry);
を許してしまうのは、明かにそのようなコンパイラの不具合と断言でき、
thisポインタをレジスタを介して渡すメカニズムのために、たまたま動く。

OS(Linuxとか、Winとか*BSDとかOSX)って、C++でかけるのかな。
すくなくとも、Linux はCでしょ。

Beは++らしいでぇ

class A、struct Bがあったとして、

Aのメンバ関数の返り値にBを使いたいんだけど
BのメンバにAも入れたい・・・
どうすればいいんでしょ？？

>>500
struct B;
class A {
struct B *hogehoge();
};
struct B {
A foobar;
};

>>501
ああ、なるほど！
さんきゅ〜〜！

> v(^・^)v

殺したい。

設計をみなおす。相互参照は少ないほどよい。

どうしても必要であれば、「前方宣言」で調べてみるべし。

>>504
それで設計見直してたらオブジェクト志向
の精神からはずれてしまうと思われ

>>498
一部がインラインアセンブラになるくらいで書けます。
C++でRTOSを自作したことはあるから、
あとはこれの規模を大きくするだけです。
BeOSもC++じゃなかったっけ？
またWindowsNTのモジュールの多くはC++です。
カーネル部分は知らないけど。

>>497
>なるほど私は、ただ踊らされているだけのようだ。
そう感じられましたら申し訳ありませんでした。
ただ、言われたことを鵜呑みにしても仕方が無いですから、自分でも調べられる
ことは調べて、それでも分からないこととか、見落としている点、勘違いしている
点を指摘してもらう。
そんな意図で色々と書いたりしています。

thisポインタの問題など、ためになる情報は非常にありがたいです。
できましたら、また疑問が浮かんだときには、ご協力願います。

>>505
うーん「ソフトウェアが表すもの(オブジェクト)が相互参照しているなら、
ソフトウェアも相互参照するべきだ」という主張なんだよね。
その主張自体はもっともだと思うけど、その理由"だけ"で相互参照を許すのは
あまり良くないと思うよ。
相互参照によって起こりやすいモジュール密結合の問題点をしっかり認識した
うえで採用するなら、もちろん何の問題もありません。

最終的な目標は良いソフトを作ることであって、オブジェクト思考や相互参照
の排除はそのガイドラインのひとつだよね。それぞれのガイドラインが相反する
としたら、それぞれの長所短所を比較してバランスをとる必要があると思うのね。

505氏はわかっているだろうけど、初心者が見て相互参照の問題点を理解せずに
「オブジェクト思考でOKだから、相互参照はOKなんだ」と思うと良くないと
思うので、意見しておきます。

Visual C++でプログラミングを始めた者です。

coutで指数表記を使う場合、3.15e+004のように指数部が３桁で表示されてしまいます。
これを指数部が２桁になるように書式設定することは可能でしょうか？
マニュアルにはなさそうだったのですが、ご存知の方はお教え願います。

>>509
#include <iostream>
#include <iomanip>
#include <math.h>
using namespace std;
int main(int argc, char* argv[])
{
double f;
f = M_PI;
cout << setprecision(3) << f << endl;
return 0;
}
というようにする。
ttp://www.page.sannet.ne.jp/mtoga/lang/cp/bih-p_09.htm
なんか参照。

あ、指数部？失礼、間違えた。

はい、「3.15e+04」のように表示したいのです。
仮数部であれば、cout << setprecision(n); ですね。

<< をオーバーロードするしかないのでしょうか。

delete[] a;
ってどーゆーこと？
deleteが拡張されてるの？

どんな定義がされているとこーゆー使い方できるの？

>>513
配列をnewで構築したときはdelete[]で破壊すべし。

例）
    new a = int[100];
      ：
      ：
    delete[] a;

激鬱
int* a = new int[100];

ｲｯﾃｸﾙ

>>514,515
なんか別の言語でそんな表記するのかと思ったYO!

ネットワーク上に共有されているCD-Rドライブや、
MOドライブの状態(読み込み中、待機中、開閉状態等々)
が分かるような簡単なアプリを作ろうかなと思ってるんですが、
どんな風にすればいいですかねぇ？
アイデア下さい。

本を探しています。
Install　Shield　For　Visual　C++6.0
大沢文孝/著
ネットサーブ/監修
出版社　アスキー
価格　3400円（税抜き）

新宿近辺で見かけた方いませんか？？？

>>514-515
親切な人
ありがとう

c++でプログラミングしたいですと、javaが好きな先生に言った。
オブジェクト指向が分かんないと意味ないから、始めにjavaを勉強して、
そのあと、オブジェクト指向が分かればc++、分からなければCにすればと言われた。
そんな感じでしたが、皆さんどう思われ？

>>520
妥当だと思われ。

>>517
C/Sにするのが一般的。
S側でデバイスを監視するデーモンを起動しておいてCでリモート。

vcでstringに+演算子が無いんだけど、なんで？

>>523
vcだから

C++全然わかりません。
+演算子って一時オブジェクトを作って返す？あってる？
じゃあそのオブジェクトの寿命はいつまで？
例えば

MyString a, b, c;
a = b + c;

b + cの部分で一時オブジェクトが作られるの？
a に代入するまでそれは生きてるの？
試してみたら不正な処理って出るんですけど。
誰かおしえてくださいませ。

>>524
粘着だね。アンチMFCキティ君（ｗ
ここは荒らさないでね。

>>525
C++では演算子の挙動も自分で記述できる。
そのクラスの演算子がどう定義されているか調べて見れ。

MyStringがどういうものだわからないけど
ちゃんと代入演算子定義した？

申し訳ない。
>>526の方が正確だわ
代入演算子だけでなく他の演算子(>>525の例だと+演算子)
が必要。(かどうかはMyStringによるが・・・)

>>527
たぶんちゃんと定義したと思うんですが。
MyString &operator=( const char *string);
MyString &operator=( const MyString &string);
こんな感じの代入演算子は作りました。動作確認済み。

んで、+演算子は
friend MyString operator+( const MyString &left, const MyString &right);
なんですけど。

デストラクタでprintfしてみたら代入前に解放してる？

コピーコンストラクタは？

>>530
あります。

>>531
あとは定義の内容かなぁ。

>>529
コピーコンストラクタは？

ひらに失礼

あ！
MyStringを受取る方のコピーコンストラクタの定義が無かったです。
定義したらちゃんと動きました、ありがとうございます >ALL

で、+演算子は一時オブジェクトを返すってのは正しいのでしょうか？

>+演算子は一時オブジェクトを返すってのは正しいのでしょうか？

正しくありません。
返すのは一時オブジェクトのコピーです。
最適化のされかたによっては一時オブジェクトは
作成されないかもしれませんが、その辺は私も
あまり詳しくありません。

>>535
Effective C++, More Effective C++を読むとここらへんの理解は進むわよ。

でも自分で簡単なテストプログラムを書いて自分で確かめてみるべきだと思うわ。
コンストラクタ、デストラクタ、コピー、代入の各関数にプリントを入れてみて
動作を追跡してみたらどうかしら。

>>535
よかったな。がんばれよ。
こういう向学心に燃える奴にならいくらでも協力してやるんだけどなぁ。
課題丸投げ厨に爪の垢煎じて飲ませてやりたいよ。

こんにちは。C から C++ に移行しつつある者です。
クラスの中に、関数 func と、関数へのポインタ *myfunc を定義して、
C 言語ライクに myfunc=func と記述したところ、エラーがでます。

具体的には、
#include <stdio.h>

class Hoge{

public:

double func1(double a){fprintf(stdout,"hoge\n");};
double (* myfunc)(double);

void setfunc(void){ myfunc = func1; }

};

というソースをコンパイルすると、

no matches converting function `func1' to type `double (*)(double)'
candidates are: double Hoge::func1(double)

てな感じでエラーがでるのです。

myfunc が func1 を指すようにしたいのですが、
C++ ではどの様に記述すればいいのか、お教え頂けないでしょうか？

結論から言うと、できないわ。

double Hoge::function( double ); (メンバ関数) と
double ::function( double ); (グローバル関数)
は違うものよね。
そしてfunc1は前者だし、myfuncは後者を指すポインタを表している。
なのでコンパイラがエラー報告しているわけ。

myfuncの定義をメンバ関数へのポインタに修正してあげれば良いわ。
class Hoge {
　double (*Hoge::myfunc)(double);
public:
　double func1(double a);
　void setfunc(void) { myfunc = func1; }
　double callfunc(double a ) { return( (this->*(myfunc))(a) ); }
...
};
とすれば通ると思うわ。

でも、C++で関数へのポインタを使いたくなったときには一度立ち止まって考えてみて。
仮想関数を使うほうが、アナタのやりたいことを効率的で型安全で保守性を保って
行うことができることが多いわよ。
がんばってね。

double (*Hoge::myfunc)(double);

でなく、 hoge::*myfunc でそ

VC++ではOKだけど G++ だと
アドレス代入の行 myfunc = func1 で

warning : assuming & on `Hoge::func1'

ってなwarningが出るんですが、 消すにはどうしたらいいんでしょう？

>>541 そのとおり。ゴメンなさい。

>>542
myfunc = &func1; にすればいいんじゃないかしら。

でもそれはエラーメッセージを読めば想像がつかないかしら？

すいません、G++使い始めたばかりで英語メッセージわからないんです

辞書引いたら assumingって でしゃばったって意味なんだけど どういうことなんでしょ？

VC++だと ＆ つけるとエラーが出ます
G++は 有っても無くても動く。なぜぇぇぇぇ？？？

>>545
辞書は assume で引いたほうがよいかと。「仮定する・推量する」

Thanx。VC++だと 仮想関数のｱﾄﾞﾚｽを取ろうとしました ってエラーなのは
なんでかなぁ、、、どっから仮想関数が出てくるんだ？

皆様レスありがとうございます。
以下のソースで g++ でコンパイル＆実行ができました。
(VC++ は手元にないのでちょっと確認できません。)

仮想関数の方が良い、という御指摘ですが、
それはこれから勉強して行きたいと思います。

#include <stdio.h>

class Hoge {
double (Hoge::*myfunc)(double);
public:
double func1(double a){return a;};
void setfunc(void) { myfunc = &Hoge::func1; }
double callfunc(double a ) { return( (this->*(myfunc))(a) ); }

};

int main(){

Hoge hoge;

hoge.setfunc();

fprintf(stderr,"%lg\n",hoge.callfunc(1));

}

ちょっと相談です。
Windowsでラップクラスを作ってるんですけど・・・

やってる事を一言で言えば
GetWindowLongとSetWindowLongでインスタンスのポインタを保存して
メンバ関数をプロシージャのようにしています。
このクラスはHWNDに関わるAPIをラップした基本クラスから派生させています。
ちょっと長いですが。

class CBaseWnd{
private:
　　m_hWnd;
public:
　　CBaseWnd() : m_hWnd(NULL){}
　　virtual LONG GetWindowLong(int nIndex){ return ::GetWindowLong(m_hWnd, nIndex) }
　　virtual LONG SetWindowLong(int nIndex, LONG dwNewLong){ return ::SetWindowLong(m_hWnd, nIndex, dwNewLong) }
};

class CRegistWnd : public CBaseWnd{
private:
　　static CRegistWnd* m_lpThis;
　　static LRESULT _WrapWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
　　{
　　　　/* 最初のメッセージ受信時はm_lpThisの値を::SetWindowLong(hWnd, 0, (LONG)m_lpThis)で格納*/
　　　　/* 以後はGetWindowLongでインスタンスのポインタを取得し、MainWndProcメンバ関数を呼ぶ*/
　　}
　　LRESULT MainWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) = 0;
public:
　　ATOM RegisterClassEx( /* 省略 WNDCLASSEXの値を引数で*/)
　　{
　　　　/* 内部でWNDCLASSEXに値設定&登録、その際cbWndExtraにはsizeof(CRegistWnd*)を入れている*/
　　　　/* プロシージャとしては_WrapWndProcを登録 */
　　}
　　HWND CreateWindowEx( /* 省略　CreateWindowExの引数と同等*/ )
　　{
　　　/* ::CreateWindowEx実行 m_lpThisにthisを入れておく*/
　　}
};

相談内容につづく

上記CRegistWndを使って自己登録ウインドウを作成するクラスにしようと思っています。
この時、cbWndExtraをインスタンスの保存で使っているので、上記クラスを使用する場合
このままではcbWndExtraを利用できません。

そこで、CRegistWndのRegisterClassExの引数としてcbWndExtraの値を設定可能にするために
この関数の内部で、引数で指定されたcbWndExtra + 指定のcbWndExtraの値 + sizeof(CRegistWnd*)
のようにポインタ分のメモリをを内部で余計に取るようにします。

そして、SetWindowLong等をこのクラスから普通の感覚で使えるようにするために
SetWindowLongとGetWindowLongをオーバーライドして、
nIndexの値が正の数の場合に、指定された数よりsizeof(CRegistWnd*)を足して
外見上ほぼ同等の動作をさせるようにしました。


このようなクラス設計はダメダメな設計でしょうか？
実際にこのクラスを使う場合、CRegistWndからさらに派生して使う事になるのですが、
その時にSetWindowLong等をオーバーライドして違う動作をさせた場合に
問題が発生する可能性があります。

オーバーライドした物の内部でCRegistWnd::SetWindowLongを
呼び出してくれれば良いのですが、人にこのクラスを使ってもらう場合
直接::SetWindowLong等を呼び出してしまうかもしれません。

習慣的には同等の動作をさせる場合は、出来るだけ派生元クラスの関数を
呼び出すものかとは思うのですが・・・

どなたかご教授お願いします。

メンバ関数のポインタの話 の続きなんですが、クラス外からの呼び出し方法についてなんですが

class hoge{
public:
void (hoge::*pFunc)();
hoge(){ pFunc = func; }
void func(){printf("omaemona" ); }
}

とこんな感じでポインタに入れたのをメイン関数から呼ぶのどうすればいいんでしょう？
main(){
hoge instance;
(instance.*pFunc)();
}
かとおもったら pFuncが定義されないってエラーがでます

>>551
pFuncが定義されてないんじゃない？

初期化してない普通のポインタ使おうとしてもそうなるでしょ？

>>551
ttp://puyon.pns.to/program/afl/h0002.html
これは？

>>551

＞void (hoge::*pFunc)();
「hoge::」いらないんじゃない？

あぁ .*演算子の右辺は左辺のメンバにアクセスするのと違うんですね
よく考えたら当たり前

（instance.*instance.p)() でokでした。でもなんか間抜け。もっとダイレクトにかけないのかしらん

>>554
ちょっと上に出てるけど、クラス内のメンバ関数のポインタの場合は必要です
いらないのは C の場合（後staticメンバ関数の場合）

C++で関数へのポインタが必要なときは、
設計を間違えたときだけ。

>>557
んなこたぁ、ないよ。

>>557
同意

すみません、Cのランタイムや生のDLLを呼ぼうとしてました。
これからはSTLやCOMを使いますので許してください。

こんにちは。昨日に引続き、C から C++ に移行しつつある者です。
new 演算子で、二次元配列を確保する方法に関して質問です。

C の malloc の様に、動的に二次元配列を確保する際、
配列サイズを変数 NX、NY で制御したいのですが、うまくいきません。
具体的には、以下のようなソースのコンパイルに失敗します。

class Pixel{

public:
int v;
Pixel(int i=0){v=i;};

};


class Image{

public:
int NX,NY;
Pixel **p;
Image(int myNX=1,int myNY=1){
NX=myNX;
NY=myNY;
Pixel (*p)[NY] = new Pixel[NX][NY];
};

};

NX、NY ではなく、具体的な数でやれば成功するのですが、
NX、NY を用いて確保したいのです。
ご存知の方はお知らせ頂けないでしょうか？

>>561
そりゃCからC++に以降以前の問題。
mallocでも無理だろう。
Cの基本部分すら理解していないようなので、一からやり直すべし。

>>562
malloc 使えば、

p = (Pixel **)malloc(sizeof(Pixel *)*NX);

for(i=0 ; i<NX ; i++){
p[i] = (Pixel *)malloc(sizeof(Pixel)*NY);
}

で、できますが…。

>>563
それなら、

p = new Pixel*[NX];

for(i=0 ; i<NX ; i++){
p[i] = new Pixel[NY];
}

とすればよいだけのような...。pは２次元配列なのか配列へのポインタなのかはっきりすべし。

誰か「Pixelをクラスにするのはやりすぎだよ」って
教えてあげれば良いのに。

>>561

２次元配列なんか不要。
ポインタの配列のぶんだけメモリ消費量も激しいし、速度も遅くなる。

#include <vector>
using namespace std;

class Pixel {
　int v;
public:
　Pixel(int i=0) : v(i) {}
　int Set(int c) { return v = c; }
};

class Image
{
private:
　int NX, NY;
　vector<Pixel> m_Pixel;
public:
　Image(int myNX = 1, int myNY = 1)
　: NX(myNX), NY(myNY), m_Pixel(myNX*myNY)
　{
　}
　Pixel &Dot(int x, int y) { return m_Pixel[y * NX + x]; }
};

Image img(50, 50);
img.Dot(10, 10).Set(crRed);

マイナー次元の要素数が決定していないと
多次元配列にはアクセスできないよ。
NX*NYの１次元配列として確保して
Pixel[myNX*NY+myNY]とかしないとダメ。

>>561
論点ずれるけど2次元配列なんか使うより、
フラットに使った方がスマートでないかい？
[ ][ ]は使えないけど。

class Image {
int NX, NY;
public:
　Pixel *p;
　Image(int myNX=1,int myNY=1) : p(new Pixel[NX * NY]) {};
　Pixel operator()(x, y) { return p[x * NY + y; };
};
NYを2の倍数にすると吉。

>>565
Pixel は例えでして、本当は、２次元格子上に細胞モデルを配置した
数学モデルを考えています。ただ、逆に混乱させてしまったかも知れません。

>>566
一次元配列を二次元にマップするのはわかりましたが、
vector<Pixel> の部分 (テンプレート？) がまだ勉強不足で
わかりませんので、今晩検討してみます。

>>566
かぶったスマソ

再び 561 です。

569 を書いている間に、さらに 2 人の方のレスが。
ありとうございます。

みなさん一次元配列を使うべし、というところは
共通しているようですね。試して見ます。

>>568
ブラケットどうしても使いたいのであれば、

template <class T> class CArray2D { // エラーチェック省いてます
T** pptAry;

public:
CArray2D(void) : pptAry(NULL) {}
~CArray2D() { Free(); }

operator T**() { return pptAry; }

void Alloc(int nWidth, int nHeight) {
Free();

pptAry = new T*[nHeight];
pptAry[0] = new T[nWidth * nHeight];

int nY;
for (nY = 1; nY < nHeight; nY++)
pptAry[nY] = pptAry[0] + nY * nWidth;
}

void Free(void) {
if (pptAry != NULL) {
if (pptAry[0] != NULL) delete[] pptAry[0];
delete[] pptAry;
pptAry = NULL;
}
}
};

というテンプレートクラスを作って、
CArray2D<Pixel> aPixel;
aPixel.Alloc(16, 16);
aPixel[0][0].Set(...);
とか。

>>572
そこまでして[]を使う意味があるの？
(x,y)でええやん。

あとC++では0をdeleteしても大丈夫です。
だから無効なポインタには0を入れましょう。
処理系によってはNULLが0ではない可能性があるので、
NULLは使わないようにしましょう。

>>572
サンクス。
列分の配列が増えちゃうね。下でどうだ。
＃オペレータオーバーロード萌え〜

template <class T> class Array2D {
　const int rawWidth;
　T* array;
　struct Raw {
　　T* raw;
　　Raw(T* nRaw) : raw(nRaw) {};
　　T& operator[](int x) { return raw[x]; };
　};
public:
　Raw operator[](int y) { return Raw(array + y * rawWidth); };
　Array2D(int w, int h) : rawWidth(w), array(new T[w * h]) {};
　~Array2D() { delete[] array; }
};

int main() {
　Array2D<Pixel> aPixel(16, 16);
　aPixel[0][0].Set(1);
　return 0;
}

>>574
そこまでやるなら、いっそのこと２次元イテレーターとかを作って、
汎用コンテナにしてはどうか。
Ｘ方向にＹ＝３でソートとかできると便利かも。

>>573
>そこまでして[]を使う意味があるの？
>(x,y)でええやん。
普段Java好きだから同意。
けど２次元配列使ったソースをコンパイルし直すだけで、
リユースできれるから無意味でもないと思う。

> あとC++では0をdeleteしても大丈夫です。
> だから無効なポインタには0を入れましょう。
そうだったのか。
コンパイラに起こられるからではないのですね(Javaちゃうって)

> 処理系によってはNULLが0ではない可能性があるので、
> NULLは使わないようにしましょう。
それはどこかの馬鹿がどこかで
#undef NULL
#define -1
とかしているのでは？
0で良いは同意だけどNULLでも悪かないでしょ？
#include <stdlib.h>とかすれば

>>573
内部では0では無い事が、多々ありますが、
Cの中では、NULL==0は保証されてたと思いますよ。
576さんが言われるとおり、誰かが0以外にしない限り…。

>>576

ANSI規格で、0のdeleteが安全であることは保障されています。
一方、NULLが0であることは保証されていません。

それだけのことだよ。

CはNULL==0は保証されていないけど
C++はNULL==0が保証されてるんじゃなかったっけ？
間違ってたらｽﾏｿ

>>ALL
NULLの話をすると長くなりそうなので、やめませんか？

#include <string>
using namespace std;

void f(string p1, string p2);

の関数にデフォルト引数を設ける場合、

void f(string p1 = string(), string p2 = string());
という書き方ではまずいでしょうか？

VC++ だとコンパイルエラーになりした。GCC g++ だと
コンパイルエラーになりませんでした。

>>581
まずくないです。
ANSI準拠のC++なら通ると思います。

#include <string>
のstringで引っ掛かったのでは？

>>582
最近おとなしいね。アンチMFCキティ君（藁

>>583
ｱﾌｫｳ

>>582
ありがとうございます。言語仕様上問題無いという
裏付けが中々見つからず、頭を痛めておりました。

>>583
string型でないケースでも同様でした。例えば、

class T{
public:
T();
};

void f1(T p1 = T(), T p2 = T());
→ error C2062: 型 'class T (__cdecl *)(void)' は不要です。
というエラーになります。(VC++)

ただ、
void f1(T p1, T p2 = T());
はコンパイルエラーになりませんでした。(VC++)

>>586
こういうときはANSI準拠に依存する必要があるかどうかをまず十分に検討せよ。

>>587
> こういうときはANSI準拠に依存する必要があるかどうかをまず十分に検討せよ。
というのはなんだかなあ…。
C++の問題かVC++の問題かを切り分けるべきだろう。

VCのANSI対応云々は荒れるからここではおいとくとして、
そのデフォルト引数の使い方はどうかと思うけどな。
関数呼び出しがヘッダ側にあるというのはどうにも保守しにくそうで。

例外処理について２００字以内で簡潔に説明してください。
これがわかるほどの人はここにはいないか〜

590が課題でないことを200字以内で簡潔に説明してください(5点)。
人にたよって課題を終わらせようとする590が、将来真人間になる
可能性を200字以内で簡潔に説明してください(95点)。

>>590
http://piza.2ch.net/test/read.cgi?bbs=tech&key=991726421&nofirst=true&st=16&to=16

>>590
このスレを頭から読み返してみなよ。

>>591 - 593
わからないならレスをつけないでくださいよー

この板バカばっかりでだめいたなのかもね
こんなとこで得られるものなんてなにもないなー

>>590
例外処理: C++では例外はthrowしてcatchする。

>>596
我ながら簡潔で素晴らしい。

>>590
みんなを煽って宿題をやらせようとしているヴァカ

もしくは相談室を何か違うものと勘違いしているヴァカ

>>594
http://piza.2ch.net/test/read.cgi?bbs=tech&key=991726421&nofirst=true&st=16&to=16

>>598
できないならできないと素直にいえよー
だいたい宿題だとしても人にやってもらって何が悪いんだ
おまえだってできない仕事を人に押し付けてるくせに

>>600
ヴァーカヴァーカ

ピューピュー

>>601
おまえがだろー
わかんないっていえよー
おらー

>>600 だいたい宿題だとしても人にやってもらって何が悪いんだ
本気でそう思ってるの？
授業料どぶに捨てるのも個人の自由と言われれば何もいえないけど。

レベルの低い罵りあいだな（藁

例外処理くらいgoogle一発だと思うが
小学校で辞書の引き方を習わなかったんだろうな
登校拒否のヒッキーの末路か……

例外処理
C++ではthrowとcatchを使う。
throwを実行するとcatchに飛ぶ。goto文の変種である。
gotoと違って他の関数に飛べる。
滅多に使われないから例外処理と呼ばれている。

>>600
http://piza.2ch.net/test/read.cgi?bbs=tech&key=991726421&nofirst=true&st=16&to=16

>>606
ﾜﾛﾀ

今まで僕の中でもやもやとわだかまっていたものがすっきりとしました
606サン本当にありがとうございました。

>>603
個人の自由じゃないです。
他人に宿題やらせて卒業して社会人になると社会全体が迷惑しますから。

>>610
おまえの存在自体が社会の迷惑なんだよ
高卒がー

元気だね、課題丸投げ厨。
2ch読んでるヒマあったら勉強しろこのｸｿｶﾞｷが。

>>612
かよわい妹の宿題を手伝ってくれないなんて。。。
おにいちゃんのいじわる。。

>>594
>わからないならレスをつけないでくださいよー

同じ事を同じスレで言いたくないから、
>>593と言ったのだ。

>>614
わかってないのはお前ただひとりだよ。
http://piza.2ch.net/test/read.cgi?bbs=tech&key=991726421&nofirst=true&st=16&to=16

誤爆。
×614
○613

ｽﾏｿ>>614
鬱氏

Singletonパターンを、全てのメンバ変数やメンバ関数をstaticにする事で代用する事は可能ですか？

>>617
オブジェクト指向における再利用のためのデザインパターン　第３版より
「Singletonパターンと同等の機能を提供する別の方法として、
クラスオペレーション（C++における静的メンバ関数、Smalltalkにおけるクラスメソッド）を
用いることもできる。しかし、このような言語上のテクニックで対処する方法では、
クラスのインスタンスを１つ以上に変更する場合に困難にになる。
さらに、C++における静的メンバ関数は仮想関数にすることができないので、
サブクラスにポリモルフィックにオーバーライドすることはできない。」

class A; ← Singleton
class B : public A;

A a;
B b;

Aは１つ、Bも１つ、AとBは共存、としたい場合にどうよ。

>>617
やってみて、出来たら出来る。
出来なかったら、出来ない。

>>618
class Bの書き方に気をつけないと、Singletonじゃなくなるぞ
Singletonパターンを作りたい場合は基本的に継承禁止にすべきだと思うが

C++でクラスのコンストラクタにつけることができる、
explicit修飾子が良くわかりません。
一応、MSDNの日本語解説は読んでみたのですが、
引数の暗黙の型変換は一切ゆるしませんという宣言と思
えばよいですか?

SLTのコンテナをヒープに作ることはできますか?

>>618
良くわかりました。どうもありがとうございます。

>>620

>Singletonパターンを作りたい場合は基本的に継承禁止にすべきだと思うが

実装を複雑にして流用しやすくするか、
流用できなくてもいいから実装を単純にするか、
それは状況に応じて選べばいいと思う。
staticメンバ関数でやるというのも一つのやり方だろう。

>>621

explicit修飾子の機能的な面に目を奪われているようだね。
暗黙の型変換についてよく考えてみよう。
この機能は、何が良くて、何が悪いのか、
まだよくわかってないんじゃないか？
理解できれば、explicitの使い方は教わらなくても自然にわかるようになる。

>>622
できます。

vector<int> *p = new vector<int>();
vector<int> *p = new vector<int>(16);
vector<int> *p = new vector<int>;

だけど、こんなのgotoより使わないだろ。
何かのクラスのメンバにいれておけばいい。
class A
{
　vector p;
};
コンテナは何がしかのクラスがきっちり管理しておくべき。
コンテナの責任者は誰なのか明確にしておかないといけない。
複数のクラスが共同で管理しようとすると破綻するよ。

「この機能」は「暗黙の型変換」をさしているのですか?

>>625
explicitの機能を指してるのかと思われ。

鉄則：explicitの意味がわからないやつは単一引数コンストラクタにはすべてexplicit付ける事。

知らなかった……

class a
{
public:
a() {m_i=0;};
a(int i) {
m_i=i;
};

protected:
int m_i;
};

void func(class a)
{
}

func(1);

int &Fact()
{
int a = 10;
return a;
}

int main()
{
int a = Fact();
cout << a << endl;

return 0;
}
これはだめなんでしょうか
結果は

10

ってなったんですが

int &Fact()
{
int a = 10;
return a;
}

int main()
{
int a = Fact();
cout << a << endl;

return 0;
}
これはだめなんでしょうか
結果は

10

ってなったんですが

int &Fact()
{
int a = 10;
return a;
}

int main()
{
int a = Fact();
cout << a << endl;

return 0;
}
これはだめなんでしょうか
結果は

10

ってなったんですが

int &Fact()
{
int a = 10;
return a;
}

int main()
{
int a = Fact();
cout << a << endl;

return 0;
}
これはだめなんでしょうか
結果は

10

ってなったんですが

int &Fact()
{
int a = 10;
return a;
}

int main()
{
int a = Fact();
cout << a << endl;

return 0;
}
これはだめなんでしょうか
結果は

10

ってなったんですが

int &Fact()
{
int a = 10;
return a;
}

int main()
{
int a = Fact();
cout << a << endl;

return 0;
}
これはだめなんでしょうか
結果は

10

ってなったんですが

int &Fact()
{
int a = 10;
return a;
}

int main()
{
int a = Fact();
cout << a << endl;

return 0;
}
これはだめなんでしょうか
結果は

10

ってなったんですが

int &Fact()
{
int a = 10;
return a;
}

int main()
{
int a = Fact();
cout << a << endl;

return 0;
}
これはだめなんでしょうか
結果は

10

ってなったんですが

int &Fact()
{
int a = 10;
return a;
}

int main()
{
int a = Fact();
cout << a << endl;

return 0;
}
これはだめなんでしょうか
結果は

10

ってなったんですが

int &Fact()
{
int a = 10;
return a;
}

int main()
{
int a = Fact();
cout << a << endl;

return 0;
}
これはだめなんでしょうか
結果は

10

ってなったんですが

とりあえず落ち着け

>>639
大爆笑

int &Fact()
{
int a = 10;
return a;
}

int main()
{
int a = Fact();
cout << a << endl;

return 0;
}
これはだめなんでしょうか
結果は

10

ってなったんですが

int &Fact()
{
int a = 10;
return a;
}

int main()
{
int a = Fact();
cout << a << endl;

return 0;
}
これはだめなんでしょうか
結果は

10

ってなったんですが

int &Fact()
{
int a = 10;
return a;
}

int main()
{
int a = Fact();
cout << a << endl;

return 0;
}
これはだめなんでしょうか
結果は

10

ってなったんですが

int &Fact()
{
int a = 10;
return a;
}

int main()
{
int a = Fact();
cout << a << endl;

return 0;
}
これはだめなんでしょうか
結果は

10

ってなったんですが

int &Fact()
{
int a = 10;
return a;
}

int main()
{
int a = Fact();
cout << a << endl;

return 0;
}
これはだめなんでしょうか
結果は

10

ってなったんですが

int &Fact()
{
int a = 10;
return a;
}

int main()
{
int a = Fact();
cout << a << endl;

return 0;
}
これはだめなんでしょうか
結果は

10

ってなったんですが

落ち着いたみたいだね。

さて、結論から言えば駄目です。
ローカル変数の参照を返すのは全て駄目です。
何でも動けばいいってもんじゃない。

MFCのQueryInfoStatusCodeで取得できるStatusCodeを
MFC使わずに取得したいのですが、何か方法ございますでしょうか？

うんち。

>>648
(何がしたいのかイマイチよくわからんが)
ソケット開いて GET 要求出したあと、
帰ってきた 1 行目(だったかな?)に書いてある。

telnet で 80 につなげて GET 要求出してみりゃ、すぐわかる。

thisってどうして自分のポインタを返すのですか？

thisの意味を英和辞典で調べるように。

>>651
thatだと相手のポインタかな…って思っちゃうでしょ?

>>651 仕様です

仕様なのでしようがないのですか？

>>655
そのオチが言いたいために質問したのですか？

>>655
はい
ごめんなさい

おい、82、
クッキー残ったままだぞ。

>>658
クッキーってなんですか？

>>658
クッキーってなんですか？

クッキーとビスケットとサブレとクラッカーの違いはなんですか

あたり前田のクラッカー。

ポケットビスケットつ

ポケットビスケットつ

VCでクラスに初チャレしたんですが、
externで他のソースの関数を使うみたいに
他のソースのクラスにあるpublic関数を使う方法って
無いんでしょーか？
厨房な質問ですんまそん

publicなら、そのクラスの定義をincludeすれば使えよう。

>>665
使用するクラスのヘッダをインクルードすればよいだろう。
メンバ函数をさもグローバル函数のごとく使おうと思っているのなら
設計レベルの話しになるが。

>>667
>メンバ函数をさもグローバル函数のごとく使おうと思っているのなら
できるの？

>>668
staticにする。が、いきなりやると自動的に、メンバになってる意味があるか
どうかとかの検討（葛藤）が始まって気持ち悪くなるので、設計時によく考えて
実装すべし。

>>669
代弁してくれた。
>>668
まぁ要求するものによっていろいろあると思うけど、
はじめからグローバル函数にするとか、namespaceも考慮するとか、
static函数にするとか、同じ機能をもつ函数だけど名前をかえるとかなど。

>メンバ函数をさもグローバル函数のごとく使おうと思っているのなら
>設計レベルの話しになるが。

激しく同意。

綺麗に設計されていれば、Ｃ＋＋の機能を素直に使って実装できる。
あれこれテクを駆使しなければならないときは、たいてい
設計に問題がある。

俺もＣ＋＋を使い始めた頃は他のクラスの関数を流用したいと思った。
こういう制限が出てきたときは、そのクラスの使い方を間違っているか、
そのクラスの設計に問題があるかのどちらか。

C++Builder5で

class TDataModule1 : public TDataModule
{
public:
__declspec(dllexport)long hoge1(AnsiString, AnsiString *);
BOOL hoge2( char * , double * );
};

__declspec(dllexport) long TDataModule1::hoge1(AnsiString hogeStr1,AnsiString* hogeStr2
)
{
hoge2(charhoge1,doublehoge1);
}

BOOL TDataModule1::hoge2( char* hogechar1, double* dwhoge1 )
{
return true;
}

とすると、『外部シンボルhoge2がプロジェクト名.objで未解決です』という
リンカエラーになってしまいます。どこが悪くてエラーになるのか分からず
困っております。低レベルなミスとは思いますが、解決法あれば教えていただけないでしょうか。