C++相談室２

v(^・^)v

http://www.kuzbass.ru/docs/isocpp/

あは

下のようなのを書いたんですが、ちゃんと動きました。
これはC++的にはアリなんでしょうか？

class foo
{
public:
　　int bar;
};

int main( int, char **)
{
　　foo a;
　　a = 0xDEADBEEF;
　　printf( "%08X\n", a);
　　return 0;
}

>>3
メンバ関数の無いクラスは構造体のようなもの。
メモリにべたコピーされてるだけで今のところ
うまくいってるだけ。

>>3
良く動いたね。
正しくは、
a.bar = 0x0deadbeef;
ってやった方が良いよ
どう動いてるのか　俺にはさっぱりだ。
ウツダシノウ

試してないけど、上のコードはコンパイル通るのか？
=演算子や型変換の演算子も定義してないぞ。。。。

[C++ エラー] Unit1.cpp(19): E2034 'unsigned long' 型は 'foo' 型に変換できない

動きませんな。

>>4
メンバ関数のあるなしでC++の構造体はメモリ上の配置の仕方がことなるのでしょうか？
Cと同じように構造体が実装されているようには思えないのですが。。

また独習C++を読むと、
classとstructはデフォルトのアクセス指定子が異なるだけ、なんて
書いてあるんですが、これはホントですか？

アセンブラが分からないヘタレですみません。

$g++ samp.cc
samp.cc: In function `int main(int, char **)':
samp.cc:11: no match for `foo & = unsigned int'
samp.cc:6: candidates are: class foo & foo::operator =(const foo &)

gccでもダメでした。ところでコンパイルが通るってどんなコンパイラ
使ってるんですか？＞＞３

やっぱりネタですよね？ｗ

>>8
そうです。デフォルトでpublicかprivateかの差だけです。

メモリ上の配置が変るのは、処理系によっても違うかも
しれませんが、仮想関数を持った時に仮想関数テーブル
へのポインタが自動的に追加されます。

C++のコードをＣに変換してみよう！

"C++"

class CClass
{
private:
　int n;
public:
　void func1(int a);
　virtual void func2(int a);
};

CClass c;
c.func1(0);
c.func2(1);

"C"

void *CClassVTable[] = {
　CClass_func2;
};

typedef struct CClass
{
public:
　void **v_tbl = CClassVTable;
private:
　int n;
};

void CClass_func1(CClass *this, int a);
void CClass_func2(CClass *this, int a);

CClass c;
CClass_func1(&c, 0);
c.v_tbl->CClass_func2(&c, 1);

Cのコードが分からない｡｡｡鬱だ

>>11
続きは？

あいまいなｼﾝﾎﾞﾙって何じゃー？どうせいっつんじゃー
さっきまで動いとったのに、2,3行目加えただけで
コンパイル不能になっとるし。

1 #include <fstream.h>
2 #include <string>
3 using namespace std;
4 int main()
5 {
6 ofstream obj("test.txt");
7 return 0;
8 }

>test0.cpp(6) : error C2872: 'ofstream' : あいまいなｼﾝﾎﾞﾙです。

「C++相談室２」というタイトルと

↓この顔文字

v(^・^)v

の組み合せはまさに芸術だと思う。

>>14
1行目が悪いんじゃないか？

>>14 STL厨房
1c1
< #include <fstream.h>
---
> #include <fstream>
もしくは、
3c3
< using namespace std;
---
> //using namespace std;

SEE ALSO
http://www.microsoft.com/japan/developer/library/vccore/c2872.htm

>>16 >>17
レスどもっす。
.h の方を使うと内部で暗黙に namespace が有功になってて
外部で再び宣言すると、名前がかぶって ofstream がどっちに
属すのか特定できんって事なんかな｡｡｡

STLのリストに関して質問がござる。

いまリストの特定の要素を削除したいのじゃが、
そやつの『アドレスを知っている』場合の処理について
悩んでいるのでござる。それがしはこれまで
イテレータで頭から順繰りに伝って、

struct _hoge xxx; // 消したい要素の化身
list<struct _hoge>::iterator i;
for(i=hoge.begin(); i!=hoge.end(); ++i)
if(&(*i)==&(*xxx)) hoge.erase(i), break;

などとやってきたわけでござるが、
最近これはとても非効率な気がしてきたのでござる。
なんとなれば要素のアドレスを知っている限りにおいては
直接にその要素を削除して、リストの前後関係を
修復するような機能があってもよさそうではござらぬか。
つまりhoge.erase(pos)[posはイテレータ]の
アドレス版hoge.erase2(&xxx)みたいなものでござる。
しかし『C++標準ライブラリ チュートリアル＆リファレンス』
なる書物を紐解いてみるに見つける能わなんだ。

当方、イテレータなるものについての理解が浅い故、
頓珍漢なことを申してるやも知れぬが、
右の点に関してなにとぞお知恵を拝借致したく候。

「アドレスを知ってる場合」云々はおいといて
list::remove()を使わないで　イテレータで自分で回して比較しているのには
何か理由があるのか？

まじめに質問しているのならふざけた口調はやめたほうがいいぞ

かたじけない >>20
エセ侍風はお気に召されなかったようで、口調を戻します。

removeを使えばよいという指摘、その通りでした。半分解決です。
自分でイテレータを回して比較していることに意味はありませんでした。

で私の中で未解決の点というのは、removeは値が該当するもの全てを
削除するようなので、結局内部的には全検索しているのですね。
疑問に思ったのは、消したい要素のアドレスが判ってるならば、
その要素をピンポイントで消せる方法があってもいいのに、ということです。
この考え方は変でしょうか。

listのメンバとしてstruct本体じゃなくてstructのポインタを持つ
ようにすればいいのでは？

>>21
消したい要素のアドレスがわかってたとして　そのアドレスがlistのどこに
あるかは探さなければわからないのは当然じゃない？
要素自体を消したいんじゃなくて　要素を「listから」消したいんでしょ？

>>23
> そのアドレスがlistのどこにあるかは探さなければ
> わからないのは当然じゃない？

リストって各要素が前後の要素とポインタで繋がれているだけの
単純な構造だと思っていたんですが、これが私のそもそもの誤解かな？

上のように考えていたので、要素を適切に削除するには、
要素のアドレスを知っている場合（該当要素に直接アクセスできる場合）は、
前後の要素についてポインタの繋ぎ変えをした後で、
該当要素のメモリを解放すればそれでおしまい、
つまり要素の前後関係だけが重要だから要素がリストのどこにあるかは
関係ないと思っていたんですが、そんなに単純ではないということでしょうか。

むむむ。

リストを構成しているそれぞれのノードはポインタでチェーンされているが
そのノード自身のアドレスと　ノードが参照している中身のアドレスは別物。

STL内で
template <class Temp>
class Atom
{
Temp m_Youso;
Atom* p_next;
Atom* p_before;
};
のようにラップされているのだろうけど、それはＳＴＬを作っている
ところ次第だし、ヒープの確保＆解放の最適化を行うためにもう
一つラップクラスを用意しているだろう。このあたりはvectorの内部
ポインタ、_First,_Last,_Endの機能と同様のものだと思う。
　強引に
temlate <class Temp>
MyList : public list<Temp>
{
public:
void
erase2(Temp*);
};
のようなことも可能だがprotectedなメンバを書きかえるよな
操作はしたくないのが本音。複数のバージョンのＳＴＬを考
えるとやりたくない。

>>25
至極なっとくでござる。
お付き合いどうもありがとう。

>>26
おぉ、これもレスですね。どうもありがとう。
今すぐには理解できないけど少し反芻してみます。
一度はヘッダの中身を覗いてみないとダメですね。

>>28
STL じゃないが、格納されるデータ自体にポインタを持たせたコレク
ションの実装として 4.4BSD の <sys/queue.h> がある。もともと C
言語用のマクロだが、これに C++ 風のインターフェースをかぶせたも
のが、

http://diary.imou.to/~AoiMoe/2001.03/middle.html#2001.03.15_s04
http://www.issei.org/diary/d200104c.html#22-1

にあるぞ。

葵萌えさんの日記は直林禁止だったはずだが。

直リン禁止なんて言ってる奴も守ってる奴もDQNだ。
検索エンジンに引っかかったらロボットに向かって文句言うのか？

>>30
最新版の日記を見ると、上のほうに「逆リンクを許容できる場合に限り、リンク
はご自由に」と書いてあるよ。

virtualの使いどころがわからないっす。
だから使ったことないデス…。

>>33
ネタ？

本気なら「憂鬱なプログラマのためのオブジェクト指向開発講座」を
買ってきて読みましょう。C++ は言語仕様から勉強するとワケ分から
なくなるが、先にオブジェクト指向の分析・設計手法を勉強して、そ
れを実装に落とすための道具として見ると、簡単に理解できる。

ネタでしょ。
本気で分からんやつは、一度Javaを使ってみるといいかもしれんね。

いや、Effective C++の第6章35項を8回、読み直せ。

>>32
あれ、最近のには書いてないね。
昔は、MLとか掲示板とか不特定多数からアクセスが殺到するような場所に
URLを貼らないで欲しいというようなことが書かれてあったような。

サイト引っ越して環境が変わったからよくなったのかな。ま、もう書いてないからいいや。

>>35 Javaはすべてのメソッドにvirtualついているようなものだから
かえって意識しにくいと思われ、、、

Javaは純粋仮想関数、抽象クラス、匿名クラスでどうこう
って感じだからかえって混乱するかも。
33は継承パターンを自分で作って動作を追跡すれば理解が
進むと思う。特にディストラクタの　virtual 宣言は多態性を
表現する上で重要。

C++と直接関係無いんだけど質問。

みなさん日本語処理（や文字列処理）ってどうしてますか？
やっぱりAnsiString?

実は日本語コードの変換機能付きのストリングクラスを作ったのですが
一文字ずつ文字を追加する処理が遅くて困ってます。
string += 'A'; <- こんなの。

みなさんの文字列処理のやり方を教えてくださいませ。

>>40
どこが遅くなるのか分かりませんが、変換は必要なときだけ
やればｲｲですよね。

>>41
はい、変換は必要な時だけしかやってません。

遅くなるのは・・・
１、約5000行(380KB)のテキストファイルを読み込んでコードを調べて変換
２、一行ずつに分離して文字列リスト(これも自作のクラス)を作成
３、全部の行から特定のキーワード(約10文字)を検索
って処理をした時に2番目の処理で3秒ぐらいかかってしまいます。

コード変換無しなら一瞬で終わるような処理なんですけどね・・・。

>>42 一行ずつに分離して文字列リスト(これも自作のクラス)を作成
の部分で
>>40 一文字ずつ文字を追加する処理が遅くて困ってます。
という問題があるという話なら
コード変換は全く関係ないと思うんだけど

>>43
まったくおっしゃるとおりです。
実はもう改良済みです。

で、ホントに聞きたいのは「日本語処理ってどうしてます？」ってことです。
もしかして普通は特定の日本語コード決め打ちなのかなぁ？

>>44
俺のWindowsプログラムの場合、
内部コードは ShiftJIS か Unicode で持っておいて
ファイル入出力の時に[必要なら]変換…だなぁ。

エディタを作るんでもなけりゃ、あんまり多文字コード対応にしても意味ない気がする。

すみません。誰か教えてください。
引数宣言リストというのは何なのでしょうか？
お願いします

>>46
どういう文脈で「引数宣言リスト」という単語が出てきたのかを書いた
方がいいと思うぞ。

>>45
日本語EUCとSJISだけでも対応しておくと
フィルタ系のツールなんかで便利だと思うよ。
ソースのフィルタとかさ。

…コード処理出来る人って少なそうだけど。

便乗なんですが
UTF-8 8 ビット Unicode 変換形式
ってなんですか？

俺もあんまり詳しく無いんだけど。

UCS4を1〜6byteに変換する形式だよ。

>>49
googleで検索してみそ
utf8はビット数固定じゃないから嫌いなり
日本語テキストなら UCS2 で十分なんだよね
ごくごく一部の限られた人を除いてだけど

ネットワーク関連でフリーのクラスライブラリとかってあるんでしょうか？
もし何かあれば教えて下さい。

書き忘れました。
環境はLinuxもしくは*BSD*で使えるものを探しています。

>>52
SourceForge を見てみたら？

ちなみにここのエキスパートの人はネットワークの機能を実装するときは、
そういったライブラリ使わないんでしょうか？
Windows以外の場合の話ですが。。

networkでなにをするか、によるのでは。
簡単なことならsocket直で叩くだろうし。
……v6対応があるから、そうでもないかな？

socket直ですか、、、分かりました。
正直、ネットワーク関連のプログラムは初めてなので、
コネクションのプーリング機能なんかを実装したクラスとかが
あればいいなって思ってました。
勉強がてら自分で実装するのがよさそうですね。

コネクションのプーリング機能なんかを実装したクラス
TCPは無理だよね？

プーリングって何？pooling?
具体的に何の為に必要なの？

オブジェクトを何回も生成しないようにじゃない
Ｃだったら何度もmallocしないようにって事かな？

コネクションをプールするってのは・・・
クライアント側の発想かな
サーバーに対してサービスを要求するのに
わざわざコネクションをはりなおさないって感じかな？
実用的じゃないね

connectしたソケットをcloseしないでずーっと持っておくの？
だけどTCPって放置したら勝手に切断するんじゃなかったっけ？

>だけどTCPって放置したら勝手に切断するんじゃなかったっけ？
そりゃないっしょ
そうだったら不便だな・・・

>>62
プロトコルによるんじゃない？

近くにあるネットワークスレに聞いた方がいいかな？わらい

>>64
そうだね。
俺の知ってる範囲だと、大抵は自動的に切断する。
つーか、切断される。

>>63
するよー。
RFC読むのはきついから、setsockoptのkeepalive辺りを読んでちょ。
UNIXの仕様じゃなくて、TCPの仕様だよん。

Solaris辺りはndd(1M)で変更可能。
*BSDやLinuxはシリアスな用途に使ってないから知らん。

>>61
HTTP1.1

プロトコルじゃなくて
サーバーによる、だと思う
けど､サーバーによって切ったり切られなかったりって
当たり前すぎる話に帰結してしまう

>>69
> プロトコルじゃなくて

ってなんだ？TCPやHTTP 1.1の仕様読んだ事あるか？

ないです
HTTP1.1では、
応答が何秒以上なければ、
コネクションを切る事
なんて書いてあるんでしょうか？

TCPの仕様なら納得できますが、
書いてあるならどこに書いてあるのか教えていただけませんか？

>>71
8.1 Persistent Connections
19.7.1 Compatibility with HTTP/1.0 Persistent Connections
詳しい内容はRFC2068を読んでね。翻訳もあると思うし。

>>58
ACEのACE_Cached_Connect_Strategyでも参考にして自分で作ったら？
http://www.cs.wustl.edu/~schmidt/ACE.html
ちょと仕様過剰かも知れないので

プリプロセッサの文字列置換に関して質問があります。

#define LIST_TEMP(type)　　　　　　　　　　 \
　##type *insert_back(){　　　　　　　　　　　 \
　　##type *elm = new (##type) [1];　　　　\ (注*1)
　　…　　　　　　　　　　　　　　　　　　　　　　　\
　}　　　　　　　　　　　　　　　　　　　　　　　　　\
　void *copy(const ##type &src){　　　　　 \ (注*2)
　　if(this!=&src){　　　　　　　　　　　　　　　　\
　　　…　　　　　　　　　　　　　　　　　　　　　　\
　　}　　　　　　　　　　　　　　　　　　　　　　　　\
　}　　　　　　　　　　　　　　　　　　　　　　　　　\
↑のようなマクロ（リストのテンプレート）を作って、

class _my_list{
　LIST_TEMP(int);
　…
};
みたいに使おうと思っています。
ここで困ってるのが(注*2)のところです。
例えば(注*1)のところのnewの後の##typeは
new (int) [1] と置換されるので問題ありません。
しかし(注*2)のところはconstintと置換されてしまいます。
もちろんconst (##type) &srcとしてもエラーになるので
困っています。何か良い方法はないでしょうか。

ど，どこでそんな書き方を憶えたのさ？(´Д`)
## を全部削ってみてちょ。

const##type
これは？（自信なし

すいません馬鹿でした↑

はうっ。
100回死にます…。

struct _xxx{
　int *elm0, *elm1;
} xxx;

#define elm(a,b) (*(a->elm##b))

hoge = elm(xxx,0);

ずっと↑みたいな使い方をしていたので前後不覚になりました。

78に書いたのは間違ってるけど雰囲気だけ…。
お礼を忘れてました。74さんありがとう。

私が関心したのは \ が縦にきちんと揃ってるトコロ。
練習したですか？

>>73
何故templateを使わん？

>>74
はい。メモ帳で練習しました。(カット＆ペースト)

>>81
とても大切な理由があった気がするのですが
思い出せません…。

>>82
では、さっそくtemplateに書き換えるのだ。

function objectってなんですか？

動名詞のことですか？

>>84
C++だとI/O manipulatorみたいなやつのことだろ？
どんな文脈で出てきたの？

あ、I/O manipulatorは、streamを引数にとってstreamを返す関数なのね。
extern ostream& endl(ostream& outs);

>>86
そうじゃなくて <functional> にあるような、operator() を定義し
てあるクラスのことだと思うが。<algorithm> で定義してある汎用ア
ルゴリズムと組み合わせて使ったりする。

関数的オブジェクトに関する詳しい話は「プログラミング言語Ｃ＋＋」
に載ってるよ。

>8.1 Persistent Connections
>19.7.1 Compatibility with HTTP/1.0 Persistent Connections
これは関係ないじゃん（笑）
ＴＣＰコネクションはったまま
何もしなかったらって話じゃないの？

>>89
とりあえず、8.1.4 Practical Considerations読んでくれ。
いきなりは切らんがserver/clientどちら側からも切断する可能性があり、

Clients and servers SHOULD both constantly watch for the other side of
the transport close, and respond to it as appropriate.

とある。他にもいろいろ書いてある。

そもそも規約になくても、相手がいきなり切断して、
それが分からないようなclass libraryなんて使いたいのか？

int main()
{
return 0;
}

これはアリですか？

>>91
質問の意図がよくわからんぞぃ。

蟻です。

>>83
いまtemplateに書き直して思い出した。
例えば↓みたいなテンプレートにすると

*************************************
template<class type>
class _list{
　_list<type> *next, *prev;
　…
　type elm;
};

class _elm{
　int var;
}

_list<_elm> xxx;
*************************************

リストxxxの要素にアクセスするときにxxx.elm.varってしないといけない。
マクロで書いておくとxxx.varってできるから楽(だと当初思った)。
OpenGLの描画プログラムを書いてるんだけど、
いま両方のフレームレートを測ってみたら0.2%ほどマクロの方が速かった…。
おとなしくテンプレートの方にしておきます。

>>94
なんでSTLのlistを使わない？
下手な車輪を再発明するなよ。

>>95
勉強中なら別にいいんでないの？

仕事で同じことをやるのは痛いけどね

一番最初にSTLのリストを使って書いたんです。
でイテレータの使い勝手が(慣れてなかったので)悪いなぁと思いながら
じゃあ自分で作ってみようとすったもんだしているうちに、
やっぱりSTLのリストはよくできてるなぁと思うようになった昨今。
もう一度書き直すことになりそうです。

超初心者なのですが、ルート計算を行う関数はどのように定義したらいいのでしょうか。

>>98
あっ、わかりました。スマソ

std::listを使ってまた書き直した挙句、なぜ自前で実装しようとしたのか
本当の理由をようやく思い出した。（すごい回り道だ…）
長くなるけど、時間があったら何か指摘してもらえればうれしいっす。

例えば

−□−□−□−□−□−□−□−□−
↑　　　　　　↑
リンク　　　　ノード
(エッジ)

という構造を作りたいとき(ノードが持つリンクは2つとは限らない)、

// ノード
class _node{
　list<_link> link; // 隣接ノードへのリンク
}
list<_node> node;

// ノードが持つリンク(要素は相手ノードへのポインタ)
class _link{
　_node *node; // 相手ノードへのポインタ
　_edge *edge; // リンクの別体へのポインタ(*ここが重要)
}

// リンクの別体
class _edge{
　_node *node0; // 端点0のノードへのポインタ
　_node *node1; // 端点1のノードへのポインタ
}
list<_edge> edge;

このとき、ノードn0とn1の間にリンクがあるかないかは

list<_link>::itr edge_detect(list<_node>::itr n0, list<_node>::itr n1)

みたいな関数で判断するんだけど
(つまり戻り値がn0からn1へのリンクのlistのイテレータになっている)
こうすることで

(*n0).link.erase(edge_detect(n0, n1));

みたいに消去できる。ここまではよし。

しかし今同時にリンクの別体list<_edge>も更新したい。
リンクの別体というのは全リンクのlistで、
これがないといちいち各ノードに対してリンクをサーチしないといけないから
2重にカウントされて遅い＆不便。すると当然、

edge.erase((*edge_detect(n0, n1)).edge);

としたくなるけどこれは不可。なぜなら上の引数はlist<_edge>の
要素本体へのアドレスであり、list<_edge>のイテレータではないから。
つまり消したいedgeの要素本体のアドレスは知っているのに、
それをイテレータに直さないといけない点がとても非効率的だと思ったんです。
自前で実装すれば要素の操作はイテレータではなくてリストの上部構造(?)も
含めたアドレスで行えるから、ここで望むような操作が可能だなと。
いじょ。

>>100
途中から読み出したのでアレだけど、
そもそも、ノードの論理的な構造をそのままデータ構造にしようと
しているところに、 list<_edge> edge の必要性を生み出している
原因があるような気がするんだが...。

要は、 list<_edge> edge をどうするか…でしょ?
漏れなら、単に _node の可変長配列を(テンプレート)クラスにして、
ノード間のつながりは隣接点行列を作るなりして仮想化させると思うな。


目に見えるものすべてを「実体」として実装しようとするから、
話がややこしくなるのでは?

list< list<OneType> > hoge;
のようにするのは駄目なの？

うぅ。ありがとう(泣)。

>>101
>漏れなら、単に _node の可変長配列を(テンプレート)クラスにして、
>ノード間のつながりは隣接点行列を作るなりして仮想化させると思うな。

当初は

// ノード
class _node{
　list<_node*> link; // 隣接ノードへのリンク
};

のように実装していました。これが>>101で言わんとすることかな。
(というのを前提に話を進めると)
そうすると、例えばリンクを描画するときにn0→n1とn1→n0という
同じリンクを2重に描画することになっちゃうのがイヤンだったのです。
もちろん描画済みか否かの条件文を入れればいいんだけど、
要素の数が増えてくると計算速度に結構効いてくるので
リンクの別体(実体)を考えて重複をなくそうとしたのです。
答になってるかな…。

>>102
駄目な気がする。理由は…ぅぅ頭が割れそうだ…。

class obj {
public:
virtual draw();
};

class link : public objs {
node *pnode[2];
public
draw();
};

class node : public obj {
list<link*> linklist;
public
draw();
};

list<obj*> objects;

こういうこと？

>>103
あぁ、なるほど、リンクを描画したいわけね。それも効率よく。

計算するのが何なのかわからずに書いてしまうけど、
ノードを可変長配列として実現しておいて、
あらかじめ隣接点行列 bool isConnected[length][length] を
準備しておくと、

for (i=0;i<length-1;++i){
　for (j=i+1;j<length;++j) {
　　if (isConnected[i][j]) {
　　　(計算とか);
　　　(描画とか);
　　}
　}
}

で、できるような気がするんだけど。

>>104
この場合、ノードがリンク先をサーチしようとするときに、
『リンクの両端を見た上で自分じゃない方が相手』、
という余計な判断が入るから少しうれしくないです。

>>105
いま書いてるのは1000個以上のノードがバネ(=リンク：1000〜2000本)
で繋がれてグリングリン動くプログラムなんだけど、
隣接点行列でやると数十倍遅くなってしまうです…。
いまのところはノード数10000、リンク数10000(リング状)の
ばねアニメーションがFPS30ちょいで動いてます。

>>106
> 隣接点行列でやると数十倍遅くなってしまうです…。
ふぅ〜ん、そういうもんかなぁ..。

力になれなかったな。スマソ。

>106
いや、もうちょっとコード見てくれよ..
s/objs/obj/g

>>108
あ、objsとobjがある…。
ごめん。まだよく理解できないから少し考えてみる。

それと補足だけど、各ノードはどんどん繋ぎ変えてリンクの状態が変わるから、
特定のノードが持つリンクの相手をできるだけ高速にサーチしたいです。
この繋ぎ変えの処理に関しては>>101にあった方法が一番速いんだけど、
同時に高速に描画も行おうとするとまたトレードオフが出てくるです。

ちなみに今リンクの本数をL、ノード数Nとすると、
存在し得る最大リンク数N(N-1)/2に比べてLが圧倒的に小さい条件(L∝N)で
やってるです。隣接点行列で判断すると計算時間はL∝N^2になるので
おいらがやってる条件に限って言えばキツイということです。

初めてなのですが、質問させてください。

domain_errorって何なんでしょうか？
どんな関数が投げるものなんでしょうか？

>>73
よくわからんけど、参照カウンタ付きのProxyをCompositeパターンで
リンクすればいいのではないの？
俺が勘違いしているかも知れんけど、それはともかくとしても、
73の設計にはオブジェクト指向の香りがしないよ。
デザインパターンの本をよく読むことをおすすめする。

>>73
重複しない走査を実現するための特別な構造が
必要で、リストでは駄目ということなのでは。
自分で「サーチ」と言っているし。

>>111
これってexceptionでlogic_errorなdomain_errorのこと？

>>114
そうです。

Ｃ＋＋の反復子ってなんですか？

走査子

ほぇ

>>115
logic_error自体は、引数チェックみたいな｢runtimeじゃない｣
例外のための基底クラス。

ある関数を呼び出すとする。
runtimeじゃないっていうのは、プログラミングをしている
時点で例外が起こらないように、関数の呼び出し側で
コントロールできるってこと。

runtimeエラーの代表的なものにout_of_memoryがあるわけだが、
ある関数を呼び出すのに、out_of_memoryにならないように、
っていうのは｢プログラミングの時点では｣コントロールできない。
だからruntime。で、logic_errorはそうじゃないやつ。

domain_errorってのは、length_errorとかout_of_range_error
とか、invalid_argumentではない、ソフトウェアの｢対象ドメイン
特有の事前条件｣に違反した場合に投げるべき例外。

基底クラスとして用意されているだけで、標準ライブラリの
中を捜しても多分使ってるところはないのだと思う。

下手な説明でスマソがわかる？

繰返子

>>119レスどうもです。

ええと、、実はexceptionなやつのほとんどが
いまいちよくわかっていないのですが…。
logic_errorはちゃんとやってれば防げるはずのエラー？
runtime_errorは、メモリ不足とか、ファイルが無かった、
などの時に投げるのでしょうか。。

domain_errorはlength_errorとかに当てはまらない
logic_errorのときに投げることになるのでしょうか？
あと、基底クラスとして用意されているだけということは、
domain_errorはそのまま投げないで、domain_errorを
継承したクラスを投げたほうが良いのでしょうか？

それから、range_errorとout_of_rangeの
違いがいまいち分かりませんです…。
logicかruntimeかの違いでしょうか…？

回答がﾃｷﾄｰだったことを謝罪する。ｽﾏｿ(鬱。

漏れの解釈では、out_of_rangeは添え字の範囲外エラーの類、
range_errorは、オーバフロー、アンダーフローの類だと思っていた。
(10まで入れていい数字で11というような値そのもののエラー)

考えて見れば根拠を示せない(鬱

> domain_errorはそのまま投げないで、domain_errorを
> 継承したクラスを投げたほうが良いのでしょうか？

標準例外自体、全てがexceptionから派生している、
というわけではないから、標準ライブラリのユーザーに
Javaのようなやり方を推奨しているわけではないと
考えている。

domain_error自体、インスタンスを作ることが認められていない
わけではないからそこをどうするかは、個々のプログラムでの
設計上の判断次第だと思う。
継承することによって、設計上の利点があるならば、、だ。

漏れはポリモーフィックに扱う必要がない場合は、極力継承は
使いたくないが。

ド初心者ですが、教えてください。
Ｃ＋＋を学習してるのですが、
コードを書いてみようとＶＣ＋＋を使ってやってみたのですが、
BOOLとかstringとかが使えません。
こういったものを使えるようにするには何をインクルードする
必要があるのでしょうか？iostream.hじゃだめなんですかね。
string.hをインクルードしても標準ライブラリのstringが使え
ないし・・。

>>123
#include<windows.h>
#include<iostream>
#include<string>
namespace using std;

>>124
レスどうもです。いまからやってみます。
ところでwindows.hは何のためですか？

だめでした^^;。
iostreamやstringは確かに本とかでは.hついてないのですが、
つけないと開けないというエラーがでます。で、付けてコンパイル
すると

構文エラーusing
string 定義されてない識別子です

などが出ます。ちなみにこんな感じで書きました。

#include <iostream.h>
#include <string.h>
#include <windows.h>
namespace using std;

void main()
{
string a;
}

なんででしょう。

std::string a;

using namespace std;
じゃないのか？

ちなみにBOOL型はWindows固有の型。
C++汎用のはbool。

BOOLのためだけにwindows.h入れるのかい
C++なら標準はBOOLでなくてbool

だぶった遅かった（´д｀；）

おれのマソコマークがいっぱい書き込まれた「独習C++」を
あげるから、基本からやり直すこと！！＞１

１じゃなくて１２３だった。。。鬱だ

using namespace std;
にしてみると、
'std':存在しないか名前空間ではありません。
と出ました。
なんでやねん・・・。
標準のＣ＋＋やりたいだけなのに・・・。
boolすら使えません。

そういえばcoutとかsinもstdですよね。
それらはstdとか使わなくても使えるンですが・・・。
iostream.hを取りこむだけで。

#include <iostream>
#include <string>

using namespace std;

int main()
{
string a;
return0;
}

まずは一通り、「最近発売された」 C++ の参考書を読むことをおすすめする。
90 年代後半に大きく C++ の規格が変わってるから。

#include <string>
#include <iostream>
using namespace std;
int main(){
  string s = "Hello, World!\n";
  cout << s << endl;
  return 0;
}
たったこれだけ貼り付けても動かんか？BCCではOK。VCは知らん

ｶﾌﾞｯﾀ...鬱氏

あ、もしかして・・・。
私が使ってるＶＣ＋＋がおもいっきり古いからでしょうかね・・・。
４．０です（藁。
実際、コードを書いてくださった方のをそのまま貼り付けても
だめでした。なにせ#include<string>の時点でダメなんです
から（藁。.hを付けないとダメなのでおかしいとは思っていま
したが。今のＶＣ＋＋の最新は７ぐらいっすかね。買ってこないと。

SDKでいいよ。そのレベルなら。
もうちょっとレベルアップしてからの方がありがたみがわかる

cygwinで十分だろ。
nestしたtemplateとか書けないけどな、gccはまだ。

C++で初めてゲームつくってて、カメラのクラス作ってんだけど、
そこには視点とか、カメラ位置とかそういうメンバがあって、
でカメラの変換行列とかをGetするメソッドがあってって感じなんだけど、

それで、あるスコープでインスタンス作って、位置とか設定してカメラの行列
ゲットして３次元計算して、ってやるのはいいんだけど、
その他のスコープにいったら、またインスタンス作って位置とか視点とか
設定しなおしになるよね。

こういうときはグローバルにインスタンス作ればいいの？
でもなんかそれきもちわるい。

というかそもそも設計がおかしいの？

誰か教えてください。

boolのサポートはVC5あたりからだと思う（´д｀；）
VCがいいならMSから.Net framework SDK落とすか
gccでも使うかBCCにするか好きなのにすれ、全部ただだ

>>141
そういう用途なら位置と視点は別クラスじゃないの？

>>143

カメラ位置って３次元ベクトルです。
視点（フォーカス）も同様に３次元ベクトルです。
それをクラスにするのでしょうか。
どういうことでしょう。
私がよくわかってないのかもしれません。

別クラスにしたとして、グローバルに持っとけばいいのですか？
というか、そこが一番ききたいところなのです。

他のスコープでも扱うものをどうしたら良いのかというところが。

初歩的な質問なんですが、
イニシャライザに可変個引数を渡すのってどうやるんでしょうか？
B::B(char *format, ...) : A(format, ...) {}
こんな感じでやってみたんですがやっぱりだめでした・・・。

>>145
可変個引数を使ってどうしたいかの方に興味がｱﾘﾏｽ。

VC++を始めようと思うのですが、C/C++共に初心者です。
Cをある程度理解してからC++に入ったほうがやりやすいでしょうか。
それとも、余計なこと考えずにC++入ったほうがすんなりいくものでしょうか。

個人的見解で充分ですので、ご鞭撻を。

>147
手段なんかどうでもいいから、
何か作れ
作りたいものがなにも無いってんなら、
やめろ

>>147
C を理解することはコンピュータの原理を理解することに限りなく近いです。
どちらかというと C++ はその原理を覆い隠すようなとても「便利」な
仕組みがいっぱいあります。しかしながら C++ は便利すぎて、
その「仕組み」を 100% 使うには膨大な勉強と経験が必要です。

したがってお勧めとしては、まず C でコンピュータの仕組みを理解し、
その後で Java で C++ の基礎となる概念を学び、
そして C++ もしくは C# を学習するのが良いと思います。

とは言え何よりも大事なことは、>>148 さんも言ってるように、
作りたいことは何か？　ということです。
作りたいものがあり、それを作るのに適した言語を選べるくらいになれば、
とても幸せなプログラマ生活が待ってるでしょう。
「作りたいものは何か」、これを大事にしてくださいね。

Cの勉強つったって、たいがいはいきなりそこで挫折する（ｗ

最初にJavaを学ぶと、Java厨になってしまい、
決してC++やCなどに戻ることはできない。
C#は似てるから、強制力があれば可能かもしれない。

ＣとＣ＋＋でいいじゃない。

>>139
SDKって何の奴ですか？

>>123
コンパイラのエラーにヘルプがついてるのを知ってるか？
当然十分な情報がるわけではないが、チェックすべきだぞ。
アウトプットウィンドウのメッセージだけ見たところで止まってないか？
CXXXX:の番号のところを選択してＦ1キー押すか、ヘルプのキーワードに
番号いれてみ。

＞作りたいもの
今のところ、最終的にはVC++で自分向きの
ファイラーを作りたいと思っています。
けど、どうせやるのなら基礎からの方がいいかなと思って。
過去にも何度かやろうかと思ったことはあったのですが、
今回は腹をくくってますのでやる気だけはあります。
# もっとも、できるかどうか自信はないですが(汗

出来ればエディタも作ってみたいと思っていますが、
既存のフリーソフトとかのレベルまで追いつけるかどうか(汗
# 学習の一つとしては作ってみるかもしれませんが。

>>149
なるほど。なんとなくCやってから方がいい気はしてました。

皆さんの言う通り、以前にJAVAに手を出そうとして
やりたいことが無いのに気付いて、結局何もしなかったのと、
過去ログ(このスレに限らず)を見て目標は大事だと思いました。

>>151
危なかったッス（ｗ

ありがとうございます。

>>149
＞C を理解することはコンピュータの原理を理解することに限りなく近いです。

それ言い過ぎと違う？
C学んだら、コンピュータの原理なんて理解できるかなあ。
せいぜいメモリ、CPUの割り込みとかぐらい？
それとも俺がバカ？

一直線のメモリがイメージできるって意味だろ。
プロセスごとの境界はあるにしてもね。
VBとかスクリプトじゃ永遠にそういう考えには
いたらないな。

じゃあメモリの原理（？）がわかるってことじゃん。
コンピュータじゃなくて。

>>119ありがとうございました。。

>>141

私は、グローバルにインスタンス作ってやっています。
確かになんかいやですね。
私も初心者なのでよくわかっていませんが。

私も知りたいです。どなたか教えてください。

>>156
>>149は哀れな勘違いだろ。
ALU内部で乗算・除算処理がどう行われているかを理解するのと
Cとかの高級言語を理解するのは全く別だからな。
そもそも149はCMOSの仕組みについて分かっているのか？
オーバークロックとかのたまって、規定よりも高い電圧をCPUにかけている
ドキュソじゃないだろうな(w

自作のヘッダーファイルで作ったクラスを
グローバルで確保するにはどうしたら良いんですか？

#include"zisaku.h"

someclass *pt;
pt = new someclass;

グローバルで宣言するとエラーが出てしまいます。
他のクラスや関数内ではエラーがでません。
どうしてグローバルだとエラーが出てしまうのでしょうか？

>>141, >>160
今の設計でも、その[位置]とか[視点]とかの情報はローカルスコープ外に
持たせてるんでそ？それと同じところで[カメラ]も管理すればいいんでないの？
どんなゲームやらわからんのでなんとも言えないけど、キャラクタ毎に持つなり
シーン毎に持つなりレンダリング用のクラスが持つなり。

>>162
グローバルスコープには制御構文を書けない。

>>164
ありがとうございます
pt = new someclassが駄目だったんですね
基本的な質問で申し訳ありませんでした

>>154
そういうやり方があったんですねぇ・・・なるほど。
でも、今回の原因は私のＶＣ＋＋が古いためであると思われます。
仕様がけっこう変わったんですね・・・。
新しいコンパイラ買わないと。
でも金かかるんでしょうね、はぁ。

>>166
VC++5.0でエラーでてるソースがVC++6.0で通ったり(vv
｢それでいいのか、おい？｣って。

>166

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

int main(){
　string s = "Hello, World!\n";
　cout << s << endl;
　return 0;
}

>>163
もしかして、カメラだけ特別扱い？
Worldを頂点とする、オブジェクトツリーの中の、
１つのオブジェクトとして定義するのが普通では？

逆行列さえ求められれば、どんなオブジェクトもカメラになりえるし。

>>163
アー、参考になります。
確かにレンダリング用のクラスでカメラクラスのインスタンス持っとけばいいな。

位置とか視点とかはカメラクラスのメンバです。

どんなゲームでどうこう、というよりも、
一般的な座標変換のことです。


>>169


あー、それも参考になるなあ。
カメラクラスって言うのが不自然なのかなあ。

>>168 +これも。
----
#include <string>
#include <iostream>

int main(){
　using namespace std;
　string s = "Hello, World!";
　cout << s << endl;
　return 0;
}
----
#include <string>
#include <iostream>

int main(){
　std::string s = "Hello, World!";
　std::cout << s << std::endl;
　return 0;
}

余談だが、<iosfwd>も知れ。

>>171
本題とずれるが operator=() 呼び出すより、コンストラクタに引数
渡したほうが良くないか？

string s = "Hello, World!";
string s("Hello, World!");

>>168
>>171
コンパイルしましたが、全滅です^^;。
上にも書きましたが
#include<iostream>
#include<string>
はだめで、.hを付けないとファイルをオープンできません。

それとstring.hをとりこんでもstring宣言すると、stringは定義
されてない識別子というエラーになります。
using namespace std;
とすると、stdは存在しないか名前空間ではないとエラーがでます。
これはコンパイラが古いせいで、解決法は無いと思われます。

しつもぉ〜ん
VC4.0って、STL付いてるの？
iostreamだけじゃないの？

http://www.stlport.com/
4.0に対応してるかはしらないけど、
ここで落すべし。

string.hは、cのヘッダだろ（藁

ということはＣ＋＋のstringは無いってこってすか？？

>>172
この場合はoperator=呼ばれないんじゃないの？
代入じゃなくて初期化として扱われると思ってたけど。。

>>173 >>174 >>175
入ってないものは仕方ないな。VC++のヘッダディレクトリ見て、
存在してなかったらコンパイラがどうとかいう必要ないな。
stlportは、本家よりいいという噂もあるしな。
漏れは、Plaugerのソースが性に合ってるが。

質問なんですけど、

char a = 'a';
cout << int(a); //文字じゃなくて数値を表示

このint(?)は何ですか？マクロかなんかですか？
それとこの場合、(int)aのようにキャストしても大丈夫みたいですが、
int(a)と(int)aの違いは何ですか？

>>178
int(a)はC++固有のキャスト構文
(int)aでも問題ないけど。
詳しくは参考書読み返して

typename(expression)は、プリミティブな型に使う明示的型変換構文。
マクロっていうよりは演算子。

Cでは使えなかったかも、ってのとポインタへ型への変換
には使えない、ってのが違うはず。効果は同じだと思うが。
static_cast<int>(a)とかの方が好きだが。

かぶった(鬱

>>172
177 が正解。

>>177 >>182
そうなのか。勉強になったよ。

>>179
>>180
そうですか。ありがとうございます。
しかし、違いがポインタ型への型変換ができないということだけなら、
最初からキャストがあるわけなので、意味が無いように思える
のですがね。なんでＣ＋＋でこんなの作ったんでしょうかね。
まあいいけど。

>>184
あれってコンストラクタの構文と同じだよね。
C++(の作者)的には、コンストラクタとキャストを同一視したかったのだと思う。
ある型の値を与えられて「それと同等だけど別の型の」ものを生成するってのは
コンストラクタ(の使われカタの一部)とキャストとは似てるので。

で、そうしたまではいいが、hogehoge*みたいなメタ型に構文的に適用不可能という辺りが、間抜けだ。
ポインタ型への変換に使えないんじゃなくて、「1単語で表現できない型」に使えないんじゃなかったっけ？
だからたとえば、ポインタだってtypedefしとけば、その別名でtype()なキャストがやれる。

すげーどうでもいいが、Pascal/Delphiはこの構文だ。
Pascalはhoge*みたいな1語で表現できない型を使うのを許してない
(ほぼ常にtypedef相当を書かないとならない：だから面倒(藁))
ので、これで問題ないわけね。

>>180
typedefしてればポインタ型もOK。*が構文中に使えないだけ。
typedef int* pint;
pint pi = pint(&i);

メモリ最適化ツールって、どうやってるの。
例えば１９２MBのメモリがあったら１９２MB全部確保しちゃうの？
でもそれ、できなくない？

またDel厨が・・・

そんなにいわないでよ

static_cast<>
dynamic_cast<>
reinterpret_cast<>
const_cast<>
あとなんかあったっけ？

誰か、これらの違いをわかりやすく説明してよ。
それぞれどういう場面で使うのかも。

サーチエンジンで検索すればいいのに・・・

あ、そ。
つまんないネタで悪かった。

>>190
このうち使い分けが微妙なのは static_cast<> と reinterpret_cast<>
だと思うけど、MSDN のコラムが詳しく説明してる。

http://www.microsoft.com/japan/developer/library/dsmsdn/deep05182000.htm
http://www.microsoft.com/japan/developer/library/dsmsdn/deep06012000.htm

・dynamic_cast<>
Javaのキャストと同じ

・const_cast<>
const指定を除去する。型変換はできない。

・static_cast<>
dynamic_cast<>の逆をする。

・reinterpret_cast<>
Cのキャストと同じ。危険物。

あってる？

>>193
ありがとう。そこ面白かった。
static_cast<T> では operator T() が呼ばれることがあるけど、
reinterpret_cast<T> では常にビットパターンそのまま
ていうのが決定的な違いなのかにゃ？

>>194
君も 193 のリンク先を呼んだ方がいいぞ(藁

ｻﾝｸｽｺ ｵﾓｼﾛｶﾀｰﾖ > 各位
ついでだから漏れも質問。

struct HogeImpl; // class HogeImpl
struct Hoge{
　HogeImpl* _pimpl;
};

ってやった場合、先行宣言でstruct/classにしてしまった場合、
HogeImplにテンプレートインスタンスな構造体/クラスを使えない
ようなのだが、これって回避可能？
コンパイラはVC++5.0/6.0あたりなんだけど。

やりたいことは、DLLの外側にテンプレートインスタンスな
クラス/構造体を出したくないから、何かかぶせよう、って
ことなのだけど、これはC++スレ本来からは外れる気がするので
とりあえず、最初の疑問のみ回答ｷﾎﾞﾝﾇ。

>>196
宣言の仕方が悪いだけのような気もするが...。

列挙型の値の範囲ってありますよね？
あれって何の意味があるんでしょうか。
例えば

enum e{ a=1, b=3, c=5, d=9};

の場合、上限は１５で下限は０ですよね？
この上下限て何かに役に立つのですか？

それと、列挙値に負数が含まれる場合の下限値の計算方法を
教えてください。

なんで？
列挙型ってintでしょ

>>196
HogeImpl には純粋仮想関数だけ持たせておいて、

template <typename T>
class Foo : public HogeImpl
{
};

で、良いんじゃない？

>198-199
が何言ってるのか分からないのは俺だけか

>>200
ｻﾝｸｽ。いや、実際今のところそんな感じにはなってるんだ。
結局typedefとかではダメで、サブクラス化が必要なのかぁ、、
素直に通らないのにはなんか理由があるのかなぁ、
というより漏れがやろうとしていることの方が素直じゃないんだね。。

structテンプレートの変数が全部解決されたら、それは
もうstructだろう、と漏れはいいたいのだが。
なんかできそうな気がするんだけど。

>>197 正しい宣言のしかたｷﾎﾞﾝ。

>>198
設計上ビットサイズが意味をもつ場合には、なんか使い途
があるのかもね。でもenumの使い方としてはやや本筋を
外れるかもしれない。

少し長いがプログラミング言語C++ 第3版 日本語訳から、、
--
列挙子は、整数データ型の定数式により初期設定できる。

列挙の上限は、列挙に含まれるすえての列挙子の値よりも
大きい2の累乗値マイナス1の中で最も小さい場合である。

列挙の下限は、列挙子の最小値が負数でない場合には0、
列挙子の最小値が負数の場合には、それより小さい
2の累乗値プラス1の中で最も大きい値である。

これは、列挙の値を保持できる最小のビットフィールド
のサイズである。

>>203
ビットサイズはenumの設定値によって違うということですかね・・・。

それと
＞列挙子の最小値が負数の場合には、それより小さい
＞2の累乗値プラス1の中で最も大きい値である。
の部分ですが、私はアホなのでよくわからんのですが、
例えば最小値が−１０だったらどういう計算になるのでしょう？
最大値の方はわかるのですが・・・。

このプログラムがなぜエラーになるのかわからないです。
o[i].hoge()だとコンパイル通るんですが。

#include <iostream>
using namespace std;

class A
{
public:
　　　　void hoge(){ cout << "hello\n"; }
};

int main()
{
　　　　A* o;

　　　　o = new A [3];

　　　　for( int i = 0;i < 3; i++ ) o[i]->hoge();

　　　　delete [] o;

　　　　return 0;
}

>>205
o[i]が、A&なんじゃないの？

o = new A;だと
o->hoge();でいけるんですが。

配列だと参照になっちゃうんｄすか？

>>207
operator[]使った時点でderefされてるのが普通だと思えるよ。
たしかにoperator new[]はvoid*返すんだけど。

int* a; でa[i]ならポインタでなくてint値が返るだろ？
o->hogeの配列版は(o+i)->hoge()じゃない?

>>205
o は A の配列 (配列の名前)
o[i] は A 型のオブジェクト
だからメソッドを呼ぶときは o[i].hoge() でいい。


A * o = new A; だと
o は A 型のオブジェクトへのポインタ
だから o->hoge() でメソッドを呼ぶ

なるほど。どうもです。なんかややこしいな。

超初心者の質問です。
Cでmallocとかでメモリを確保した後、きちんとfreeしてあげないとだめなんですか？
すごくめんどくさくて別に問題ないのならやりたくないんだけど。
ちなみにOSはLinuxです。
教えてください。

>>211
C++ じゃなくて C の話題のような気がするが…ともかく。

free() すると、free() したメモリが malloc(), realloc() で再利用可能になる。
もし何度も malloc() を行うプログラムなら free() しておくと使用メモリ量を
抑えられる。

サーバプロセスのように 24 時間実行されたり、エディタのようにいつまで実行
すればいいのか分からんアプリケーションで何度も malloc() する場合には
free() 必須。さもないとメモリを食いつぶしてしまう。

短期間だけ実行してすぐに終了してしまうプロセスや、malloc() で確保する
メモリ量が限られている場合には free() せずに終了して構わない。free()
していないメモリ領域も含めて、プロセスが使っていたメモリは OS がまとめ
て回収するから。

関連スレッド
始まった！malloc and free - fj.comp.lang.c
http://mentai.2ch.net/test/read.cgi?bbs=prog&key=981051921

あと free() するのが面倒だと感じるなら、ガベージコレクタを使っても良いよ。
プログラム中から参照されていないメモリ領域を勝手に free() してくれる。

BoehmGC
http://reality.sgi.com/boehm/gc.html

>>211
>>212の手段の他に、処理系依存だけどallocaってのがある。
(処理系依存といってもほとんどの処理系に存在する)
これはスタック領域を使うんで、開放は必要無い。
でも呼び出せる場所に制限があるかも知れない。
システムに要求を出すわけではないから、
mallocより多少効率が良いかも知れない。
関数を抜けると開放されるので、永続的な用途には向かない。

>211
>>210はネタのような気がするが

ずれた
>>211-212

> >>210はネタのような気がするが

VB野郎なんじゃないの?

211です。
C++のスレッドと知らず書き込んでしまいました。
すみません。

212,213さんありがとうございます。
free()の意味がわかりました。
さんきゅーです。

ちなみにこれはネタじゃないんです。
本当に超初心者なだけです。

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

int main()
{
int i, s, sign[10];
long n, x;

for (i = 1; i <= 9; i++) sign[i] = -1;
do {
x = n = 0; s = 1;
for (i = 1; i <= 9; i++)
if (sign[i] == 0) n = 10 * n + i;
else {
x += s * n; s = sign[i]; n = i;
}
x += s * n;
if (x == 100) {
for (i = 1; i <= 9; i++) {
if (sign[i] == 1) printf(" + ");
else if (sign[i] == -1) printf(" - ");
printf("%d", i);
}
printf(" = 100\n");
}
i = 9; s = sign[i] + 1;
while (s > 1) {
sign[i] = -1; i--; s = sign[i] + 1;
}
sign[i] = s;
} while (sign[1] < 1);
return EXIT_SUCCESS;
}
-1+2-3+4+5+6+78+9=100を表示させないようにするにはどうしたらよいですか
おしえてください。お願いします。

初心者ですが質問させて下さい。
整数を保存するリストに対し,
その順序を反転する関数を作成せよ。という問題なのですが、
これって各ノードを図であらわしたときの矢印の向きを変えろ,
と言っているようなものなのですか？
宜しくお願い致します、、、

それ以外の可能性ってあるの？
双方向リストなら、書く量が少なくていいね
単方向でも、ルート不要なら、再帰で書くと
少ない努力でできるかな

なんでも定番は同じだね

STLのlistだったりして…

STLのlistだと問題にならないじゃん。

>>222
自分で組むのは、STLで使えるようになってからでもいいじゃん。
問題出すほうがわかってないのかもよ。

protectedについて質問。
派生クラスから基底クラスへのprotectedだったら見えると思ったんだけど、
下のコード、コンパイラ通らないです。
基底クラスへの参照は無理なの？
教えてください。

class A
{
protected:
　　int xxx;
};

class B : public A
{
　　void func(A* ptr);
};

void B::func(A* ptr)
{
　　cout << ptr->xxx;
}

class A
{
protected:
int xxx;
};

class B : public A
{
public:
void func();
};

void B::func()
{
cout << xxx;
}

void main(void)
{
B b;

b.func();
}

こうじゃなくて？

namespace使用時、friend class宣言が無視されます。
何が悪いのでしょうか？

ファイルA
namespace a

class A{
friend class B;

int i

};

};

ファイルB
#include "ファイルA"

using namespace a;

class B : public A{

B(){
i = 1; // ←privateﾒﾝﾊﾞにｱｸｾｽ出来ないとエラー。
}

};

>>225
あ、クラスＡを継承してるクラスが他にもあったりするので、
基底クラスであるクラスＡに対して行いたいのです。

class B;
namespace a {
class A{
friend class ::B;
int i ;
}; };

>>228
それでうまくいきました。
でもnamespaceを使う前は、プロトタイプ宣言無しでもいけてました。
それに複数のファイル間で同じnamespace名を使うとエラーが出まくります。
疑問だらけなんで、もうちょっと勉強してみます。
ありごとうございました。

理解できました。
C++ってやっぱ難しい！

２１９の質問をしたものです。
長いので2chに書くのを控えたのですが、
http://members.tripod.co.jp/giriam2001/c.html
のプログラムを参考にして解けというものなのです。
全く糸口さえわからないのですが、、、、、

>>291

>>219

>>219
氏ね

>>219

>>224
のコードはBの基本クラス要素ptrを見てるんじゃなくて、新しい別のクラスAのptrを見ているよ。だから、*ptrには何も入っていないからcoutにNULLが渡されて、エラーがでてるんじゃない?

>>236
その答えは思いっきり外してるぞ。

あ、しまった。coutには参照が渡されなければ行けないのに、
NULLが渡されたからエラーがでる。。
てことでOKだよね

>>238
いや、そもそもコンパイルエラーが出るって話だろ…？
呼び出し側のコード見ないとなんとも言えないが func( NULL ) なんて呼び方してるとも思えんし。

つーか、解決 >>230 してるんだよね。(^^;

そうだったんだ。すまん。でも見ため224と226は同一人物ではないような気がして。。。

>>236
前半は合ってるけど後半が違う。
>新しい別のクラスAのptrを見ている
から他人の保護メンバ xxx にアクセスできんということだ。

>>231
リンク先のソースに付け加えるとしたらこんな感じか。
//要素の順序を逆にして新たな先頭ノード(旧末尾ノード)へのポインタを返す
Node *reverse(Node *n)
{
　Node *prev_node;
　Node *old_next;
　for (prev_node = NULL; n != NULL; prev_node = n, n = old_next) {
　　old_next = n->next;
　　n->next = prev_node;
　}
　return prev_node;
}

>>241
その通りでした。一番肝心なこと忘れてたYO。
まだまだっす勉強します。

．NetのVisual開発ツールってframeworkSDKのbinの何ていうアプリケーション？

あれ？protectedのメンバって例え派生クラスとはいえ
べつのオブジェクトのprotectedメンバにアクセスでき
るんだっけ？
protectedって単に継承したときに基底クラスのメンバ
をどのように扱えるかを決める物じゃないんすか？

＞２４５
ハァ？

>>245
正解。

>>245
>protectedって単に継承したときに基底クラスのメンバ
>をどのように扱えるかを決める物じゃないんすか？
意味不明。

つまり、生成された同一クラスのインスタンス間で
protectedなど、アクセス制限は適用されるか？ってことか。
おいらもよくわからん。
誰か調べて。

#include<stdio.h>

class pee{
protected:
int tinkasu;
public:
void peeing(pee p){tinkasu=p.tinkasu;}
};

int main(){
pee p1,p2;
p1.peeing(p2);
return 0;
}

こういうこと？

>>245が正解なので、>>224がコンパイル通らないのです。

>>245
そうなんですか。勉強になりました。
Javaのprotectedとは意味が違うんですね。
C++では同じクラス同士のみで参照したいメンバは
作れないんですか？

同じクラス同士、ならprivateでもprotectedでもいい、と、思、う。
派生がからむとややこしいけど…。

…自信なし。

>>252
いや、同一クラスならアクセスできます。派生クラスだとアウト。

class A
{
protected:
　　int xxx;
public:
　　void func(A* ptr)
　　{
　　　　std::cout << ptr->xxx << std::endl;
　　}
};

>>255
じゃあ、ダウンキャストしてからだとＯＫですか？

あれ??そうなると、224がコンパイルできないのは、Aのprotectedメンバを指しているからではないんですね。ではやっぱり236が正しいということ??

すいません、コメントに「。」をつけますか？

つまり、同一クラスのオブジェクトは一種の派生クラスと考えられるってことでいいですね??

>>258
よくわからん。

ん?
たとえば、
クラスAのオブジェクトとしてobj1とobj2があるとすると、
obj1のprotectedメンバにobj2からアクセスできるの?

>>260
できるよ。
Privateでも。

>>260
それはできる。

class Test
{
protected:
　int xxx;
};

void Test::func(Test* t1)
{
　this->xxx = t1->xxx;
}

じゃあ、基底クラス型オブジェクトのprotectedに派生クラスから
アクセスできないの？

>>256
>>224 の B は ｢Aの派生クラス｣ であって、A ではないよね。
だから A のインスタンスの protected メンバにはアクセスできない。
でも B の別のインスタンスの
(A から継承した) protected メンバにはアクセスできるから、
下のようにすればコンパイルは通る。

class A {
protected:
　int xxx;
};

class B : public A {
public:
　void func(B* ptr); // B へのポインタを受け取るようにする。
};

void B::func(B* ptr) {
　cout << ptr->xxx;
}

-----------------------------------------------------
<html><head><title>クラスのアクセス</title></head><body>
<table><tr><td>派生の仕方＼基本</td><td>Public</td><td>
Protected</td><td>Private</td></tr><tr><td>Public</td><td>
Public</td><td>Protected</td><td>参照不可</td></tr><tr>
<td>Protected</td><td>Protected</td><td>Protected</td><td>
参照不可</td></tr><tr><td>Private</td><td>Private</td><td>
Private</td><td>参照不可</td></tr></table><p>表の中にある
のは、派生した後の派生クラスから見たメンバの状態 </p>
</body></html>
-----------------------------------------------------
HTMLで保存して、見なさい。

(多分あってると思う・・・間違ってたら指摘して)

>>264
Ａを抽象クラスとして、Ａに対して処理することに意味がある場合は？
例えば、CompositパターンのCompositオブジェクトから
基底クラスのprotectedへアクセスしたい場合とか。

同じ派生クラス型の異なるインスタンス間においては、相手のインスタンス
のリファレンスやポインタを受け取ることによって、相手のすべてのメンバ
（派生クラスのメンバ）にアクセスできるし、相手の基底クラス
のprotectedメンバ以下（protectedとpublic）のメンバにもアクセスでき
る。ただし、一方が派生クラスのインスタンスで、他方がその基底クラスの
インスタンスである場合、派生クラス側が基底クラス側のインスタンスの
リファレンスやポインタを受けとっても、その基底クラスのprotectedメンバ
以上（protectedとprivate)のメンバにはアクセスできない。

>>224　でエラーが出たのは、派生クラスが基底クラスのポインタを受けとって
いたから、protectedメンバにアクセスできなかったということで、
もし派生クラスのインスタンスを受け取るように設計してれ
ば、インスタンスが異なっていても基底クラスのprotectedメンバにアクセス
できるということ。

>>266
いっそパブリックにしたらぁ？

>>266
派生クラスを経由して基底クラスにアクセスすると何か不具合
でもあるの？

>>264-267
よーくわかりました。丁寧な解説ありがとうございました。
これで、サルから原人レベルになれました。

しかし>>265さんの、htmlのソースを載せる書き方は初めて見ました。おもしろいっす斬新っす

C++でもデバイスドライバ書けますか?

STLで質問ですが、
class a{
int b;
int c;
}
vector < vector<a> > d;
とした場合、
d[10][8]という配列を新規に確保したい場合、どうすればよいのでしょう。

書ける>272

>>273
vector< vector<a> >型の[10][8]の配列が必要なら
vector< vector<a> > d[10][8];
で普通に確保できるぞ？
いまいち質問の意図が読めんが。

>２７５
説明不足ですいません。動的に確保する必要があるのです。

void E(int x,int y){
//ここで動的にd[x][y]の配列を確保したい
}

このような場合です。

>>276
new使って動的に配列確保すれ。
つか、vector４つ重ねたほうがいいと思うが。

”d[x][y]の配列”ってのが意味不明だが、
vector<vector<vector<vector<a> > > > d(x);
for(int i=0;i<x;++i) d[i].resize(y);
もしくは、
vector<vector<a> > **d = new vector<vector<a> > *[x];
for(int i=0;i<x;++i) d[i] = new vector<vector<a> >[y];
こんなもん？

resizeってなかったっけ？

http://www.himawari.sakura.ne.jp/%7Eloveseat/Adu/index0.html

vector< vector <int> >をクラスのメンバにしてファイルに書き出した場合、読み込みも自動的にvectorメンバの範囲を読み取ってクラスのインスタンスのメンバに格納されるのでしょうか。
それとも、自分でassignしなければならないのでしょうか。また、その場合どうやってやればいいのですか。

>>281
内側の個数がわかっているなら、外側のvectorのiteratorを順に回して、内側のvector<int>のresize/assignをしときなさい。
わかっていないなら、vector<int>を一個ずつ追加でもしながら、assignしていきなさい。

質問です。
シングルトンなどで使用されるようなstaticなメンバの開放ってしなくていいんでしょうか？
クラスのデストラクタ（？）みたいなものってあるのかな？

>>283
下でどうでしょ？

#include <iostream>
#include <string>
template <class T>
class Singleton {
　static T *instance;
　static int count;
protected:
　T* create();
public:
　Singleton() {
　　if (count == 0) {
　　　instance = create();
　　}
　　count++;
　}
　~Singleton() {
　　count--;
　　if (count > 0) {
　　　cout << "逝ってよし" << endl;
　　} else {
　　　cout << "オマエモナー" << endl;
　　　delete instance;
　　}
　}
　T& operator *() { return *instance; };
};
template <class T> int Singleton<T>::count = 0;
template <class T> T* Singleton<T>::instance = 0;
string* Singleton<string>::create() { return new string("モナー"); };
int main() {
　Singleton<string> s1;
　Singleton<string> s2;
　cout << "s1:" << *s1 << ", s2:" << *s2 << endl;
　return 0;
}
けど、スタティックなメンバー位なら、(free信者みたいに)あんまり
解放を気にしすぎると健康に悪いと思う。
また、そいつが他の資源を握ってるんなら、
デストラクタにとは別のメソッドで明示的に解放すべきだと思う。

↑
わけがわからん

BCC5.5で試してみた。
・include後に
using namespace std;
を加える。
・string* Singleton<string>::create() { return new string("モナー"); }; を
template<> string* Singleton<string>::create() { return new string("モナー"); };
に変更。
で動いたよ。勉強になった。thx

ほんとかよ！

単にクラスのメンバーに定数を定義したいのですが
class A
{
　const int i = 1;
　const CString str = "abc";
};
等とすると､コンパイルエラーとなってしまいます。
関数定義の中だと問題ないのですが､
クラス内では､このような定義はできないのでしょうか？

>>288
enumを使うか初期化子使え。

>>289
初期化子､はじめて使いました。
まだまだ厨房､､､

>>288
組み込み型はstatic constな場合に限りclass宣言内で定義できる。
よって以下のように書くこともできるyo

// A.h
class A
{
　static const int i = 1;
　static const CString str;
};

// A.cpp
const CString A::str = "abc";

>>291
> 組み込み型は
"整数は"の誤りだな。以下のコードはコンパイルを通らない。

class A
{
　static const float f = 1.0;
};

>>291 >>292
Visual C++ みたいにアホい（というか仕様が古い？）コンパイラでは、
整数でも宣言時初期化はエラーになるんです。

gcc では以下はコンパイルできたよ。

class A {
static const int i = 0;
static const float f = 0.0;
static const double d = 0.0;
static const char* const s = "abc";
};

CStringとchar *は全然違うだろ

>>295

>> 組み込み型は
>"整数は"の誤りだな。以下のコードはコンパイルを通らない。

のあたりを試してみたんだけど？

>>294
確かにgcc(2.95.3)だと通った。これってgccの拡張仕様なのかな。
手元にあるプログラミング言語C++第3版には、整数でないとダメと書いてある。
それとも本が古いの? 誰か教えれ。

MS　VisualC＋＋Ver６で
Windows9x,NT,2000 が終了する際に
cookie をすべて削除するプログラムを作りたいとおもうのですが、
どうやればいいでしょうか？

>>298
常駐してWM_ENDSESSIONが来たらcookieの保存されてるフォルダ内容をすべて消す。

まだ、Visualｃでソフトを作ったことがありません
１　常駐させる方法
２　ﾌｫﾙﾀﾞの内容をすべて消す
方法教えてください。

300の作ろうとしているソフトは怖いです

VBAしか扱ったことがありません。
VBAですと、イベントハンドラたとえば、ボタンを押したタイミング
で、プログラムが動作します。

VisualCの場合は　メッセージを単位ににしてプログラムが動作
するようになるのでしょうか？

>>302
>VBAしか扱ったことがありません。
>VBAですと、イベントハンドラたとえば、ボタンを押したタイミング
>で、プログラムが動作します。
人のことなめてる？(いろんな意味で)

>VisualCの場合は　メッセージを単位ににしてプログラムが動作
>するようになるのでしょうか？
あなたは Win版 HelloWorld からはじめてください。

>>297
ちょっと気になったので調べてみました。
私の手元には1996年のドラフト2のPDFしかないんですが、
（ちょっと古いですかね...）それによると、

> If a static data member is of const integral or
> const enumeration type, its declaration in the class
> definition can specify a constant-initializer which
> shall be an integral constant expression (5.19).

とあります。「整数または enum の場合はできる」と
書かれていますが、それ以外の型の場合については
「できる」とも「できない」とも書かれていませんね。

ちなみに、整数だけ通して、他の型ではエラーになる
コンパイラとしては、CodeWarriar があります。

>>302
「ボタンを押したタイミング」ってのは、「メッセージを単位」にしてるってこと、
もしかしてわかってない?

まずイベントドリブンって言葉から、勉強しましょう。

>>298
とりあえず、お前の求めている機能を実現するのにVCでプログラム書く必要はない。
autoexec.batに以下の１行を追加するだけだ。

del C:\Windows\Cookies\*.txt

ｿﾀﾞﾈ.

本についてですが、
プログラミング言語Ｃ＋＋第３版という本の姉妹本みたいなの
ありますよね。同じアスキーで赤い背表紙の本で、ＯＯＰに関するものや
ＳＴＬに関するものや、あとはＣ＋＋第３版の問題の解答集みたいなのとか。
あのあたりの本はいいのでしょうか？それともＣ＋＋第３版に便乗して
売ろうとしてるただの本なのでしょうか。言語仕様の本とはべつに
ＯＯＰやＳＴＬあたりの本も読もうと思ってるのですが・・・。

>>308
Effective C++ と More Effective C++ は読んでおいた方が良いと思う。

>>309
同意。必須です。

分厚いやつでは最近出たSTLのリファレンス的なやつに目を通せば
よいと思うけど。あとは疑問視。

>>309 の次くらいにExceptional C++とか。
GotWの記事直接見てもよいが。

フォントファイルに関しての質問です

フォント名（ＭＳ ゴシック など）が解っていて、それに対応する
*.TTF あるいは *.TTC のファイル名を得るにはどうすればいいでしょうか。
またその逆に
*.TTF等のファイル名が分かっていて、それに対応するフォント名
を得るにはどうすればいいでしょうか。

MS　VC++ 5
Windows 98

class A {
　const int data[2];
public:
　A(int d1, d2);
};

A::A(int d1, int d2) : data[0](d1), data[1](d2) { }

constのメンバ配列を初期化したいのですが、出来ないのでしょうか？

ちょっと質問があるんですが。
Cで制御系のプログラムを組んでたんだけど、今度C++で組むことに
なったのです。
で、本買って勉強したり、サンプルとか見せてもらったんだけど、データの
部分に関してはクラスを使うのは分かるんだけど、何でもかんでもクラス
にするものなの？
メインで無限ループで受信待ちの部分なんて、クラスにする必要あるの？
制御系のプログラムを組む時、どこまでクラスで設計するものなのか
良く分からないんですけど、いい本とか、いいサイトはありますか？

>>314
メインループは唯一のインスタンスを持つアプリケーション全体のクラス
として設計しる。
含まれるメソッドは初期化、メインループ、例外処理。

そういえば Effective C++ の著者が Effective STL というタイトルの書籍を出したけど、
誰か読んだ人います？

http://www.amazon.co.jp/exec/obidos/ASIN/0201749629

あと個人的には Modern C++ Design: Generic Programming and Design Patterns Applied
も気になってる。

http://www.amazon.co.jp/exec/obidos/ASIN/0201704315

>>312
レジストリを漁れば見つかるはず。でも、スレ違い

>>313
こんなやり方はどう？
class A {
　const int* data;
public:
　A(int d1, int d2);
　~A(void) { delete[] data; }
};

A::A(int d1, int d2) {
　int* temp = new int[2];
　temp[0] = d1, temp[1] = d2;
　data = temp;
}

>315 レスありがとうございます。
なるほど、C++では何でもクラスで作っておけということでしょうか。
それによるメリットは、後々使いまわしがきくということですか？

>>316
> あと個人的には Modern C++ Design: Generic Programming and Design Patterns Applied
> も気になってる。
>
> http://www.amazon.co.jp/exec/obidos/ASIN/0201704315

これめちゃ面白いよ。template炸裂。
Effective C++, More Effective C++, Exceptional C++の次に必読。

// templateが原始帰納関数計算できるって知ってた？

>>316
Effective STL読んでます。今item37。
あと一週間待って。

>>320
Thanks. よし、買おう。

> // templateが原始帰納関数計算できるって知ってた？
Game Programming Gems で template 使って行列計算するサンプルを読んで、
初めて template の記述能力の高さに気づきました。あそこまでいくと、もはや、
コンパイル時に評価されるインタプリタ「言語」ですね。

>>321
レビュー、期待しております :)

>>322

ちょっとサンプル見せて

>>323
行列だと長いから、フィボナッチ数列のサンプルで良い？

template<unsigned N> struct Fib
{
　　enum
　　{
　　　　Val = Fib<N - 1>::Val + Fib<N - 2>::Val
　　};
};

template<> struct Fib<0> { enum { Val = 0 }; };
template<> struct Fib<1> { enum { Val = 1 }; };

これで、ソース中に Fib<8>::Val と書くと、フィボナッチ数列の 8 番目
の数値が得られます。

やはりみなさんは「プログラミング言語Ｃ＋＋」を通して
お読みになられたのでしょうか？

>>323
> ちょっとサンプル見せて

http://cseng.aw.com/book/0,,0201704315,00.html
ここからloki.zipを取得せよ。ちょと強引なのもあるけどね。template萌え萌え

// 標準に追い付いてないg++でcompile出来ない…

>>324
うぁ、すごいね。
これを見ると、とてもC++を使いこなしているとは言えないなぁ

>>324
関数型言語みたいな感じやね

Lisp、ML、Haskelで培った型やマクロに関する知見を、
compile-timeという制約を課して開花させていると思われ

最近良く使うのは、

template <class T> struct UnConst { typedef T UnConstT; }
template <class T> struct UnConst<const T> { typedef T UnConstT; }
…UnConstT<var>…

というようなpattern matchを使ったconst, &, *外し。

「引数がポインタ型だった時だけ」というようなtemplateも書ける。

最近のお話のものは、テンプレートメタプログラミングで
引けばいろいろ出ると思われ。

ttp://www.oonumerics.org/oon/
ttp://extreme.indiana.edu/~tveldhui/papers/techniques/

昔のCマガにも出てたことあり。

>>324
よくもわるくも馬鹿すぎ。
よいほうの理由は説明は略するとして、
悪いほうは「それって単なるCの引数つきマクロと同じレベルじゃん」。
その理屈でいえばマクロ的なことをなんでもやらせられるという安直な結論になるだけだ。

>>331
> 「それって単なるCの引数つきマクロと同じレベルじゃん」
マクロは C/C++ を理解しない単なる文字列置換しかできませんが、template
関数／クラスは C++ の文法を 100% 理解できますから、記述能力が全く違い
ますよ。

それと >>324 で挙げられているような単なる数値計算に限っても、実行時では
なくコンパイル時に値を確定できる利点があります。数値シミュレーションや 3D
ゲームのエンジンを記述する時には、十分に実用的なテクニック。

> その理屈
どの理屈？

マクロは字句解析レベルで置換を行うプリプロセッサ
テンプレートは構文解析レベルで置換候補を作っておいて、
リンク時に解決を行うプリ/ポストプロセッサって感じがする。
（実際は違うんだろうけど）
なんかC++の言語本体からは遊離しているような印象。
それが使いやすくもあり、使いにくくもある。

JavaのJSR-14とかだと、もうちょっと言語よりになっているような．．
reflectできるし、interface指定できるし

lispのマクロみたいね。

>>331
知ったか厨房決定。
テンプレートをよく知らないと思われ。

＞355
いや、ただの厨房でしょ。

みなさん無反応なんですが・・・（汗

やはりあんな分厚い言語仕様本を通して読むのはバカげてますかね・・。

>>337
そんなことない。1回は読んどくべきと思う。
‥とかいいつつ、漏れもまだ20章あたりまでしか読んでないが(w

そうですか。読む勇気が沸いてきました（w。
まだ５章です。
あの大きさは、電車とかで読むのにはちょっとキツイですな。
それがネックになっています。

>>337
読んだよ。

g++-3.0.1ではg++-2.95.3で通ったC++のコードをコンパイルしてくれません。
なぜですか。

2.95.3 では通るけど、3.0.1 では通らないコードを
コンパイルしようとしているからです。

「Standard Template Libraryプログラミング」επιστημη と
「C++標準ライブラリチュートリアル&リファレンス」の
どっちがおすすめですか？

struct A {
　A();
　virtual void method();
};

struct B : public A {
　B();
　virtual void method() { puts("called"); }
};

上記のようなクラス定義で、
1 A::A() { method(); }
2 B::B() { method(); }

1の呼び出しが無効なのは分かるのですが、
2の呼び出しが正常に行われる保証はあるのでしょうか？
Bのコンストラクタが開始した時点で仮想関数は確実に呼び出せる状態にあるのでしょうか？

BCCでは呼び出せたのですが、処理系依存なのか分からないので・・・

>>344
コンストラクタ内での関数呼び出しは不定なので
初期化用メソッドを別に用意するのが普通です。
コンストラクタでの処理は、メンバの初期化などで留めましょう。

>>345

返答ありがとうございました。
初期化メソッドもvirtualで継承してきているので、
そうなるとまたもうひとつ初期化メソッド用意するということですね。
なんか、カッコ悪い(^^;

>struct?
public:を省略して記事量を抑えるためですが(^^;

クラス設計で質問です。

戻り値がvoidのメソッドを作るのなら、
自分への参照を返す方が賢い気がするのですが、
実際どっちが良いんでしょう？

>>322
Effective STL終わりました。

内容は、More Effective C++より平易だと思います。
しかしSTLの中身を少し覗いたことがないと分からないと思われる記述も多いです。
また所々に標準についてのほほうと思う文が散らばっています。
「vector<bool>は標準化委員会の失敗作だ」
では買いなのかといわれると、More Effective C++より役に立つ機会は多いと思います。

>>344
保証はあると思います。

モロ、無修正画像サイト発見！

http://www.sex-jp.net/dh/01/
http://www.sex-jp.net/dh/02/
http://www.sex-jp.net/dh/03/
http://www.sex-jp.net/dh/04/

>>347
>自分への参照を返す方が賢い気がするのですが、
この根拠は？どんな用途を想定しているの？

>>345
大嘘付かないよーに

各コンストラクタ中の仮想関数呼び出しは、自分自身の仮想関数
テーブルを用いて行われるので、どのクラスの仮想関数が呼ばれ
るかを特定できる

>>344
＞1の呼び出しが無効なのは分かるのですが、

無効というのは、B::methodが呼ばれないという意味？
そういう意味では真だが、A::methodが呼ばれるのは保証される

コンストラクタ内では、自分はまだ作りかけで
オブジェクトとしては(コンパイラに)認知されていないから、
仮想関数は部分オブジェクトとして構築済みの
基底クラスのそれが呼ばれるのだ。

仮想じゃない関数を介してコンパイラをだますことは
できるけれど、あくまで自分は作りかけなので
それを承知の上での処理をしないといけない。

んだよね？

ファイルをios::inでopenしたりした時にそんなファイルが無かったりした場合などのようにI/O関係でのエラーで例外を投げてくれないのは？
一々状態チェックするの嫌なんだけど。。。

>>３２4あたりのテンプレート
いろいろやってみるも実際は意図した結果になかなかならないなー
結局ループしてたりw

あとテンプレートの引数が複数あって、片方だけ専門化できるようにならんのかな

>>314

最初っから何でもかんでもクラスにするこた無いかも。

・とりあえず // と const と inline と namespace に萌えてみる
・関連の強い構造体と関数をクラスにまとめてってみる
・ユーザー定義型を作ってみる
・標準ライブラリを覚える
・全部オブジェクトにする（シングルトンとか使って）
・クラスライブラリを作ってみる
・テンプレートライブラリを効率を意識しながら作ってみる

みたいに段階を踏んだ方が、実行時効率を問われる世界から来た場合はやりやすい
んじゃなかろーかと。
例えば、関数オブジェクトを知らないでクラスライブラリ作ろうとしたりすると、
効率と柔軟性のトレードオフな物しか書けない訳で。

>>352
> コンストラクタ内では、自分はまだ作りかけで
> オブジェクトとしては(コンパイラに)認知されていないから、
> 仮想関数は部分オブジェクトとして構築済みの
> 基底クラスのそれが呼ばれるのだ。

そんな仕様聞いたことないよ。
A::f()とB::f()が宣言されてる時にBのスコープ内で単にf()としたら、
B::f()が呼ばれるのが自然じゃない?

リファレンスやポインタを介さない関数呼び出しはコンパイル時に静的に決定できる
ので、仮想関数の仕組みは必要ないと思うんだけど。

で、結局 >>344 の例だと、
void hoge(void){
　B b;
　// 何か
}
とした時、Bの構築時は、まず基底クラスAのデフォルトコンストラクタA::A()が呼ばれ、
その中でA::method()が呼び出され、その後でB::B()が呼ばれ、B::method()が呼ばれる
という順番になると思うんだけど‥。少なくともうちのgccではそうなったよ。
これが保証されないんなら怖くて継承とか仮想関数とか使ってられないよ。

>>357
確かに実際にはその順番になるんだけど…。

B b;
ってしたときに、A::A() の中で B::method() ではなく A::method() が
呼ばれてしまう実装ってダサいと思わないか？
しょっちゅう間違えてハマるんだけど、俺。(w

12.7

-3- Member functions, including virtual functions (class.virtual),
can be called during construction or destruction (class.base.init).
When a virtual function is called directly or indirectly from a constructor
(including from the mem-initializer for a data member) or from a destructor,
and the object to which the call applies is the object under construction or destruction,
the function called is the one defined in the constructor or destructor's own class or
in one of its bases, but not a function overriding it in a class derived from the constructor or destructor's class,
or overriding it in one of the other base classes of the most derived object (intro.object).
If the virtual function call uses an explicit class member access (expr.ref) and the object-expression refers to the object
under construction or destruction but its type is neither the constructor or destructor's own class or one of its bases,
the result of the call is undefined. [Example:

352さんはどうやら分かっているが誤解をまねく記述をしている模様。
んで358さんへの答えは352さんがしているという再帰。

>>358
もっと勉強してから偉そうなこと書いてくれ

>>351
あう〜、大嘘はひどいモナー（AA略）、というわけでザッと探してきた
http://www1.kcn.ne.jp/~robe/cpphtml/html02/cpp02017.html
http://www.sun-inet.or.jp/~yaneurao/rsp/rspA1toA8.html
（逆に叩かれたりして（ｗ

うーん、VCだけなのかなぁ。でも…昔のBCCも仮想関数呼び出し前に
派生クラスのコンストラクタ呼んでくれなかったような…。

あとコンストラクタ内で重い処理するとマズイみたいな話無かったっけ？
それにグローバルでやるとなんたらとか……全部記憶が曖昧だ(^-^;

全部ひっくるめて適当に答えたのは謝ります。ごめんね〜　>>344

>>359
おっと書いてる間に…よく読んどこ

>>354
コンパイラ古くない?

>>337
読んでるよ。仕様書も必要なところは。
仕様書のcode断片例はいいと思う。仕様は曖昧じゃないしさ。

>>361
yaneuraoあげると余計ややこしくなる

質問です
クラス A がクラス B へのポインタを持ち、クラス B の機能を
利用するのですが、クラス A の派生クラス AA はクラス B の
機能では満足できないのでクラス B の派生クラス BB を利用します.

クラス A ではクラス B へのポインタを設定する関数
SetProxy( B * pB ) を宣言しているのですが、
クラス AA はクラス BB の機能を利用するため SetProxy のポインタを
クラス BB 以下の派生クラスに限定したいのですが
クラス A の SetProxy インタフェースを維持しつつ、
クラス AA の SetProxy ではクラス BB 以下の派生クラスへのポインタを
限定して受け取るように設計するにはどうしたら良いのでしょうか？
あと、初心者なのでこういう設計になれていないので
良い設計がありましたら、教えてほしいのですが…。

class B {
public: void doHogeHoge();
};

class BB : public B {
public: void doFooBar();
};

class A {
protected: B * PointerB;
public: void SetProxy( B * pB) { PointerB = pB; } };

class AA : public A {
protected: BB * PointerBB;
public: void SetProxy( BB * pBB) { PointerBB = pBB; } };
???

>>359
いや、だからC++ってその辺ダサくない？って言ってるんだが。
「そういうもんなのです」って答えっスか？

>>366
この結果のどこがダサイですか?
Bの部分であるAをconstructする時に、Aに任せるのは当たり前では?
何か勘違いしてませんか?

$ cat virtual.c
#include <iostream>

using namespace std;

struct A {
A() { method(); }
virtual void method() { cout << "A's method() called" << endl; }
};

struct B : public A {
B() { method(); }
virtual void method() { cout << "B's method() called" << endl; }
};

int main(void) {
A a; B b;
return 0;
}
$ g++ test.c
$ ./a.out
A's method() called
A's method() called
B's method() called
$

>>367
派生クラスによる追加部分が未構築な段階で、
基底クラスの構築子から派生クラスの仮想メソッドを呼べてしまうと、
その仮想メソッドが派生クラスの未構築なメンバをもしもアクセス
すると動作が異常になるので、言語仕様では安全サイドに振って
一律に派生クラス側のメソッドを呼べないようにしているわけだが、
コンパイラとリンカが神のごとく賢ければ、未構築なメンバを
アクセスする仮想メソッドの呼び出しに対してはエラーを、
さもなくば呼び出し可能としても良いわけで、>>358 はそれを
ダサいと言っているのであろう。
逆にプログラマ責任サイドに振って、派生クラスの仮想メソッド
を呼び出しOKにして、未構築なメンバをアクセスするような
仮想メソッドの場合は「未定義の動作」とする手もあったと思う。
C++の場合、この手の選択では「未定義の動作」とする場合が
多いのだが、そうしなかったのは仮想テーブルの設定を行う
実装が難しくなるからかな。

>>368 の続き
ちなみに、Java は基底クラスの構築子の中から、
派生クラスの仮想メソッドが呼べてしまう。

その時点では派生クラスで追加したフィールドは派生クラス
の構築子による設定前なので、デフォルトの0(null)が埋まっている。
C++のように「デフォルトは不定」ではないので、深刻な問題は起きない。
もちろん、0(null)がプログラマが意図した結果であるかどうかは別問題。

------------(インデントはスマン)
class A {
A() { v(); }
public void v() { System.out.println("A#v"); }
}
class B extends A {
String s;
B() { s="hello"; v(); }
public void v() { System.out.println("B#v s="+s); }
}

public class test {
public static void main(String[] argv) {
// A a = new A();
B b = new B();
}
}

$java test
B#v s=null
B#v s=hello
------------

C# ではどうなるのかな。

>>361
ええ。叩かせて頂きまふ(ｗ

上のURLの方は、説明してる事は*ほぼ*正しいんですが、
＞仮想関数はコンストラクタ内では正しく働かない。
という表現が間違ってますな。

下のURLの方は、>>358と同じ勘違いをしてるんでしょう。
何処を勘違いしてるかは、>>352と>>367が書いてるから省略。

仕様を調べたわけじゃないから不正確だけど、危ないのは
初期化構文で仮想関数を呼んだ場合。(B() : A(method()) { })

仮想関数テーブルが初期化作業は、初期化構文を抜けて、
コンストラクタの関数部分({})に入る直前に行われるから、
この場合は何が起こるかわからない。(bcc32.exeだと落ちた)

>>370 何が起こるかわらない…って違うだろ。>>359 を良く読め

>>367-369
残念ながら恐らく>>366さんはそんなことをダサいと言っているのではないです。

模範解答

C++のコンストラクタは、"コンストラクタ"だからである。
コンストラクタとメモリ管理を密接に結びつけることによって
コンパイラ実装者は、コンストラクタに、オブジェクトを作成するための
多種多様なメモリ管理の意味を与えることができる。

Javaにおいては、
メモリの割り当て及びメンバ変数の初期化を、コンストラクタと切り離すことによって
基底クラスコンストラクタが実行される前に、
派生クラスオブジェクトのメンバ変数が初期化済みであることを保証することができる。

いや残念ながら俺が言いたかったのは、>>368氏が例としてあげた
> 逆にプログラマ責任サイドに振って、派生クラスの仮想メソッド
> を呼び出しOKにして、未構築なメンバをアクセスするような
> 仮想メソッドの場合は「未定義の動作」とする手もあったと思う。

こういう仕様の方が自然だったんじゃないか？ってこと。
仮想関数を呼んだときに実際に呼ばれる関数が
コンストラクタ配下で"だけ"他の場合と異なるってのは
違和感があるっつーか何というか。


> コンパイラ実装者は、コンストラクタに、オブジェクトを作成するための
> 多種多様なメモリ管理の意味を与えることができる。

ゴメン俺あんまり理解できてない模様。今の場合だと

　　C++のコンストラクタ ∈ メモリ管理
→　vtableの構築も"コンストラクタ"の仕事
→　派生クラスコンストラクタより先に基底クラスコンストラクタが呼ばれるので
→　基底クラスコンストラクタ中ではvtableは整って無くて当然

ってことでしょか？

「整ってなくて」って言い方はマズいかな。
「まだ派生クラスのものになっていなくて」 くらいに修正…。

>>365
実装とインターフェースを分離すれば？

struct A
{
　　virtual ~A() {}
　　virtual void doSomethingWithB() = 0;
};

struct AA : public A
{
　　virtual ~AA() {}
　　virtual void doSomethingWithBB() = 0;
};

class AImp : public A
{
　　B* m_imp;
public:
　　AImp() : m_imp(NULL) {}
　　void SetProxy(B* imp) { m_imp = imp; }
　　void doSomethingWithB() { m_imp->doHogeHoge(); }
};

class AAImp : public AA
{
　　BB* m_imp;
public:
　　 AAImp() : m_imp(NULL) {}
　　void SetProxy(BB* imp) { m_imp = imp; }
　　void doSomethingWithB() { m_imp->doHogeHoge(); }
　　void doSomethingWithBB() { m_imp->FooBar(); }
};

スタティックライブラリのファイルサイズって
実行速度に影響するんですか？

>>376
質問が大雑把過ぎて、何が言いたいのが良くわかりませんが。

純粋に実行コードのサイズの話なら、ワーキングセットがキャッシュメモリの
サイズを越えるかどうかが問題。実行ファイルが 100KB でも 1MB でも、あ
る時間内に頻繁に実行される部分が L1 キャッシュに収まるなら、実行速度
は変わらない。

あとスタティックライブラリのファイルサイズが大きくても、それが全て実行ファ
イルにリンクされるわけじゃない。必要な部分だけリンクされる。

>>377
ありがとうございます
数値計算で使うパッケージが全部で14Ｍくらいなんで
どうなんだろうかと思っていましたが
ちょっと安心しました

>>375
ありがとうございます。勉強になります。
クラスAAは派生クラスBBを受けるので、引数の異なるSetProxy()を
定義することになっちゃいますよね。ポリモルフィックの見方からすると
それで良いのかなと思いまして。
共通のSetProxy()を宣言して、ダウンキャストできるか調べる方法も
ありますよね。それとどちらが良いのかなとも。
OOP は難しいです…。(^^;)

>>379
> 共通のSetProxy()を宣言して、ダウンキャストできるか調べる方法も
> ありますよね。それとどちらが良いのかなとも。
他のクラスがどのように A, AA と関わってくるかによって最適解は違ってきますが、
こちらの方法だとコンパイル時にエラーを検出できないのが悲しいですね。

> OOP は難しいです…。(^^;)
クラス階層の設計に関しては、必ずしも「正しい」解答がないですからね。

ただし、経験から生み出された定石があって「デザインパターン」と呼ばれています。
C++ では言語レベルでな継承・集約をサポートしていますが、これに加えてデザイン
パターンも習得すると、設計の柔軟性が格段に上がります。

参考文献
　オブジェクト指向における再利用のためのデザインパターン 改訂版
　ガンマ，エリック ヘルム，リチャード ジョンソン，ラルフ ブリシディース，ジョン
　ソフトバンクパブリッシング (1999)ISBN:4797311126

デザインパターンの骸骨たち
http://www11.u-page.so-net.ne.jp/tk9/ys_oota/mdp/

>>373
そのような実装も許されるということです。(ARM 10.9c)
未構築の派生クラスオブジェクトに対する仮想関数の呼び出し自体が定義できません。

>こういう仕様の方が自然だったんじゃないか？ってこと。
標準化委員会はそう思わなかったようです。
Javaは、基底クラスコンストラクタの呼び出しの前に、
派生クラスオブジェクトのメンバ変数は初期化されているので
実はこの判断と独立できます。
その説明が、>>372です。

>>380
素早いレスありがとうございます。とても早かったのでちょっとびっくりです。

>こちらの方法だとコンパイル時にエラーを検出できないのが悲しいですね。
そうですよね。見た目なんとなく、すっきりするのですが
コンパイルエラーでチェックできないので…
あまり良くないかもしれないです。
こういうときに使うもの、ではないのかも…。

>これに加えてデザインパターンも習得すると、
>設計の柔軟性が格段に上がります。
デザインパターンはまだ未開拓の土地です。(^^;)
C++をまだ十分理解できていないので難しいかな？と
思いまして。(^^;)
設計する上で先人の勉強は大切ですよね。この機会に
ＤＰのほうも一緒に勉強してみます。
役立つリンクをご教示いただいて、ありがとうございます。(多謝)

-********/////////////////////--------------------------------------------------------------------------
あなた達には分からないでしょうが、Rubyは素晴らしい言語です。
オブジェクト指向スクリプト言語として他のスクリプト言語を圧倒する性能と美しい言語仕様を持っています。
例えば、SchemeやSmallTalkなどは比較的美しい言語だと言われていますが、後発である優位さでRubyは
さらなる美しさと実用性を備えています。
もちろんPerlやPythonなど問題外です。
日本語との親和性ではRubyしか選択肢がないでしょう。

LinuxのディストリビューションもRubyの採用例が増えてきています。
１年後には全てのディストリビューションがRubyを標準採用するでしょう。
Rubyは未来のスクリプト言語なのです。

長くなりましたが、コピペではありません。
賛同していただける方はRubyの事を分かっていただけない人に出会ったら、
この発言をコピペしていただければ幸いです。
C＋＋なんて問題外ですが。

じゃあなんで
Ruby　Ruby　Ruby　Ruby　Ruby　Ruby　Ruby　Ruby　Ruby　Ruby　Ruby　Ruby
とかやる荒らしが出る？

>383はDelphiスレとかにも似た奴貼り付けてる。
放置。

C＋＋なんて問題外です。
C＋＋なんて問題外です。
C＋＋なんて問題外です。
C＋＋なんて問題外です。
C＋＋なんて問題外です。
C＋＋なんて問題外です。
C＋＋なんて問題外です。
C＋＋なんて問題外です。
C＋＋なんて問題外です。
C＋＋なんて問題外です。
C＋＋なんて問題外です。
C＋＋なんて問題外です。
C＋＋なんて問題外です。
C＋＋なんて問題外です。
C＋＋なんて問題外です。
C＋＋なんて問題外です。
C＋＋なんて問題外です。
C＋＋なんて問題外です。
C＋＋なんて問題外です。
C＋＋なんて問題外です。

俺はどっちも好きだ。どっちもいい言語だよ。
けど、Rubyの話は別スレでやってくれよ。

Rubyは好きだけどRubyバカは勘弁してくらはい。
お前らにRubyを語られたらゆきひろがかわいそうだろ？

Rubyはクソです。ゴミ箱逝きです。

いじょ

>>383
Linuxは何言語で作られているか分かってるんだろうかわらぃ

どなたかマージソートで重複を削除する
プログラムを教えていただきませんでしょうか？？

>>390
それ C++ の話なんですか？　ともかく、宿題は麻衣ちゃんに教わって下さい。

お兄ちゃんの宿題、私が答えるよ
http://piza2.2ch.net/test/read.cgi?bbs=tech&key=982853418

Ｃ言語です。
ありがとうございます。
さっそく聞いてみます。

Rubyはクソです。ゴミ箱逝きです。

いじょ
この発言をコピペしていただければ幸いです。

Javaスレにも出没していたな。
そんなに素晴らしいのなら、他言語と比較するアカデミックなスレでも立てて、他人を納得させてみなさい。まぁ、叩かれるのがオチだろうがな。

>>388
（　´∀｀） ナイスお茶。

マジレス希望なんですけど
new演算子で確保したメモリに対してエラーチェックってしたほうがいいんでしょうか？

if( ( int *pNum = new int ) == NULL ) {
/* エラー時の処理 */
}

っていう感じに

new は失敗すると std::bad_alloc という例外を送出するナリ
例外を送出して欲しくなければ new(nothrow) なんてするナリ

new(std::nothrow) かな？

>>397さん早いレスありがとうございます、
例外って意外と便利なんですね。

#include <iostream.h>

int main(void)
{
char c;
int i=0;

while(cin.get(c)) {
i++;
}

cout << i << endl;

return(0);
}
これで、入力した文字数をカウントして表示するプログラムを作成したつもりですが、
これでは、文字数が表示されません。どこが間違っているのか教えてください。

>>400
文字の入力が終わるのはいつだ？

>>400
C++以前の問題。
わからんかったらプログラム書くな。

>>396
set_new_handlerも調べておけ。

>>399
ただし、落とし穴もあるので注意な。

void foo()
{
　　int *p1, *p2;

　　p1 = new int;
　　p2 = new int;
　　// do something
　　delete p2;
　　delete p1;
}

このプログラムで p2 = new int に失敗すると、そこで例外が投げられて関数
を抜けてしまうため p1 = new int で確保したメモリを開放する機会が失われ
る。

C++ の例外に絡んだ落とし穴は色々あるので、実用的なプログラムを書くなら
Effective C++, More Effective C++, Exceptional C++ の三冊は必読。

＞Effective C++, More Effective C++, Exceptional C++ の三冊は必読。
おいらはこのうちの一冊も読んでないナリ。
読んだのは、プログラミング言語C++ と ARM だけです。
実用的なプログラムを書くのは無理ですか？(藁

>>405
その読んだって２冊の読み方によるけど、
仕事で使ったりするんだったら、
読んでないとロクでもないソフトが完成してしまうと思います。

っていうか、出来れば読みたくない訳？
C++でコード書きたかったらがむしゃらに読んどけ。

＞その読んだって２冊の読み方によるけど、
思うんだけど、プログラミングの初心者じゃない人で
その２冊読んでダメならなに読んでもダメなんじゃない？

あと、C++ の解説書ばっかしいくら読んでも
スキルは上がらんよ。

何度もゴメソ

＞Effective C++, More Effective C++, Exceptional C++ の三冊は必読。
ちなみにこの３冊が良い本なのは確かだと思いまふ。
読んでないけど。

以上、暇だったのでからんでみました。

そうそう。Rubyができないと一人前とは言えないね。

>>410 ワラタ
でも氏ね

>>410
　　　λ
　　 (　ヽ　　／￣￣￣￣￣
　　( ﾟДﾟ )＜　Rubyはクソです。ゴミ箱逝きです。 いじょ
　(＿＿＿_) ＼＿＿＿＿＿
　　　ヽ(´ー｀).ﾉ
　　　　　(　 へ)
　　　　　　く



　　　　　　　　　　　　　　　　　　　　　　- = ≡三　　λ
　　　　　　　　　　　　　　　　　　＿ = ≡三　　　　　(　ヽ　　／￣￣￣￣￣
　　　　　　　(´ー｀) 　　　　　　　　　= ≡三　　　　( ﾟДﾟ )＜　この発言をコピペしていただければ幸いです。
　　　　　　( ヽ ヽ)　　　　　　　　　- = ≡三　　　(＿＿＿_) ＼＿＿＿＿＿
　　　　　　／　　>　　　　　　　　　　　　　- = ≡三

>>397
VC6は投げないという話があったような。VC持ってないから間違ってたら失礼。

try { delete[] new char[-1]; } catch (const std::bad_alloc& e){ std::cerr << e.what(); }
こんなんで確認出来るだろうか？(one-liner失敬)
保護の弱い環境だとクラッシュするかも。

Effective C++, More Effective C++, Exceptional C++
これらの本はＣ＋＋のどのような本なんですか？
ＯＯＰとかですか？

OOPならRubyだね。

>C++
>いろいろと有名なオブジェクト指向言語であるC++と
>Rubyを比較すると:

>* C++なぞ問題外．^^;;;

http://www.ruby-lang.org/ja/compar.html

Rubyを知ってもらうためにもこの文をコピペしてください。

ttp://www.ascii.co.jp/books/detail/4-7561/4-7561-1808-9.html
ttp://www.ascii.co.jp/books/detail/4-7561/4-7561-1853-4.html
ttp://www.mmjp.or.jp/pearsoned/washo/prog/wa_pro34-j.html

>>415 いまさらですが、ひとつに偏るのは良くないです。

>>414
「プログラミング言語Ｃ＋＋」は、コンパイラ作成者向けに書かれた仕様書を、利用者
向けに咀嚼した書籍だけど、上の三冊は仕様書の狭間にある陥穽や、仕様書には直
接は書いていない言語仕様策定者の意図に踏み込んで解説している。

実践で得られた知見をまとめた Tips 集、というのが近いかな。

Exceptional C++ も似たようなものだけど、こっちは Gru of the Week の記事が元に
なっている。英語が苦手でなければ、Web で公開されている記事をどうぞ（というか
私は GoW しか読んでない）。

Gru of the Week
http://www.gotw.ca/gotw/

　　　　　　　　　　　　　　　　　　　　　　　

――――――――――――――――――――――
番組の途中ですが、臨時ニュースです。
「Rubyはクソです。ゴミ箱逝きです。 いじょ 」
この発言をコピペしていただければ幸いです。
＿＿＿＿＿＿＿＿＿＿_ 　 ＿＿＿＿＿＿＿＿＿＿
　　　　　　　　　　　　　‖　＼|________　　　
　　　　　　　　　　　　　‖　| ON AIR.|
　　　　　　　　　　　　　‖　￣￣￣￣
　　　　　　　　.／￣￣θ Λ＿Λ
　　　　　　...／　　　／／（´∀｀　)／|
　　　　　.／　　　　 ￣／⊂　　　 ||_／
　　　　　|￣￣￣￣￣|　 （　 ━┳┛
　　　　　|＿＿＿＿＿| ／ヽ｣┘┻

　　　　　　　　　　　　　‖　| ON AIR.|
　　　　　　　　　　　　　‖　￣￣￣￣
　　　　　　　　.／￣￣θ Λ＿Λ
　　　　　　...／　　　／／（´∀｀　)／|
　　　　　.／　　　　 ￣／⊂　　　 ||_／
　　　　　|￣￣￣￣￣|　 （　 ━┳┛
　　　　　|＿＿＿＿＿| ／ヽ｣┘┻

　　　　　　　　　　　　　‖　| ON AIR.|
　　　　　　　　　　　　　‖　￣￣￣￣
　　　　　　　　.／￣￣θ　　　Λ＿Λ
　　　　　　...／　　　／／（´∀｀　)／|
　　　　　.／　　　　 ￣／⊂　　　 ||_／
　　　　　|￣￣￣￣￣|　 （　 ━┳┛
　　　　　|＿＿＿＿＿| ／ヽ｣┘┻

　　　　　　　　　　　　　‖　| ON AIR.|
　　　　　　　　　　　　　‖　￣￣￣￣
　　　　　　　　.／￣￣θ　　∧＿∧
　　　　　　...／　　　／／（´∀｀　)／|
　　　　　.／　　　　 ￣／⊂　　　 ||_／
　　　　　|￣￣￣￣￣|　 （　 ━┳┛
　　　　　|＿＿＿＿＿| ／ヽ｣┘┻

AA調整実験中

――――――――――――――――――――――
何故か耳がズレる
＿＿＿＿＿＿＿＿＿＿_ 　 ＿＿＿＿＿＿＿＿＿＿
　　　　　　　　　　　　　‖　＼|________　　
　　　　　　　　　　　　　‖　| ON AIR.|
　　　　　　　　　　　　　‖　￣￣￣￣
　　　　　　　　.／￣￣θ　∧＿∧
　　　　　　...／　　　／／（´∀｀　)／|
　　　　　.／　　　　 ￣／⊂　　　 ||_／
　　　　　|￣￣￣￣￣|　 （　 ━┳┛
　　　　　|＿＿＿＿＿| ／ヽ｣┘┻

この間から騒いでるRuby厨房は、当然Rubyも理解できてないと思われ。

参照はどう使うと
きれいにコーディングできますか？
以前Javaをやっていて、VC++もやってみようと思い
現在C++猛勉強中です
JavaからC++に移行する際に注意する点等もありましたら
教えてもらえるとうれしいです
多重継承と、virtualをつけないとオーバーロードできない点が
なんか違うなーと感じてます

オーバーライドですね

参照は & と * があるよ
& はいまいち好きじゃない。値渡しと見た目で区別できないから。
でもコピーコンストラクタやテンプレートで必須になるんだよね。

>>425
左辺値を返すとき、たとえば
代入演算子のオーバーロードをするとき。
virtualがないものはクラス名で修飾された、
単なる関数で第一引数にthisが渡っていると
考えて良いそうな。
デストラクタの実行はスコープがあれば
その終わりに順ずる。
コンテナと例外をうまく使えばごみ集め
の手間はかからない。

C++(gcc)でシグナルハンドラからlongjmpするとコアダンプ
するんだけど、仕様的にはこれでいいんだっけ？
もうひとつ、allocaってC++で使っていいのかってこと。
例外とデストラクタが絡むから、ヤバイ気がする。

>>429
おいおい、シグナルハンドラからどこへ longjmp するんだ？

＞例外とデストラクタが絡むから、ヤバイ気がする。

そこまでわかってるならやばくないように
使うこともできるのでわ？
まあ c++ ならあんま必要ないしね。

gcc 限定なら int a[n] (iは非定数)なんてことができて
これは alloca と等価。

×:(iは非定数)
○:(nは非定数)

Ｖｉｓｕａｌ　Ｃ＋＋７．０っていつでますか？

>>432
激しくスレ違い。

visualC＋＋で
一般保護法違反がでてPCが固まったんですけどなんででしょうか?

>434　ははは・・・キミの上司ならもしかして理由の想像は判るかもしれないね。
　　　　でもたぶん・・・・・

　PCを固めるのはコールバック系の処理中に変な事するとか
　まあ色々方法はあるけどね

コールバック系?
リアルジュークボックスを起動しながらやっていたせいかなぁ?

>>429
ISO/ANSIでは、C++における(POSIX) signalについて何も保障してない。
環境依存だから、compiler, libraryのmanualを読め。

ただ、longjumpはregister周りをいじって大域脱出を実装するので、
destructorが呼ばれるなんて事は金輪際ないと思うぞ。

signal→例外という機構がまだないんだなー。UNIXには。
Windows(SEH&__try)にはあるのになー。

関数内ででかい配列を宣言すると飛ぶよ。
gnucも飛ぶ。

シグナルハンドラ内で閉じている longjmp は、
たぶん機能するんじゃないかと思います。
ただしスタック巻き戻すときにデストラクタなんかは動かないでしょう。
(なので覚悟の上じゃないとちょとアレ)

シグナルハンドラてのは、プログラム本体とは無関係に
非同期に動くものなので、シグナルハンドラの外へ longjmp するのは
あるスレッドで setjmp した場所へ、別のスレッドから
longjmp しようとするようなものです。

飛ぶでしょ？普通。

＞(なので覚悟の上じゃないとちょとアレ)
かわりにC++ではthrow/catchを使うべきだですよね。

>>440
シグナルハンドラから throw するのも、保証されてるかどうか怪しいな。
環境依存だからマニュアル読んでね、としか言えないけど。

ソダネ
そもそも本筋で throw してる最中にシグナルハンドラが
呼ばれて、そんなかで throw しようとしたらえらいことになるかも？

>>436
ばーか。
そんなこと逝ってるようなやつが質問すんな。

>>443
恐怖恐怖恐怖！！
４４３引見陰険隠見隠顕淫ビ
４４３最低
いじめかこわるい
ださ
さいあく〜〜〜〜
ちょーーーーーーー
ぼーーーーーーーーーーーーーーーーーー
ぶーーーーーーーーーーー
ってか厨房
あほ
だぼ
さヴぉ

しったかぶり
　　　　　　　　∧ ∧　　　∧ ∧
　　 ／⌒~~~⌒＼ 　　　　　　　　　　　　　　　　　　　　　　(　 　,,) 　　(,,・Д・)
　／ （ ﾟ?д?ﾟ ）y─┛~~ 　　　　　　　　　　　　　　　〜（＿__ﾉ 　〜（＿__ﾉ　,γ＿
（_ ノγ Ｕ　　∩_∩）　　　THANK YOU　2ｃｈ　　　　　┌───────┐　　　＼
　　α＿＿＿Ｊ _Ｊ　　　　　　　　　and　　　 　 　　　 （｜ ●　　　 　 　 ●　| 　　　 　ヽ
　　／￣￣￣￣＼ 　GOOD-BYE ２ｃｈ WORLD！ ／.|　.┌▽▽▽▽┐　.|____|__||_| ））
　/　　　　 ●　　●､　　　　　　　　　　　　 　 　　 　（　┤ .｜　 　 　 　 ｜　.|□━□ ）
　|Y　　Y　　　　　　　＼　またどこかで会おうね　　＼.　 .└△△△△┘　.|　 J　　|）
　|.| 　 ｜　　　 　 　.▼ |　　　　　　　　　　　　　　　　　｜　＼あ＼　　　　　 |　∀　ﾉ
　| ＼／ 　　 　 　 ＿人|∧∧∩゛冫、　.∧＿∧　 　 　 |　 　 ＼り.＼ 　 　 . |　 - ′
　|　　　　　　 ＿/）/）／( ﾟДﾟ)/　`　 .　（´∀｀　）..ヽ(´ー｀)ノ　　＼が＼ . 　 |　 ）
　＼　　　　／ 〔／＼〕　U　　/　∩∩　（　　　　） （＿＿＿）　　　 ＼と.＼　.|／
　　｜ ｜　|　ｃ（*・_・）　 |　　|ヽ(´ー｀)ノ_|　 |　 |　｜　　　｜〜 ／＼.＼う＼|　(-＿-)
　　（_＿）＿）　UUUU　/∪∪ （＿＿_）（＿（＿_） ◎￣￣◎─┘　.└──┘.（∩∩）


　ママ〜 2chでスレたてたよ〜
　＼＿＿　 ＿＿＿＿＿＿
　　　　 　∨　　　 ∧＿∧
　　　　 　　　 　　" ,　 、　ﾐ 　　／￣￣￣￣￣
　　　　 　　　 　 　ゝ∀　く 　＜　いい子ね、後で見てみるわぁ
　　　　　 　　　　 ∧_∧ 　| 　　＼＿＿＿＿＿
　 　 　　 　三 　（　 　 とノ
　　　 　　三 　　/ 　　つ |
　　　　　三　 _ ( _ 　/|　 |
　　　　　 　　（_ｿ（_ソ（＿ ）

テレビにニュース速報が入る。
俺は慌ててパソコンを立ち上げ、そして気付く。
「あぁ、2chは閉鎖したんだっけ……」
テレビからは現場の慌しい状況が伝わってくる。
もし2chがあったら、どういうスレが立っているのだろう。
重複スレが沢山できて、それで荒らしとかやってきて……
テレビでは相変わらず、レポーターが必死で現場の状況を伝えている。
可愛いレポーターだ。俺は、頭の中で「萌え〜」というレスを
つけている自分を想像した。
後ろの群集がテレビに向かって挑発的なポーズを取っている。
「なんだ、あのドキュソ」「厨房氏ね」……
俺はたまらなくなり、無いとは分かっていながら再び2chにアクセスした。
しかし、画面には一言「閉鎖したのです。。。」とだけしか表示されない。
何度リロードしても変わらない。あの日以来、2chは止まったのだ。
どうやら犯人が逮捕されたようだ。相変わらず可愛いレポーターが
その状況を伝えている。
「さよなら、にちゃんねる」
俺はお気に入りから2chを削除し、そして騒がしいニュースを冷めた目で
見るのであった。
　　　　　　　　　

　　　　　　　 　　　　⊆ニ(二(ニニ⊇ 　　⊆ニ(二(ニニ⊇
　　　　　　　　.／￣￣￣￣￣/￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣ヽ
　　　　　　　／　＿＿＿＿/＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿ヽ
　　　　　　,/￣￣ ┏━, /￣￣￣|| ||.￣￣￣￣ ||| ￣￣￣￣￣￣￣...| |
　　　　　,/ ∧ ∧.　i┸i //. ∧ ∧　|| ／￣￣￣￣￣￣￣￣￣￣￣￣￣
　　　 _.,/.　(・Д・ )　| :::|//　(ﾟДﾟ　) ＜　>>４４３を迎えにきました。措置入院です！！
　　　|/,,,,,へ⊂　ヽ　 .// 　,/　　ノ/ ||＼＿＿＿＿＿＿＿＿＿＿＿＿＿＿
　　,/￣￣￣￣￣￣//|＿／￣￣￣| ￣￣￣￣￣ |￣￣￣￣￣￣￣￣|
　　|~ ゜￣゜￣￣￣~~|￣￣　　　＝。|┃　　　　　　　|━━━━━...............|
　　|＿＿＿＿＿＿: |,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,|,,,,゜,,,,,,,,,,,,,,,,,,,,,,,,,|,,,東京精神病院,,,,,[|
　._|]0::∴:::0::[二二il:]　　 　,-―-、 ,,|　　　　　　　 　|　　　　　　　.　　 　 [|
　|=＝＝＝＝= ;...........|　　/, ￣ヽ |~~|.　　　　　　　　|　　/, ￣ヽ |　　　 　{|
　ヽニ[＿]ヾニニヽ''''''|―-|.（※）|':|''''|.'''''''''''''''''''''''''''''|''''''''|.（※）|:|'''''''''''''''''/
　　　　　ゞゝ三ノ￣￣￣ ゞゝ＿ノ￣￣ゞゝ三ノ￣￣￣ ゞゝ＿ノ

while(){
printf("きしょ");
}

━┓　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 ＿＿＿_
]　┃　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　／　　　　/
　 ┃　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 ／　2ｃｈ 　/
]　┃　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　／Λ＿Λ　 /
　 ┃　　　　ｹﾞｷﾄﾂｽﾙｿﾞﾇｯ!!　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 ／　（´∀｀　） /
]　┃　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　／ ∧∧ 　　　）/
　 ┃　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 ／　 (ﾟДﾟ )￣￣ /
]　┃　　　　　 ＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿／　　　　U U￣￣/ ＿
　 ┃　　　　／　 　 　 　 　・・・・・|_|・・・・・ Λ＿Λ　∩∩　　／）_／）　i⌒――⌒i　　　　　　￣　| ＿_
]　┃　　　/＞　　 ＜　　２ｃｈ Ａｉｒｌｉｎｅｓ　（・∀・　） (･x･)ﾉ　（，’ー’） （´（Å__）｀ ）　／￣￣￣￣￣／
　 ┃　 ／　　 　 　 　 _ 　　　　 　 　 _　　（　 　 　） ノ|x| ＿（　Ｕ__Ｕ） /ヽ ／ /_ノ ヽ ￣￣￣　／￣
]　┃　| ▼　　　　　　|_|・・・・・・・・・・|_|・・・・・・ ・・ |_|・・・・＿・・・・|_|・・・／＿/ |_|((.ｌ_ｌｌ）))　　／
　 ┃　|_人＿　 (-＿-)ヽ(´ー｀)ノ／￣￣￣￣￣￣￣￣￣／￣￣￣￣￣　／ （ｌロ-ロｌ) ／
]　┃　 ＼　　　(∩∩)（＿＿＿）＼＝＝　 ／￣￣￣ ／||￣|￣|＼／￣￣　　　ヽ ∀ノ／
　 ┃　　　￣￣￣￣￣￣￣￣￣￣￣￣||￣|￣|＼／￣||　 |　 |　 | ￣￣￣￣￣￣￣
]　┃　　　　　　　　　　　　　　　　　　　 　||　 |　 |　｜ 　 ||　 |＿|／
　 ┃　　　　　　　　　　　　　　　　　　　 　||　 |＿|／　　　￣￣
]　┃　　　　　　　 　 　 　 　 　 　 　 　

参照を使った戻り値について質問なんですが
int &f(){return value;}
という関数があるとして、
f()=5;
という使い方できる事以外では
int f(){return value;}
と同じでしょうか?

　　 ||
　∧||Λ
（ / ⌒ヽ
　| |>ALL|
　∪ / ﾉ
　 | ｜|
　 ∪∪

　　　　　　　　　　正直、スマンカッタ！！
　　　　　＼＼　 正直、スマンカッタ！！　／／
　+　　　+　＼＼　正直、スマンカッタ！！／+
　　　　　.　　 ＿＿＿　.　 ＿＿＿　　. ＿＿＿　　　+
　　　 　　　 /. ――┤　 /. ――┤ . /. ――┤+
　　　　　　./(. 　= ,= |　./(. 　= ,= |　./(. 　= ,= |
　+　　.　　|||＼┏┓∩|||＼ ┏┓∩|||＼┏┓/　　+
　　　（(　　（つ　　　ノ 　（つ　　 丿 （つ　　　つ　)）
　　　 　　　ヽ　 （　ﾉ　　 （　ヽ ノ　　　）　 ） 　）
　　　 　　　（＿）し　　　 し（＿）　　 （＿_）＿_）

参照を使った戻り値について質問なんですが
int &f(){return value;}
という関数があるとして、
f()=5;
という使い方できる事以外では
int f(){return value;}
と同じでしょうか?

(先ほどの人、コメントありがとうございます。それではここで。)
最近linuxでC++を始めたんですが、関数一覧表、みたいなものはネット上にどこかないんですか? GNUのGCCを使っていますが。GNUのぺーじには、一覧表、みたいなものは見つけられませんでした。
perlとかphpとかだと、日本語のページでけっこう簡単に見つかって参考にしているんですが、C++はどうにも見つかりません・・・。
みなさんはある機能を使いたいと思った時、どのようにして調べるのでしょうか? 参考までに教えて下さい。

システムコールは載ってないけどね
http://www.microsoft.com/japan/developer/library/vclang/vclanghm.htm

>>453
いいえ違います、同じではありません

言語機能やSTLについて調べたいときは、
VC++やBCBのオンラインマニュアルを参照してます。
ＯＳやライブラリの機能については、
それらのマニュアルを調べます。
あとはサンプルプログラムをgrepするとか。

>>453
戻り値に参照を返すのは鬼門。
EffectiveC++第２版の３１項を参照。

>>404

void foo()
{
　　auto_ptr<int> p1(new int);
　　auto_ptr<int> p2(new int);

　　// do something
}

こうすれば例外が出てもリークしません。
p2の確保に失敗したときですら、p1だけがうまくデストラクトされます。
auto_ptrを使え、ということではなく、自動変数（スコープ）をうまく使えということです。
vectorやlistを使ってもいいし、何かのクラスのメンバになっていてもいい。
要はdeleteが無ければいい。deleteをまき散らしているやつはまだ厨房。

>>459
404 は、それを知ってて敢えて *ダメなサンプル* として、あのコードを出ただ
けだと思うが。More Effective C++ の項目９が、そのものスバリだし。

> deleteをまき散らしているやつはまだ厨房。
同意

正直、すまんかった。

void foo()
{
　　int* p1 = NULL;
　　int* p2 = NULL;

　　try {
　　　　p1 = new int;
　　　　p2 = new int;

　　　　// do domething
　　}
　　catch (...) {
　　　delete p2;
　　　delete p1;
　　　throw;
　　}
}

それじゃ、うまくいった場合にメモリリークだ。(笑)

以上、はまるパターンのサンプルでした。(てへっ)

>>450
まあ大体はそれでいいと思うが、アセンブラだと

; int& f();
mov eax,offset value
ret

; int f();
mov eax,[value]
ret

という感じだと思われるから、その後のアクセスなど考えると前者が軽いかもしれん。
要は、戻り値がintでなくint&だから、一般的実装ではポインタ的に動きそうだと。
でもインライン化されるなら話は全く変わる。

どっちにしても、個人的にint& f();みたいな関数を書きたい局面は滅多に無いと思う。
でもMyClass& f();みたいにクラスを返すなら話は全く変わるし、頻繁に使ってる。

つーか組込型への参照を返す場面ってほとんど無いんじゃ。
クラスメンバアクセサとかなら、半端な隠蔽せんで読みと書きに個別の関数作るしな。

>>458
いや、どう見ても自動変数じゃないから鬼門ではなかろ。
int& f() { int value; return value; }
なら即自滅だが。

>>464
自動変数じゃなかったとしても、EffectiveC++２９項、３０項に引っかかる。
C++とオブジェクト指向を両方とも深く知った人が理由あって使うならともかく、
普通は使用禁止と考えたほうがいい。

ＶＢで作ったＤＬＬをＶＣで呼び出す必要が出てきたのですが、ＶＢ側で

Public Function Show(XXXX as Collection)

となっている場合、ＶＣ側での引数はどうすればよろしいのでしょうか？

LPDISPATCH aaa;
XXXDLL->Show( &aaa ) ;

だと、ビルドは通っても、実行時に
「ハンドルされていない例外はXXX.EXEにあります。0x0000005:Access Violation」
となってしまうのですが・・・。
BSTRのときのSysAllocStringみたいに、何かしてあげないといけないのでしょうか？

C++でコンストラクタ中のエラーを例外投げずに通知するには一般にどうやってるの？
とりあえずコンストラクトは成功させて後でGetLastError()メソッドでエラーチェックさせるとか？

>>467
「一般には」例外を投げる。

どうしても例外を投げたくなければ、オブジェクトのコンストラクトと初期化用の
メソッドを分離して、後者の戻り値で判断させるのが手だと思うが。グローバル
なデータ領域を使って成／否を記録しておくのは、ネストできなくなるから、や
めたほうがいい。

CFoo foo;
if (!foo.Init(...)) {
　　// 初期化失敗
}

これって合法？
class Foo{
public:
　static void foo(char *message)
　{
　　puts(message);
　}
};

void (*bar)(char *message);

int main(int argc, char* argv[])
{
　Foo::foo("xxx");
　bar = Foo::foo;

　bar("yyy");
　return 0;
}

実行結果
xxx
yyy

#include <string>
#include <stdio>
#include <stdlib>
using namespace std;
class IBar
{
　public:
　　virtual void Write(const string &message) = 0;
};

class Foo : public IBar {
public:
　virtual void Write(const string &message)
　{
　　puts(message.c_str());
　}
};

int main(int argc, char* argv[])
{
　Foo foo;
　foo.Write("xxx");

　IBar *bar = &foo;
　bar->Write("yyy");
　return EXIT_SUCCESS;
}

typedefって使う意味あるんですか？

>>471
typedefの役割と意味を調べれば自明。

実際にそういう使い方して役に立った？

>>471
とりあえず林晴比古本でも見るよろし

インスタンスが無いと、メンバ関数って呼べない・・・

>470
駄目なんです。
コールバックを登録するCのライブラリの
ラッパーを作っていてその部分を隠蔽したいのです。

まあstaticメソッドを普通の関数としてクラスの外に
追い出してしまえばいいのですが、もし合法なら
staticでやりたいなということです。

>>476

そーゆーことなら469のまんまでも問題ないっしょ。

つまり469でのbarが実際にＣで叩かれるアドレスなのねぇ。

関数ポインタとstaticメソッドの代入互換ってどこで説明されてる？

うむ、Ｃ言語のライブラリの都合なら仕方があるまい。

>>478
いろいろなところで言われていると思うが……。
こういうケースでstaticメソッドを使うのは常套手段でしょう。
ポインタを１つ渡せる場合は、thisを渡すとかいうのも。

class Foo{
private:
　static void foo(void *p) {
　　Foo *t = reinterpret_cast<Foo *>(p);
　　t->Write();
　}
　int hdl;
public:
　virtual void Write() { puts(msg); }
　Foo() {
　　hdl = set_callback(foo, this);
　}
　~Foo() {
　　remove_callback(hdl);
　}
};

static void* hInstance

class Foo
{
public:
Foo(){
hInstance = this;
}
static void foo(char* message){
typedef void (Foo::*CallbackProc)(char*);
Foo* pObj = (Foo*)hInstance;
CallbackProc pProc = &Foo::Write;

(pObj->*pProc)(message);
}
protected:
virtual void Write(char* message){
puts(message);
}
};

参照型を返す関数ってどんな使い方があるのですか？
やはり
func(0) = 1;　　//funcの戻り値は参照型
といった感じですか？

x = func(0);
という使い方なら別に参照型を返さなくてもいいのですよね？
でも
int& a = func(0);
とすればちょっとは意味あるのかな？

とまぁいろいろ悩んでいるのですが・・・。

class A {
　　・・・
　　string m_Name;
　　const string& getName() {
　　　return m_Name;
　　}
}

みたいにconst参照を返すのはよく使う、俺は。
というか、返値として使う場面はそれ以外にないな。

>>482
それって呼び出し側はどういった使い方になるんですか？
ただのconst string型を返すのではダメなんすか？

>>483
それだと、インスタンスのコピーが発生するからコストがかさむ。

return this　の時はたいてい参照で返すＹＯ！

で・・・、そのconst string&型を返す関数をどうやって使うのですか？
関数呼び出しを左辺にするのですか？
それとも戻り値を何かに代入するのですか？
結局参照を返すのはコスト削減のためだけなのですか？

>>486
従来の C 言語の経験があるなら、ポインタを返すタイミングで参照を返す（こともある）
で分かると思うが。理由は、主に次の二つ。

- 右辺値としてアクセスしたい場合に、オブジェクトをコピーするコストを削減する
- コピーではなく、実体にアクセスしたい場合に使う

もし分からないなら、少し実際のプログラム読んだほうが良いと思われ。

>>481
参照を返す関数といえば、これ

ostream& operator<<(ostream& os, 〜);

仮想関数＋テンプレート
の関数の実行効率が異常に悪いのですが、心当たりあります？

>>489
それ自体がそれほどパフォーマンスを落とすことはないと思われ。別な原因でわ？

>>489
とりあえず、お約束ということで。
プロファイルはとりましたか？

>>491 いやとっていません。みても何がなんだかさっぱりで。

>>483
コピーに伴うコストが高くつく

>>492
それだと、ほんとにボトルネックが「仮想関数 + テンプレート」にあるのかどうか
分からん気がするが。

すみません。以下のようなプログラムで継承元のクラスＢの仮想関数を
オーバーライドするにはどうしたら良いでしょうか？
昨日から考えているのですがコンパイルエラーの連続で．．．
よければどうかお助け下さい

class A { public: virtual void method(void); }
class B : public A { ... };
class C : public A, public B {
　virtual void Cmethod(void);
　// ここで B の仮想関数 method をオーバーライドして
　// Cmethod()を使いたいのですが、書き方が分からないです。
};

void C::B::method(void) { Cmethod(); } // これはダメみたいです

なにしたいんだかわかんないけど

void C::Cmethod() {
// 必要ならなんか
B::method();
// さらに必要ならなんか
}

たぶんもっと基本的なことちゃんと勉強した方が良いと思われ。

>>495
クラス階層が明らかに変だけど。クラス C で B だけでなく A も直接継承している
のは何故？

あと「クラスＢの仮想関数をオーバーライド」という意味が良く分からんのだけど、
もしかして

C* p;
static_cast<A*>(p)->method();
static_cast<B*>(p)->method();

それぞれで、別の処理を行うことを想定してます？

>>496,497氏
レスありがとうございます。

ほんと構造が変です。こんな変な構造になったのは．．．
基底クラスのデストラクタでファイルの後始末処理をしているのですが
基底のデストラクタでは派生クラスの仮想関数はすでに使えないので
（ファイルの操作はこれに頼っているので、困ってしまいます）
派生クラスで書かないといけないですよね？
でも、この派生クラスをさらに派生すると．．．？

延々と続く問題になってしまいまして、それを解決しようとしたのが
クラスＡで、派生クラスの後始末側にＡの仮想関数を呼び出すようにして
Ａの仮想関数で後始末をできるようにしました。

ＣのＡはＣを面倒みて、ＢのＡはＢを面倒みるような形にすると
こんな問題がでてしまいました。
さらに、呼び出すにもＣのＡなのか、ＢのＡなのか明確にしないと
いけないです。さらにまずいです。

まったくもって勉強不足を痛感しております。
このような問題はどう解決したらいいのでしょうか．．．。

>>498
> 基底クラスのデストラクタでファイルの後始末処理をしているのですが
> 基底のデストラクタでは派生クラスの仮想関数はすでに使えないので
> （ファイルの操作はこれに頼っているので、困ってしまいます）
この段階で設計が間違ってるなぁ。

これだけだと何とも言えんから、各クラスの処理の概要とファイルの後始末
に関して、少し詳しく書いたほうがいいと思う。

お世話になっております。説明が少し下手ですが宜しくお願いします。(ぺこり)

概要はこんな感じです。
重要でない細かい部分は端折らせていただきますね。

class AbstructFile {
public: Open() = 0, Close() = 0, Read() = 0, Write() = 0; // 純粋仮想メソッドです
public: ~AbstructFile() { Close(); }
　// 閉じ忘れ防止にデストラクタでファイルを閉じる処理はしておきたいです
}

AbstructFile は多種に派生してその一種に AbstructFile2 があります。
これもデストラクタで閉じたいのですが基底のデストラクタの Close(); は
邪魔になります。それをどうにか解決しても、AbstructFile2 から派生した
AbstructFile3 でさらに AbstructFile2 のデストラクタ処理が邪魔になりました。

正しい設計にするにはどうしたら良いのでしょうか．．．。

>>500
~AbstructFile() で純粋仮想なはずの Close() を呼んでおりますが
そこは何やら仕掛けで派生の Close() が呼ばれるようになっています。
本質はそこではないので省略いたします．．．

蛇足です。(^^;
一見、最も派生した AbstructFile のデストラクタでやればと思うのですが
さらに派生したとき、問題に．．．ということなので．．．

>>498
> class A
> class B : public A
> class C : public A, public B

こういう継承は出来ないんでは？

(1) 基底クラスのデストラクタでファイルの後始末処理をする
(2) 基底クラスのデストラクタから派生クラスの関数を呼びたい

ってことだろう。しかし (2) ってことは、実際にファイルの後始末を処理するのは、基本クラスでなくて派生クラスなのか？それなら単に派生クラスのデストラクタで後始末処理をすれば良いと思うが。どうでせう。

>>502
さらに派生したときに新しい処理が加わるなら、派生デストラクタで新しい処理だけやれば良いのでは？

>>500
私ならインターフェースの継承と実装の継承を分離するかなぁ。

struct FileBase
{
　　virtual Open() = 0;
　　virtual Close() = 0;
　　virtual Read() = 0;
　　virtual Write() = 0;
　　virtual ~FileBase() {}
};

struct FileA : public FileBase
{
　　virtual Seek() = 0;
};

struct FileB : public FileBase
{
　　virutal Undo() = 0;
};

たとえば、こんな感じでまずインターフェースの階層を作っておく。実装はコンストラクタと
仮想デストラクタ以外は一切無しね。次に、これを継承して実装を作る。

struct FileAImp : public FileA
{
　　Open();
　　Close();
　　...
　　~FileAImp() { Close(); }
};

struct FileBImp : public FileB
{
　　Open();
　　Close();
　　..
　　~FileBImp() { Close(); }
};

実装を継承したい場合には、どこかで Close() を書くわけだよね。もし末端のクラスではなく、
途中のクラスで Close() を書いたのなら

- Close() をその先のクラスでオーバーライドしないことに「決め」て、途中のクラスのデストラ
　クタで Close() する
- 途中に挟んだクラスのデストラクタでは Close() せずに必ず末端のクラスでのみ Close() する
　（ついでに途中に挟んだクラスのデストラクタを protected にして、直接はコンストラクトできない
　ように細工）

どちらか好きなほうを選択。どちらにしても、ドキュメントを書いておく。

>500
> 閉じ忘れ防止にデストラクタでファイルを閉じる処理はしておきたいです

これを基本クラスでなく派生クラスのデストラクタでやれば済むんでは？

皆さんありがとうございます。500です。

>>503,504,506氏
はい。それで解決です。(^^;
でも、これで解決しても、派生をさらに派生すると Close() はまた、
その派生先に入れる必要がありますよね・・・
こうなると延々といれる作業を繰り返すわけで・・・
このあたりスマートに処理したいのですが・・・。

>>505
ありがとうございます。
Javaでいうfinallyを決めてしまうのでしょうか。(間違っていたらすみません)
最終の派生クラスを定義できればいいのですが
できればさらに派生させたい場合もあるかもしれないので．．．

仮想関数のようなデストラクタもどきがあればいいのですが・・・

各クラスごとでクローズの仕方が違うんですか？
つまり、AbstructFileの閉じ方とAbstructFile2の閉じ方は違うんですか？
もし違うなら継承にする意味がないような？

あとどうでもいいけど、正しいつづりはabstr「a」ctな。

>>507
> できればさらに派生させたい場合もあるかもしれないので．．．
汎用的なクラスライブラリを作っているのなら別ですが、そうでなければクラス階層は
設計段階ですべて見えてると思います。そうでなければ、まだ設計の煮詰め方が甘い。

それと上のほうでも書きましたが、インターフェースの階層だけ決めておいて、実装継
承はとりあえず忘れる（コードを共有しようとしない）方が良いと思います。実装継承は
強力な手法ですが、強力さゆえに使い方を誤ると簡単に泥沼に入りますから。

皆さんのご意見と設計を熟読いたしました。
やはり私の設計が全面的に間違っていますね。設計才能の無さを痛感しております。
勉強してもう少しまともな設計ができるようにしたいと思います。
皆さまありがとうございました。

>>508,509氏
>あとどうでもいいけど、正しいつづりはabstr「a」ctな。

>設計段階ですべて見えてると思います。そうでなければ、まだ設計の煮詰め方が甘い。

その通りです。(^^;

>それと上のほうでも書きましたが、インターフェースの階層だけ決めておいて、実装継
>承はとりあえず忘れる（コードを共有しようとしない）方が良いと思います。実装継承は
>強力な手法ですが、強力さゆえに使い方を誤ると簡単に泥沼に入りますから。

はい。はまってしまいました。
仰る事を心がけてがんばってみます。

ヌルポインターって作れないんでしょうか？

すみません、この板来るの初めてで、違うスレに書いてしまいました

C++の問題です、なにぶん初心者でして
参考になる本などあれば教えて頂きたいです・・・。

1.二つの数をインプットしそれをx,yの読み込んで
和差積商を計算するプログラム

2.１つの数をインプットし読み込んで
その数の二乗、三乗を計算するプログラム

>>513
宿題はこっちで聞け。

お兄ちゃんの宿題、私が答えるよ
http://piza2.2ch.net/test/read.cgi?bbs=tech&key=982853418

>>512
ヌルポインターを「作る」とは何？？

void* p=(void*)NULL;
終了。

classへのポインタってありますか？

class A{};
A* a;
終了。

>>518 それはオブジェクトへのポインタ
クラスへのポインタではありません

>>517
こういう感じのコードを書きたいのかな？

class A;
class_ptr X = A;
X* p = new X();
// 擬似コードなんで、コンパイル通りません。悪しからず。

C++ ではクラス自体を指す変数は定義できません。ただし template クラス／メソッドの
引数としてクラス名を渡すことは可能です。

>>520そういうことっす。ネタでした。

ネタとはいえ先ほどは非常に簡潔でいいレスをいただきありがとうございました。
御礼にもう１題
templateメソッドって可能ですか？（template関数ではない）

>>522
無理。

コンストラクタを書けない。
継承ができない。
明示的な呼び出しができない。

その前にインスタンスを作れない。

>>523 ありがとうございました。疑問は晴れました成仏します。
逝ってきまーす

>>517

これが「クラスを指すポインタ」に一番近いかな
type_info* p = typeof(class A);

>>522
テンプレートメンバ関数って意味なら、可能です。

class A{
　　template<typename T> void f(T);
};

>>525
間違えた。鬱だ・・・

const type_info* p = typeid(class A);

>>527

さらに間違い。逝ってきま・・。

const type_info& p = typeid(class A);

>>525 うを〜そんな手が〜あったか〜。早速やってみよ〜。
でっきるかなでっきるかな〜さてさてほほ〜。

>>526 >>528 できました〜。ありがとうございました〜迷わず成仏できます。

>>void* p=(void*)NULL;
この場合NULLは
stdio.hのマクロ定義かなんかじゃないんですか？
void* p=(void*)0;
とか
int* p=(int*)0;
これでいいのでしょうか？

テンプレートってヘッダファイルに書くの？
どこに書いたらいいのかよくわからん。

>>530
C++ の type_info は、そこからメソッド一覧を取得したりインスタンスを作ったり
できないので、あまり実用性は無いですけどね。

>>531
単に
void* p = 0;
とか
int* p = 0;
で善し

>>532
使う場所から見えるところ。一般的にヘッダに書く。

>>533
同意。何のためにあるのかさっぱりですな。
誰か有効な利用法プリーズ

>>536
ダウンキャストする時に使ってたんじゃない？
その昔は。

>>533
C++はObjectを作る方法として、ポインタにnew使う奴と、変数埋めこみで直接作る奴とが有るが、
C++が痛いのは、その両方に対して使える機構しか、提示しない、ということだな。

メタクラスの方向性を否定してるんで、「つみかさねる」ようなプログラミングを
ちまちま手作業で書かないとならないんで、辛い。

>>538
すまん。日本語が難しすぎてよく分からんので、もうすこし C++ プログラマに
わかりそうな言葉でしゃべってもらえると、ありがたい。

>>535
ヘッダにソース書くのやだなー。
って思う人はどうしてるの？

>>540
ヘッダに宣言だけ書いて *.cpp ファイルに実装書くこともできますよ。
でもヘッダに書くのが主流。

>>541
そうなんだ。ありがとうございます。
思い切ってヘッダに書いてみます。

昔はよく、「ヘッダにコードを書くな」って怒られたものです。
（それはインクルードするだけで実体化するからですけど〜。）

>>540
昔、ミカカ子会社提供のミドルウェアの一部であるテンプレート
ライブラリ（ヘッダに実装かいてあった）に間抜けなバグがある
のを発見した事がある。

ソース完全公開状態だからな。恥さらしだと思った。
（問題は、そこがバグっているとそもそもそのライブラリが
役立たずなものになるという致命的なものだったのだが、誰が
どう試験していたんだろうか…）

>>542
ヘッダに書いても、使わない template クラス／関数に対してはコードが生成
されませんから、気にしなくて大丈夫です。

>>536
typeidバトラー

#include <iostream>
#include <typeinfo>
#include <stdlib.h>
struct Player {
　int getPower() { srand((int)&typeid(*this)); return rand(); };
　const char *getName() { return typeid(*this).name(); };
　virtual char* say() = 0;
　static Player& battle(Player& a, Player& b) {
　　int ap = a.getPower();
　　int bp = b.getPower();
　　cout << a.getName() << " power : " << ap << endl;
　　cout << b.getName() << " power : " << bp << endl;
　　Player& winner = (ap > bp) ? a : b;
　　cout << "..." << winner.getName() << " win." << endl;
　　cout << "『" << winner.say() << " 』" << endl;
　　return a;
　};
};
struct Monar : Player {
　char* say() { return "モナー"; };
};
struct Giko : Player {
　char* say() { return "ゴルァ"; };
};
int main() {
　Monar m;
　Giko g;
　Player::battle(m, g);
}

>>545
どうさ保証なし。実行例。

>gcc -v
Reading specs from /usr/lib/gcc-lib/i686-pc-cygwin/2.95.3-5/specs
gcc version 2.95.3-5 (cygwin special)
>a.exe
5Monar power : 621329674
4Giko power : 707264478
...4Giko win.
『ゴルァ 』

>>545
やべーﾜﾗﾀ。

すいません、C++の、ポインタとかクラスとかSTL」とかはぜんぶやったんですが、enumだけ覚えずにここまできてしまいました。
enumってなんでしょう。

>>548
const や #define に代わる、定数宣言の最適な手段です（整数に限る）

例：
enum N_{
　N = 32
};

enum(enumerate: イニューメレイト)ってのは、文字どおり「列挙型」です。
大抵の言語に備わっています。

たとえば
#define ONE 1
#define TWO 2
#define THREE 3
#define NINE 9
#define TEN 10
は
enum 《ここで列挙型の名前を定義できる》{
ONE,
TWO,
THREE,
NINE = 9,
TEN
};
と書けます。

違いは、ONE/TWO/…などが #define だとプリプロセッサで展開される(コンパイラには見えない)のに対して、
enum だとそれらを識別子としてコンパイラが認識する…ってことかな。

これはコンパイラが型チェックできることを意味しています。
型チェックの結果は C と C++ で違います。
たとえば、どちらの場合も変数の型は int 類になるけど、
#define だとそこに定義されていない値を入れても、
コンパイラは「あれっ?」とも思いません。

でも enum だとコンパイラがそれを型として認識できるので、
これが C++ だと、明示的に型キャストしない限り、
コンパイラが「あれっ?」と思ってくれます。

>>550
enum は 0 からじゃ…。

enum型変数ってどうやって書くの？

基本
enum {...} x;

一般的
typedef enum {...} type;
type x;

>>551
値入れても良いんだよ。

>>554
いや、>>551は、それじゃあONEが０になってるってつっこんでるんだよ。

>>551
あっ、…。(鬱氏)
>>552
C なら
enum type {...};
enum type x;

C++ ならそれ以外に
enum type {...};
type x;
とも書ける。

(今度こそ!)

>>556
そういや、構造体と同じで普通に名前付けられるのだったね…。

boolが仕様に入るまではこうしてた
typedef enum{
false=0;
true=1;
} bool;

セミコロンじゃなくてカンマだっけ

汎用性のある参照カウンタ付きのクラスを継承して使いたいのですが、
自作したほうがいいですか？
それとも既にライブラリが存在し、それ使った方がいいですか？

C++で動的配列を作りたいのですが、new [ ] で作成した配列
のサイズをあとで変更するにはどうすればいいですか？

int *a = new int[100]; /* とりあえず100確保 */

...途中でサイズを50にしたい

delete a[ ];

STLのVector使え。

　　　　　　　　
>>561
realloc

>>563
newしたやつにreallocするのは止めろ。
ビットコピーされたらどうするつもりだ？

>>563 バカ？
素直にmalloc使えよ

s/>>563/>>564/

>>561
#include <vector>

void foo(void)
{
　vector<int> a(100);
　a.resize(50);
　//delete不要
}

eMbedded Visual C++ なので、STL 使えないのです…
realloc 使うことにします。

>>561
小さくするだけなら、そのままにしとけ。

VCスレに行った方がいいかもね。
STLportとか、つかえねーのかな。

おはようございますよろしくお願いします。

えーっと、ＡＰＩでまずは自分用のテキストエディタを
作成しようと思っているところです。

今はメモ帳がエディタ代わりです。
検索をいちいちダイアログで出すのは面倒なので、
まずデフォルトで検索窓の付いたものを作ります。

当初CreateWindowまたはExで（検索入力用の）エディットボックスを作り、
貼り付けて・・・と構想していました。すると、多分カーソルの
位置とか反転、カーソルの移動・・とかいちいち構造体を調べて・・
と、なにかと面倒そうだ、と思っていましたところ、FindTextと
ReplaceTextっていうのを発見しました。多分構造体が設定されていて
その面倒くささをやってくれるんですよね？っていうか、題意がそれてるんです
けど、
FindTextたちを使わず敢えて自前で組むのと、利用するのでは、
計算効率は違うのでしょうか、僅かでも。

貧乏性な上に、メモリ不足でカリカリいうといつもびくびくしてしまう
性分なので、メモリを食わない路線で処理の最適化を徹底したいと思っとります。
おしえてクダサイ。

ねえ、new使うときって
int *a=new int;
より
auto_ptr<int> a;
a=new int;
のほうがいいの？

>>571
２行目まで読んだ。
フリーのテキストエディタを探してきて使え。
そしてプログラム書くの止めるか、本買って勉強しなおせ。

>>572
別にいいってことはない。
auto_ptrを使った変数などを関数に渡すときに
どういう動作するか考えるとうかつに使うのは
止めた方がいい。

auto_ptrの使い方としては、例外処理が起こって
途中でリターンしなくてはいけなかったりするときに、
開放の処理をやるのが困難な場合など。
あと、一般的にはコレクション系かしら。

ダメ雄に言われたくない>>573

自分で書くんだったら、良く書けば効率は良くなるし、
クソに書けばクソになる。
既存APIは中がどうなってるのか知らんから一概に比較はできんが、
いいアルゴリズムで書けるなら書いてもいいんじゃないの？

>>576は>>571へのレスね。

>>571
ここはC++のスレだぞ。APIについては他所でやれよ。
ついでにいっとけばエディタを作るのにWindowsのEditBox使うのは止めろ。

>>574
コンポジションを使う場合にも、メンバ変数も auto_ptr で持つかな。
直接

struct Foo
{
　　X x;
};

と書いてしまうと、このヘッダをコンパイルするためだけにクラス X のヘッダを
include する必要が出てきてしまうので。

コモンダイアログを使うと、
どのみちHWND型だから使うメモリはCreateWindowと
変わらないだろうけど、代入演算が余計に起こって
処理が最適ではなくなってしまうことを心配している者です。

>578
なじぇ？

>>579
includeしたくないだけにauto_ptr使うか？
そんなこと言ったら
struct Hoge {
auto_ptr<string*> m_str;
}
か？

>>581
EditBoxを使った時点でメモ帳以上の物ができないことが保証されるから。

>>579
Fooの定義の前に
class X;
と書いとくだけで大丈夫だと思うが？

>>584
いや、それじゃだめでしょ。

全然知りません

>583
では何を使えば？

Win98のメモ帳はなぜ大きいファイルを開けないのですか？
エディタソフトハウスから賄賂もらってるから？

>588
char[固定]だからです

>>588
MSDN読め。

>>588
仕様です

>>589
それが真実ならマイクロソフトさんって思ったより知能低いですね
速答ありがとうございます

>>587
自分で作るか他のエディトコンポーネントを探すか

>>582
ヘッダファイルの相互依存関係は、ちょっとソフトウェアの規模が大きくなると
辛いです。一つのヘッダを修正するだけで、ほとんどすべてのソースを再コン
パイルすることになりかねません。

標準ライブラリのヘッダは原則として修正しませんから、さすがにメンバ変数
とはいえ参照やポインタにはしません。

>>584
いや class X の「サイズ」が決まらないと class X をメンバとして持つクラスの
「サイズ」も決まらないので、ダメです。

>593
自分で作るって、どういうことですか？CreateWindowの引数でどうにかできるのですか？

>595
悪い事いわんから開発やめとけ。

>>595
ネタとマジレスの区別も付かない、自分で一切調べないような奴には
一生かかっても無理だ。

>>592
っていうか、「メモ帳」だぞ。
そんなおっきいファイル開く方が間違ってるYO。
エディタじゃねーよ。メモって意味考えろ。

CEditView（ファイルサイズ６４Ｋまで）かCRichEditViewつかいませう。
CRichEditViewで挫折したらまた質問下さい。

リッチエディットをエディタに使うバカはいません。

>>600
はあ？ じゃあ何使うっつうの？

６４Ｋ以下ならCEditView,６４Ｋ以上ならCRichEditView。
これ常識。

普通のEDIT→メモ帳
リッチエディット→ワードパッド

になるぞ？

っていうか本気で作るんだったら、
MFCのクラスなんか使わないでしょ。普通。

でも、元ねたが「メモ帳のかわり」とか言ってるから、
りっちえでぃっとでいいんじゃないかい？

良く判らんが、単独で使いたいんじゃなくて、プログラムに
組みこむ形で使いたいんなら>>602で合ってる。

>>605
俺もそう思う。胴衣

＞っていうか本気で作るんだったら
＞MFCのクラスなんか使わないでしょ。普通。

さすがにそれは普通じゃないと思われ。

＞＞６０４
MFC使わないやつは
1 完全にオリジナルのUIを構築するやつ（移植性とかなんとか
2 アンチMFC
3 MFCが分からないやつ

で、比率で言えば、1:10:89こんなものかな

>>608
604は「エディタのビューとして」の話だと思う所存。
エディタのビューとしてCEditやCRitchEditを使う奴はDQNだと思うナリよ

MFC相談室になっているゆえ、Qt使えとか言ってみる。

.>>609 MVCの話なら歓迎〜。

メーラーとかの編集窓でRicheditは多いと思うが

Win2000ならメモ帳のサイズ制限はないよ。

>>611
俺の知る限りはAL-Mailぐらいだな。

>>611
メーラーなんかプレーンテキストで十分だ。
よってCEditで十分だと思うが、どうか？

>>608
禿同。

ruby撲滅スレ
http://piza2.2ch.net/test/read.cgi?bbs=tech&key=1001125342
ruby撲滅スレ
http://piza2.2ch.net/test/read.cgi?bbs=tech&key=1001125342
ruby撲滅スレ
http://piza2.2ch.net/test/read.cgi?bbs=tech&key=1001125342
ruby撲滅スレ
http://piza2.2ch.net/test/read.cgi?bbs=tech&key=1001125342
ruby撲滅スレ
http://piza2.2ch.net/test/read.cgi?bbs=tech&key=1001125342
ruby撲滅スレ
http://piza2.2ch.net/test/read.cgi?bbs=tech&key=1001125342
ruby撲滅スレ
http://piza2.2ch.net/test/read.cgi?bbs=tech&key=1001125342
ruby撲滅スレ
http://piza2.2ch.net/test/read.cgi?bbs=tech&key=1001125342
ruby撲滅スレ
http://piza2.2ch.net/test/read.cgi?bbs=tech&key=1001125342
ruby撲滅スレ
http://piza2.2ch.net/test/read.cgi?bbs=tech&key=1001125342
ruby撲滅スレ
http://piza2.2ch.net/test/read.cgi?bbs=tech&key=1001125342
ruby撲滅スレ
http://piza2.2ch.net/test/read.cgi?bbs=tech&key=1001125342
ruby撲滅スレ
http://piza2.2ch.net/test/read.cgi?bbs=tech&key=1001125342
ruby撲滅スレ
http://piza2.2ch.net/test/read.cgi?bbs=tech&key=1001125342
ruby撲滅スレ
http://piza2.2ch.net/test/read.cgi?bbs=tech&key=1001125342
ruby撲滅スレ
http://piza2.2ch.net/test/read.cgi?bbs=tech&key=1001125342
ruby撲滅スレ
http://piza2.2ch.net/test/read.cgi?bbs=tech&key=1001125342
ruby撲滅スレ
http://piza2.2ch.net/test/read.cgi?bbs=tech&key=1001125342

RichEditなんて遅くて重いの使ってられるかよ。
つーかエディタを作るってのはエディトコントロールを自分で作るって事じゃないの？
そこがエディタの命なんだからさ。
秀丸がリッチエディット使ってたら誰も買わないだろ。

すいません、vector< vector<int> > a;で、
stringのc_str()みたいに配列全体を得たいのですが、どのメソッドを使えばよいのでしょう。

vector<>::begin

>618
ありがとうございました。

>>616
エディタだけ組みこんだソフトなんか誰が作るかよ　阿呆。

>>612
こいつも阿呆だな。

>>621 氏ね。
>>612 は正しい。

>>620
いや、エディタの話をしてたんじゃないのか？

>>622　ソフトウエア版行けや。
ライブラリではCEditViewのサイズはshortで定義されてるから駄目。
ＷＩＮ２０００のメモ帖とか言ってるのはＰＣ厨房。

>>624
帖って間違ってるYO

VC++で
int a[100];
b=99;
cout<<a[b++];
ってやると､エラーになります？

>>626
試したら？

いいね

何でエラーになるんだ？？

勘違いでした

/*
if(typeid(*temp)==typeid(A)){
((A*)temp)->methodA();
}else if(typeid(*temp)==typeid(B)){
((B*)temp)->methodB();
}
*/
pa = dynamic_cast<A *> (temp);
if(pa){
pa ->methodA();}
else{

pb= dynamic_cast<B *> (temp);
if(pb){
pb->methodB();
}else{
}
}

すいませんが
RTTIがよくわかりません
これで実行しても、実行中にエラーになってしまいます

VC++ってRTTI使えなみたいです
サンプルプログラムも実行時エラーがでます

>>624

MFCはそうだろうが、NT系のエディットコントロールにサイズ制限がないのは常識だろ？

＞632
＞633
プロジェクト-->設定-->Ｃ/Ｃ++Ｔａｂ-->カテゴリ：Ｃ++言語-->ＲＴＴＩを有効にする
をチェック済みかい？

もしかしたらPro 以上じゃないと駄目かも。

>>635
できましたー（涙）
ありがとうございます
とりあえず､私はProを使ってますから
standardの方ではちょっとわかりませんが・・・
はまりますねコレは
ホントに助かりました

>>624
勝手にＭＦＣと決めつけるなよ。

dynamic cast も RTTI 必要ですか？ >VC

>>638
いぇす

>>639
ありがとうございます
# gcc はデフォルトでオンだったような

aString == bString （in Java）

は　Deep comparison ですか？
それとも　Shallow Comparison ですか？

分かる人教えて・・・

あ、Ｃ＋＋のスレだった。間違えました、鬱だ。
でも、分かる人いたら教えてください。悩んでるんです。

>>641-642 悩んでる時間があるなら、
ちょろっとコード書いて自分で試せば？

>>643
どうやって試すの？

たった2時間しか考えないで他人に聞くなよ。
頭は帽子を置く台じゃないんだから。

頭はかつらをかぶせる台じゃないんだから。

つーか､ポインタもわからないのに
Deep comparisonみたいな単語だけは知ってる
Javaはホントはすごいんだけど、馬鹿が使うから馬鹿にされるんだって

C言語よりエレガントにバイナリーエディターを作れますか？

>>648
Ｃ言語でエレガントに作れるものなんかあるのかよ。
エレガントだと思いこんでいる連中はいるようだが…。

>>647
相談スレだから、書いてみたんだけど・・・やっぱ
ダメだった？？

＝　がShallowって言うのは分かるんだけど、
＝＝　がDeepなのかShallowなのか分からない・・

ＪＡＶＡスレがありました。ごめんなさい。

C++のポインタを使った表記が醜いので
# foo->bar.bazとか
可能な限り参照を使ってみたいのですが
# foo.bar.bazみたいに
何か問題ありますか？

使えば？

>>652
とりあえずリンクトリストでスタック作ってみそ

>>652
問題ないよ。

ただ . 演算子が4つくらい並んでいたら、
こいつ大丈夫か？と疑いはじめるだろう。

>>652
参照にしたところで、醜いもんは醜いんだよ。
設計がおかしいんじゃねぇの？

>>654
stack<CFoo> s;
s.push(CFoo(1));
s.push(CFoo(2));
s.top().bar.baz;

>>657
参照はポインタより制限がきつい。
無制限に使えるポインタでなければ組めないとき、
なぜその制限内に収まらないのか検討する余地がある。
参照すらいらないのにポインタを使う奴もいる。
制限の緩い機能を使うときは、強力であるが故に慎重さが欲しい。

とりあえずポインタより参照を優先するという方法は
それなりに有効だよ。

>>658
STLのstackはデフォルトではリスト使ってないだろうと思い、
ソース読もうとして挫折。
オペレーターオーバーロードされると訳わからん

Javaに還ろ〜っと。

>>659
最初は参照で組む => 後にポインターに変更 => ->を.に置換しまくる。
つーことが良くあります。

>>660
それはスキルが低すぎるからだもー。

->を無条件に"．"に置き換えても
構文的に曖昧になるケースなんてないんだから
全部"．"にしちゃえば良かったのに。
まあﾄﾞｷｭｿ言語だからしゃあねえか>C/C++

>>662
何でそうなってるのか考えてみろよ

>>662
いや、"->"と"."は明らかに違うだろ。
ポインタと実体（もしくは参照）が同じように
見えるんだったらかなり重症だぞ。

たしかにそもそも用途が違いますよね。

参照/ポインタの使い途を定位置を参照することに限った場合、
>>662 のような意見をもつ人がいるようにも思われ。

そうじゃないだろ？ とまぁ、いいたいのですが。

スタック上にあるオブジェクトをdeleteしても大丈夫な
様にする事ってできますか？
(スタックならデストラクタだけ呼び出して、開放はしない)
ヒープに置いてあるやつと区別しないで扱いたいんで。
CObject a;

スタック上の(未初期化の)メモリに対して placement new を使う。

でも、どっちかというと使い方が間違ってると思う。

>>662
その話題、別のスレッドでも出てたな。

C だと . と -> はまとめられるけど、ハードウェアに近い階層のプログラムを組む
場合には、ポインタとスタック上の変数を文法上も区別しておいた方がいいと思う。
演算子をまとめて、バグを入れやすくなったら本末転倒だし（ただでさえバグを作
やすい言語なんだから）。

あと C++ に関しては operator->() がないとスマートポインタ実装できないから嫌
です。

コンパイラ標準のSTLじゃなくて、SGI STLとかSTLport
とか使ってる人いる？マルチプラットフォームなコードで
統一しようかと思ってるんだけど。

SGI STLってなんかコンテナの種類とか増えてるね。
hash_mapとか。

STLportばりばり使ってるよ

>>668
> ポインタとスタック上の変数を

という用語はどうかと思うが、

> 文法上も区別しておいた方がいいと思う。

は同意。char **argvとchar *argv[]を混乱する厨房を見るにつけ

あ、[]のdouble meaningのことね。

STLPort使ってるよ。
バイナリがでかくなるのを除けばVC付属のよりいいんで。

ただ、コンパイラ付属のと切り替えたいときもあるんだけど、
何を#defineすれば良いのかわかんないけど。
だれかしらない？

>>673

同一プロジェクト内だと無理だろ。

別プロジェクトで、ということなら、単にインクルードディレクトリの優先度を変えればできるっしょ。

STLport使ってる人、実際どう？
コンパイルが面倒とか特殊な書き方しないとだめとか
環境によって駄目とかある？

うちはWin, Mac, Linux全部やってるから出来れば
統一したいんだよね。

>>674
ああ、同一プロジェクトでは統一しますが、
コードがでかいと困るときに標準を使いたいんですよ。
ただ、環境変数で一度に設定してるから優先度いじるの面倒なんで。

>>675
コンパイルが面倒も何も、VC/BCCではmake一発でとおります。
BCCは知らないけど、VCのものよりはパフォーマンスが良いです
VC使う上での注意は、必ずマルチスレッドライブラリをリンクする
必要があるということだけかな。

ねぇねぇ、
基底クラスのデストラクタを書いてなくて、
基底クラスでdeleteすると派生クラスの
デストラクタが呼ばれないって知ってた？

>>676
そっか、特に何にもしなくてもmakeでビルドできるのか。それはナイス。

VCでマルチスレッドライブラリリンクしてシングルCPUなマシンで
動かすと若干遅くない？必ずスレッドセーフなライブラリを使わないと
だめだとするとちょっと問題になりそうな気がするが。

Mac、Linuxで使ってる人が居たら状況キボン。

>>677
当たり前だろ。仮想デストラクタにならないんだから

>>679
当たり前だが、初心者がはまりやすい落とし穴ではあるな。

>>677
C++ はいろいろ過去を引きずっている影響で、いたるところに落とし穴がある仕
様になってる。痛い思いをしたくなければ Effective C++, More Effective C++
という書籍を買ってきて読んでおきましょう。

>>678
実際に自分の書いてるコードで置き換えてみて
評価すればよいよ。

>>678
実際に計って速度に問題があればつかわんでいーだろ。

アプリケーション系で応答速度が要求されるような場合、
マルチスレッド化は当たり前のような気がする。

どうしても多重化出来ない場面でかつ、
スループットしか見ないのであれば、微妙な速度差にも
こだわってもいいけどね。

MTスレじゃないからsage

>>681
>>682
ごもっとも。なのでsage

foo->bar->baz = 0
を
using foo->bar
baz = 0
と書けると嬉しくない？

>>684
全然嬉しくない。
入れ子にできないジャン！

>>685
別に常に使わなくてもいいわけだし。
C++Builderでは便利かもね。

>>684
with( foo->bar ){
baz = 0;
}
の方が他の言語で慣れてるので嬉しいかも。

typeof_foo_bar &bar = foo->bar;
bar->baz=0;

このくらいで我慢し説け

>>684
typeof_baz& baz=foo->bar->baz;
baz=0;
できるよ？なんか文句ある？

それだとbaz以外のメンバがいじれなくていやな感じ

>>690
↓で我慢しとけ。この程度の小石につまづいているようではＸ
>>688

メンバ関数用意すれば？
せっかくC++なんだしさ。

メンバ変数にアクセスするインターフェイスをつくるとき、
名前ってどう付けてる？

class Mona {
public:
int giko;

だとして、

・void SetGiko(int);とint GetGiko(void);
・int& Giko(void);

なんかが考えられるけど。

void Giko(int value);
int Giko(void);

後者は
const int& Giko() const;
だろ。Monaがconstになった途端アクセスできなくなるぞ。
それにその方法だと、結局もう一個
int& Giko();
を用意することになる。

>>694
>>695
うん、要するに聞きたいのはSet〜とGet〜っていう命名は良くないのかな
って事なのだ。個人的には悪くないと思うんだけど、オブジェクトとして
考えた時はちょっとおかしいかなと感じるんで。周りには良くないって言う
人も居る。

constに関してはその通りだね。スマソ。

C#なんかの最近の言語ではset/getメソッドを
隠蔽するプロパティという表現が文法に組み込まれていて
とても有用なのでおかしくは無いよ。

ただ、C++では確かに一般的ではないので
コーディング規約としてきっちり確立することが
出来ないのであればやめといたほうがいいかもよ。

規約
名詞＝プロパティ Count()
動詞＝メソッド Clear()

>>697
うん？ちょっと確認なんだけど、漏れが言いたいのは

Get/Setという命名は悪くないがオブジェクトとして見ると
オブジェクトのメソッドとしてGet/Setのような名前がついて
いるのは違和感がある

って事ね。せっかくカプセル化してるのにそのオブジェクトが
どんなメンバ変数を持っているのか外が知らないといけない
のは変だと思うわけ。

で、>>697が「おかしくは無いよ」と言っているのはどっちの表現
方法に対してのこと？それと、最後の規約の部分の文章は

・そのクラスのプロパティに関しては名詞の名前を付ける
　例：Count()
・メソッドに関しては動詞の名前を付ける
　例：Clear()

という読み方であってる？

>せっかくカプセル化してるのにそのオブジェクトが
>どんなメンバ変数を持っているのか外が知らないといけない
>のは変だと思うわけ。
それは命名の良し悪しとは別の問題だよ。
メソッド経由で公開するという意味ではGetGiko()もGiko()も変わらない。

理想は全部privateにして自前で処理することだけど、
そうするとクラスが肥大化したり、メソッドの引数がやたらと
多くなってくる。
# 試しにfriend/get/set一切使わないコードを書いてみるべし
なので変数（=アクセスメソッド）を公開することでコードが
簡潔（というと語弊があるが）になるならそれを避けるべきではないと思う。

おかしくないというのはCount() という表現の事。
他言語からの借用なので積極的に推すつもりは無いけど。

規約の方はその通り。

int **p;

p = new int [x][y];

って間違ってます？

検索しても、出てきませんでした・・・

まじ質問です。

sageてしまった・・・
age

>>700
C++の質問じゃねーだろ。くだらねー質問スレへ逝け。
それにそのコード間違ってる。

>>702
newの使い方なのでC++だと思ったんですが・・・
逝ってきます・・・

>>699
ふむ。結局、Get/Setという文字列がどうこうじゃなくて、
意味的におかしくないならGetやSetが付いた命名もあり
って事なのかな。

全部自前処理が絶対に良いとは言えないのは分かるよ。
設計が悪いと言われそうだけど、friend使わないとどうしても
見通しが悪くなることはあるよね。

規約のほうは参考にしてみる。これはこれで統一されてると
思うから、うまく命名すれば使えると思う。

>>703
newの使い方の問題なのか？それ以前にポインタを復習すれ。

>>705
ってことは、

int **p;

*p = new int* [x];

for( i = 0; i < x; i++ )
    p[i] = new int [y];

ってことですか？

まとめて確保してくれると思ってました・・・

>>706

まちがいっす・・・

>*p = new int* [x];
p = new int* [x];

多次元配列を扱うコンテナをもってきて
array2<int> *p = new array2<int>(x,y);

みたいにしとけば？

stlで近いことが出来た気もする。

>>706

typedef std::vector< std::vector< int > > Aryary;
Aryary p;
p.resize(x);
for( Aryary::iterator it=p.begin(); it!=p.end(); ++it)
　it->resize(y);

>>708
>>710

おお・・なるほど・・・
参考にさせていただきます

ご教授ありがとうございますm(_ _)m

>>709スマソ。操作ミス。

>>706
それでもいいが、newをループさせるよりはこの方がいいだろ。

int **p;

p = new int* [y];
int *x = p[0] = new int* [y*x];
for(int i=1; i<y; i++)
　p[i] = &x[i*x];

これだと配列のもち方が[y][x]になるところに注意。
っていうかこれこそC++に関係ないからsage

つーか本当に任意にサイズの二次元配列確保しなきゃならないのか？
x,yは両方とも変数で無いと駄目？

STLをつかう方法もいいが、速度が要求されるか、
配列が大きいなら>>712の方法にしとけ。

>>712を自分用コンテナにして使い回すのがよさげ

単なるコレクションを返したいのですが、
どのような形で返すのが良いでしょうか？

互いに関連(相手へのポインタ）をもつオブジェクトで
なおかつそのオブジェクト同士の関連の仕方が全くの任意である場合、
その関連の仕方をデータに保存するにはどのような方法があるのでしょうか？

私が思いついたのは、全てのオブジェクトを適当に順序づけて一元に保存し、
その後、その順番を元に関連の有るオブジェクト同士の番号を別途保存する
方法なのですが、所詮素人考え、どうにも二度手間で、泥臭く感じてしまうんです。

よくありそうな処理の割に良い方法が、思いつきません。
なにかスマートな方法があったら教えて下さいませ。

外部シンボル’〜’が未解決っていうエラーがでたらどう解決したらいいんですか？

>>717
説明読んだだけでは何がしたいのか良くわからんけど、
一度「デザインパターン」で検索して勉強してみることを強くお勧めする。
多分解決する。

>>719
トホホホホ、GoF本持ってる漏れは逝ってよしということですか？
　　＿＿_　　　　　　 ＿＿_　　　　　　　　　＿＿_
　 | YES | ΛΛ.　　 | YES | ΛΛ　　　　|GoFi | ΛΛ
　〃￣￣∩ ﾟДﾟ）　〃￣￣∩ ﾟДﾟ）　　〃￣￣∩ ﾟДﾟ） GoForIt!
　　　　　ヾ.　 　）　　　　　ヾ.　 　）　　　　　　　　ヾ.　 　）

オブジェクトと書きましたが、実際はクラスと言うより、ほとんど構造体なので、
データの持たせ方がまずいっぽいです。むーん良いの思いつかねぇ。ﾑｷｮｰ

>>720
サンプル書いてみ？

>>716
イテレータ

>>717
かっこわるいけど

class Serializer {
static size_t seed = 0;
size_t serial;
public:
Serializer() { serial=seed++; } // 場合によってはmutexで保護ね
size_t Serial() const { return serial; }
void ResetSerial(size_t n); { seed = n; }
};

をそいつらのメンバに加えときなさい。

>>722
どもです。やはり
const vector<type>&
とか
const type*
を返すのはダサいでしょうか？

>>724
いやべつにいいんでない？

ダサイよ
Ｄｅｌｐｈｉ使いな

>726
よくわかっているじゃない。

つまり、>>727は、
「ダサいよ、Delphi使い。な？」
と読んだってわけか。

「ダサイよ」Ｄｅｌｐｈｉのルビかと思った。

Del厨って全角英数好きなのか？

STLのmapやsetは、マルチスレッド環境下でも排他制御なしに使えますか？
（map/setの内部にロック機構を持っていますかという意味です）
よろしくお願いします。