C++相談室 part91

C++に関する質問やら話題やらはこちらへどうぞ。
ただし質問の前にはFAQに一通り目を通してください。
IDE (VC++など)などの使い方の質問はその開発環境のスレに
お願いします。

前スレ
C++相談室 part90
http://hibari.2ch.net/test/read.cgi/tech/1310885439/

このスレもよろしくね。
http://hibari.2ch.net/test/read.cgi/tech/1312621728/

ついでに壁紙にしてね。
http://www.research.att.com/~bs/Bjarne.jpg

■基本■
[C++ FAQ]
　http://www.parashift.com/c++-faq/
　http://www.bohyoh.com/CandCPP/FAQ/ (日本語)
　　Cとその仕様を比較しながらの解説なので分かりやすい。
　　***** 質問の前に必ずこの二つに目を通してください *****
[C/C++ リファレンス]
　http://www.cppreference.com/ （英語）
　http://www.cppreference.com/wiki/jp/ （↑の日本語訳だけどまだ未完）
[Stroustrup大聖人]
　http://www2.research.att.com/~bs/
[C++ International Standard]
　http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=38110
[JTC1/SC22/WG21 - C++]
　http://www.open-std.org/jtc1/sc22/wg21/
　　ここから規格の最新（2003より新しい）ドラフトがダウンロードできる。
[JIS X3014]
　http://www.jisc.go.jp/app/pager?id=15868
　　ISO規格の日本語訳。JIS X 3014:2003はISO/IEC 14882:2003 (E)に対応。

■Libraries■
[Boost]
　Boost http://www.boost.org/
　(日本語) http://www.kmonos.net/alang/boost/
　(日本語) http://shinh.skr.jp/boost/
[標準ライブラリ]
　SGI-STL http://www.sgi.com/tech/stl/
　STLport http://stlport.sourceforge.net/
　GNU libstdc++ http://gcc.gnu.org/libstdc++/
　Apache C++ Standard Library (STDCXX) http://stdcxx.apache.org/
　STLFilt http://www.bdsoft.com/tools/stlfilt.html
　(日本語) http://episteme.wankuma.com/stlprog/ （※1999年発行注意）
[Loki]
　http://sourceforge.net/projects/loki-lib/
　LokiPort-MSVC6sp5 http://fara.cs.uni-potsdam.de/~kaufmann/?page=lokiport

■Books■
amazon　C,C++関連書籍
　http://www.amazon.com/exec/obidos/tg/browse/-/3956/ref=br_bx_c_1_3/
　http://www.amazon.co.jp/b/?node=754384

The C++ Programming Language
　http://www.amazon.com/exec/obidos/ASIN/0201700735/
　http://www.amazon.co.jp/exec/obidos/ASIN/475611895X/ (翻訳)
C++ Primer (3rd Edition)
　http://www.amazon.com/exec/obidos/ASIN/0201824701/
　http://www.amazon.co.jp/exec/obidos/ASIN/4756140068/ (翻訳)
The C++ Standard Library
　http://www.amazon.com/exec/obidos/ASIN/0201379260/
　http://www.amazon.co.jp/exec/obidos/ASIN/4756137156/ (翻訳)
Effective C++
　http://www.amazon.com/exec/obidos/ASIN/0201924889/
　http://www.amazon.co.jp/exec/obidos/ASIN/4756118089/ (翻訳)
More Effective C++
　http://www.amazon.com/exec/obidos/ASIN/020163371X/
　http://www.amazon.co.jp/exec/obidos/ASIN/4756118534/ (翻訳)
Exceptional C++
　http://www.amazon.com/exec/obidos/ASIN/0201615622/
　http://www.amazon.co.jp/exec/obidos/ASIN/4894712709/ (翻訳)
More Exceptional C++
　http://www.amazon.com/exec/obidos/ASIN/020170434X/
　http://www.amazon.co.jp/exec/obidos/ASIN/4894714833/ (翻訳)
Exceptional C++ Style
　http://www.amazon.com/exec/obidos/ASIN/0201760428/
　http://www.amazon.co.jp/exec/obidos/ASIN/4894714663/ (翻訳)

■Books(Templateまわり)■
Effective STL
　http://www.amazon.com/exec/obidos/ASIN/0201749629/
　http://www.amazon.co.jp/exec/obidos/ASIN/4894714108/ （翻訳）
Modern C++ Design
　http://www.amazon.com/exec/obidos/ASIN/0201704315/
　http://www.amazon.co.jp/exec/obidos/ASIN/4894714353/ （翻訳）
C++ Templates
　http://www.amazon.com/exec/obidos/ASIN/0201734842/
C++ Template Metaprogramming
　http://www.amazon.com/exec/obidos/ASIN/0321227255/

■長いソースを貼るときはここへ。■
　http://codepad.org/
　http://ideone.com/

>>2
> [C++ International Standard]
リンク先が ISO/IEC 14882:2003 になってるけど、現行規格 ISO/IEC 14882:2011 は
こっち。
http://www.iso.org/iso/iso_catalogue/catalogue_ics/catalogue_detail_ics.htm?csnumber=50372

しばらくは両方載せといたほうがいいかもね。

C++の作者が書いた、C++によるプログラミング入門はどうよ？

>>7 スレ違いかな

class Item {}

std::list<shared_ptr<IItem>> items;

itemsに登録されているItemインスタンスを、自身で登録から外すための方法ってどんなのがある？
Itemクラスまたはその派生クラスのサイズはできる限り押さえたいんだけど・・・

あぁ、ちょっと誤解を招きそうな部分があるな
IItem っていう記述があるけど、それは Item クラスのことです

・itemsへの参照をもたせる
・itemsを広域にする

>>11
その2つのうち、どちらかを選ぶとしたら
・itemsへの参照をもたせる
かなぁ


Itemフラグを持たせておいて、あるタイミングで立っていたら外側から削除、とか
Itemクラスのインスタンス関数の戻り値で、外側に削除して欲しいことを伝える、みたいな
使い道が限られる方法でも、何かあったら教えて欲しい

Itemの寿命が尽きたときにitemsから削除させたいなら
std::list<weak_ptr<Item>> items;
にして、定期的にitemsを掃除するとか。
いや、どんな使い方するのか知らんけどさ。

相互参照に綺麗な答えなんて無いよ
みっともなくて泥臭い方法でやるしか無い

>>9
組み込み環境ならいざ知らず、
8バイトや4バイトぐらいケチケチすんなや。

ノード毎に bool exists を持たせて、イテレータも独自のものを作成する

リスト.begin() や イテレータ::operator ++ が呼ばれるタイミングでそのフラグを確認して、
1. exists == false であり、
　1.1 イテレータが ::const_iterator に該当するものであれば、
　　次の exists == true の要素を返す
　
　1.2 イテレータが ::iterator に該当するものであれば、
　　次の exists == true の要素を返し、そこまでの全ての要素（exists == false）を削除する

2. exists == true であれば
　 現在の要素を返す

Item クラスにはイテレータを渡すなどして、exists にアクセスする方法を用意しておく

・・・という構造にしてみようと思う
std::list<T, ...> が使用しているイテレータやノードを独自のものにする簡単な方法なんてありますか？

イテレータアダプタ

>>17
亀レスでごめん
色々調べてみたが、>>16の構造はそれで解決できそうだ。ありがとう

クラスのありがたみを実感できるような
簡単すぎず長すぎない
プログラム練習問題を出して下さい

○×ゲームでも作ればいいと思うよ

>>19
多倍長整数演算クラスでも作ってみな
演算子オーバーロードの良い練習になるぞ

>>19
ベクトルクラスとか、簡単なコンテナクラスとか

まあクラスも万能ではないし、固執しすぎない程度にやればいいと思う。

>>19
双方向リストを実装せよ

>>19
スマートポインタ

>>19
プログラムの実行時間を計測できるようなストップウォッチ機能

>>19
引数解析機
これの実装を書いてみ。

PrintOption print( "message" ); //-pがコマンドラインに入力されるとmessageが表示される
FileWriteOption file_writer( "example.txt", "message" ); //-fがコマンドラインに入力されるとexample.txtにmessageが書き込まれる
std::map<std::string, Option*> options; //Optionは自作

//ここで入力されたpやfをキーにしてArgumentLexで解析。ArgumentLexはコマンドラインに-pや-fを見つけたら
//printやfile_writeからAcceptとか名前をつけた関数を呼び出し↑のコメントで書いたアクションを実行するようにさせる。
options["p"] = &print;
options["f"] = &file_writer;

ArgumentLex( argc, argv, &options );

AIに提示する環境情報をどういう風に与えるか考えたことあります？
かなり長いこと悩んでるんですが…。

すいません、誤爆しましたm(_ _)m

>>19です
みなさんレスありがとうございます
ですが、もっと低レベルなものを期待していたので
(ネコとかみかんとかが出てきそうな)
もっと勉強してから出直してきます
すみませんでした

>>29
>>24の双方向リストは俺もおすすめだな
シンプルだしアルゴリズムとデータ構造の基本も分かって一石二鳥
一気に実力が伸びると思うので手が届きそうならぜひ

あ、>>23だったわゴメ

簡単なラッパーとかは？win32apiとかの

初心者にWINAPIラップしろとか鬼畜かよ

例えば、演算をするクラスaと描画をするクラスbの両方が
設定データを管理するクラスcを使いたい場合

そういう設計ってあり、というか一般的ですか？

アリの場合、
クラスcは最初にインスタンス化されたときだけ
メモリ実体をアロケートするような小細工するのでしょうか？

シングルトンだろうな

>34
あり
"共有メモリ"かな

シングルトンとは違うぞw

シングルトンのコンストラクタで共有メモリをアロケートするというのはどうだ

なに一店の 静的メンバ だろ
じょうしきてきにかんがえて

必要な情報は全部引数で渡せば良いんじゃね。

>>39
参照する関数が数十以上になることを考えて頂戴

皆さんありがとうございました！

シングルトンはねーよ。
設定ソース.引数に設定(設定先描画オブジェクト);

とした方が設定ソースだけがほかのオブジェクトに
依存するだけだからまし。
しかも設定情報の入れ子を押さえられるし、設定ソースの切り替えで、
レジストリからXMLの切り替えも簡単。
シングルトンだとすべてのクラスがシングルトンに
依存するから修正が大変。
エラー処理とか身動きがとれなくなる。

aとbがcを使いたいのにその構造はどうなのよ

cがaとbをfriendにしとけばいいじゃない

いろんなライブラリのソースを読む

>>43
それ事態がおかしいでしょ。
極端な話、設定値は決めうちでいい。
それを敢えて外に出してるんだから、
設定部分が処理オブジェクトに依存してると考えるのが自然。
処理するオブジェクトだって常に設定ファイルから
値を渡されなきゃならない義理は無いし他の
処理するオブジェクトから値を受け取ったっていい。

決めうちでいいわけないだろ

極端な話とはどういう慣用句だろうか。

>>47
>>46の樹脂とは関係ないけど一部決めうちなんて良くある話じゃない
Direct Xの引数全部の値を外部からとりこむなんて無いじゃん。

Direct Xだって設定オブジェクトに依存して無いな。

所詮一部だろ
設定はある程度外部に出すのは良くある話

C++で作られた計算ロジックを呼び出すGUIを作りたい。
C++もしくはC++と相性の良い言語で
アニメーションを含むリッチなGUIを作成する方法について
おすすめがあれば教えていただきたい。

環境はWindowsのみ。
計算ロジックはVC++で開発中。
そこそこ複雑な画面になる予定。

QtはWindows標準と動作が異なる部分が多いので遠慮したい。
wxWidgetsやWTLでアニメーションはしんどそう。
WPFは理想に近いけどできればもっと軽くてランタイムのいらないものがいい。

妥協策でも教えて頂けると嬉しい。

「設定データを管理するクラスのインスタンス」が絶対に1つしか存在しないのか、それとも複数存在する可能性があるのかで、話の内容が2分されるだろ。なぜ最初にそれを問わないんだ？
1つしか存在しないのであれば static でもシングルトン、
複数存在するのであれば、C のインスタンスを作成→ポインタなりを A と B のインスタンスに渡すか、A と B のメンバ関数の呼び出しの際に、引数として C のインスタンスを渡すだけだろ

ゲームの当たり判定で敵と自機ではクラスが違うので座標が渡せません
なにかいい方法はありませんか？

>>52
Qtがダメってことはtcl/tkやGTK+も同じ理由でダメってことだろうし、
OpenGLやDirectXに対応してるようなGUIエンジン（ http://wiki.gamedev.net/index.php/Libraries#GUI ）もWindows標準とはいえない。
ということは最初からWinAPIかMFCくらいしか選択肢ないようなきがす

>>54
どちらも座標を返す共通の関数を持たせればいい。仮想関数とか。

>>56
できそうな気がします
ありがとうございました

>>55
そうか・・・
サンクス

>>53
設定データというのは例えばシステムのiniファイルだったり
具体的なリソースとしては唯一のものです。

その前提で、aとbにcのインスタンスを生成させるべきかどうか、
という所からの質問と捉えていただけると助かります。

>>51
極端な話…。

「トポロジー的には極端な話取手付のコップとドーナツは同じ」
とかっていう言い回しは通じないんだろうよ。

http://d.hatena.ne.jp/mb2sync/
この人の作ってるライブラリ
http://p-stade.sourceforge.net/
が非常に便利で使いたいなと思うのですが
更新が2008年で止まってるみたいです

ひょっとして他のboostと整合性とれなくなってるんじゃないかと不安なんですが
使ってる人は割といるライブラリなのでしょうか

と思ったらこんなスレが

Oven/Egg総合スレ part1
http://hibari.2ch.net/test/read.cgi/tech/1231080841/

やぱりみんな使ってるのね

それはパイプ構文が非常にキモイので使ってない

ファイル入出力について質問があります。勉強不足で恐縮ですが、よろしくお願いします。
コンパイラはMinGWです。

ファイルオープン時に、ポインタを末尾に移動させて書き込みたいのですが、出来ずにいます。
フラグが"app"だと移動して出力しますが、"ate"だと先頭から上書きされます。
seekp関数で seekp(0, std::ios::end) と書いても駄目でした。
以下がソースです。

#include <fstream>
int main(int argc,char *argv[])
{
std::ofstream Fout("test.txt", std::ios::out | std::ios::ate);

Fout << "test" << std::endl;

Fout.close();
return 0;
}

>>65
ios::ateの意味は単に「ファイルを開いた時にファイルポインタをファイルの最後に
シークするだけだから、ios::appとOR取らないとだめでしょ

std::ofstream Fout("test.txt", std::ios::out | std::ios::ate | std::ios::app);

いやateは不要かもしれんな

ちなみに意味のある組み合わせは

in
out
out | trunc
out | app
in | out
in | out | trunc

これ以外のフラグの組み合わせは許可されていない

面倒くせー仕様だな
C++最初に考えた奴はそうとうひねくれてるんだろうな
誰だかしらねーけど多分融通きかない頭硬そうなやつだから禿げてるよ

知らん
規格表にそう書いてあるもん

ちなみにC++オープンモードとCのオープンモードを対比させて覚えておくとよい

in "r"
out "w"
out | trunc "w"
out | app "a"
in | out "r+"
in | out | trunc "w+"

ateは補助的なフラグでオープン直後にファイルの最後にシークするだけで
主な動作は上の組み合わせで決まる

"a+"がねーな

in | out | app かな？よくわからん

>>71
正解
結局ateの動作が問題になるだけ

appでオープンすると書き込み時は常にファイルエンドにシークするが
ateでオープンすると任意の場所から書き込み可能

>>63-64
可変テンプレートがVisualStudioで使えないから
代用品探してるんだけど
これに変わるものがみつからない

boost::anyみたいにパーフォーマンスに影響あるのかソース見ないとわからないから
そこも不安だ

>>65です。できました。みんなありがとう。
CとC++のオープンモードの対比がわかりやすすぎて泣けました。

>>73
特殊化とデフォルトテンプレート引数駆使すれば相応のものができる。
ただし、16個までとか32個までとか上限を決める必用が有るけどね。
16も有れば普通は十分。

なんでC++のブログって
開始後１年後ぐらいにハスケル始めるん？

template <typename T>
class typedef_smart_ptr_to { // ←これ
public:
　typedef boost::shared_ptr<T> shared_ptr;
　typedef boost::weak_ptr<T> weak_ptr;
　typedef boost::scoped_ptr<T> scoped_ptr;
};

class Hoge : public typedef_smart_ptr_to<Hoge>
{
public:
　Hoge() {}

　void SetNext(const shared_ptr & pNext) { this->pNext = pNext; }
　shared_ptr GetNext() const { return this->pNext; }

private:
　shared_ptr pNext;
};

typedef_smart_ptr_to は自身を継承したクラスへの typedef を集めたクラスです

Q1. クラステンプレートをこんな風に使って大丈夫ですか？
Q2. これを継承したクラス（例では Hoge）にデメリットはありますか？

>>77
大丈夫かというのなら心配している点を言って欲しいな。
デメリットを考えるのなら比較対照を示して欲しいな。

とりあえず、継承を使うと POD にならないとか、 Hoge も template だったり
すると途端に面倒になるとか、 scoped_ptr しか要らないところでも他のやつの
#include が必要になるとか、そんなのが思いつくけど。

こういう構造は気を付けないと循環参照を起こしやすそうであまり好きではないかな。
リスト作りたいならlistとかに任せたらいいのではと思うんだけども。

>>78
しいて言えば、この継承によって
1. Hoge インスタンスのサイズが増えないか
2. Hoge インスタンスの作成（コンストラクタの呼び出し）が遅くならないか
3. Hoge インスタンスの破棄（デストラクタ（ｒｙ
ここら辺です
自分の知識ではこれらのデメリットは発生しないと思いましたが、念のためです

>>79
話題の中心は typedef_smart_ptr_to ←これです
Hogeクラスの構造はこのクラステンプレート（で定義されている typedef）の使用例として書いただけです

>>80
効率は実測が基本。

ここで問題ないという答えが返ってきたところで、あなたの使っている環境や
作っているものについて問題にならないとは限らない。

内部に侵入しなくてもいいように作られてるshared_ptrを
思いっきり内部に取り込んでる設計は好ましくない

>>81
「一般的にどうであるか」を尋ねています。

>>82
「typedef boost::shared_ptr<T> shared_ptr;」などを Hoge クラス内で宣言するべきではないということでしょうか
クラス外で「typedef boost::shared_ptr<Hoge> HogePtr;」を宣言するのは問題ありませんか？

QZ臭せえ〜

>>77
A1. 大丈夫
A2. デメリットはない

けど外部に委ねられるものをインターフェースとして内包する……という設計には疑問を感じる
>>83
そうだね
それで代替できるのならそうしたほうがいい

>>77
わざわざ継承している理由がいちいち子クラスで
typedefするのがめんどい程度しか感じられない。

>>85
回答ありがとうございます
しかしtypedefのためにクラステンプレートを使うのはマズのか・・・
他の方のレスと合わせて、ちょっと使用は控えようかと思います

>>86
まさに「typedefがめんどくさい」から考えた構造です

>>84
QZは低脳なのでC++はやらないのでは？

標準にもstd::unary_functionとかあるから問題外ってことはない。
しかし一々typedefするのが深刻なほど問題になるような状況は考えにくいな。
子クラスがものすごく単純な構成ばかりで、typedefが総行数の半分以上とかになるようなら
使ってもいいって所。

まあunary_functionも廃止予定だし

>>83
アホ？

81 は「一般論など意味がない」と答えているのに
それが水掛け論で答えが変わったら何か得られるとでも思ってるんだろ

ああ、効率いいよ
これでご満足か？

# ごね得を拾う生き方の人は自然科学が相手じゃない道を選んだ方がいい

C++スレなんだからコメントは//にしろよ

>>83
Hogeの中だけで使うスマポとしてtypedefするならいいと思うよ
でもHogeのポインタを扱うときにはこのスマポを使ってね、という意味で公開typedefを用意するのは良い設計とは思えない（たまにこういうことをする人がいるから指摘した）

>>93
＞Hogeのポインタを扱うときにはこのスマポを使ってね、という意味で公開typedefを用意する
まさにこれをやろうとしていました
クラス外であれば使う都度、typedefを使わず宣言した方が良さそうですね

素人丸出しの質問ですまん。
長いプログラム書くときどういった手順で作成してる？
俺の場合main関数に大体の流れを書く→クラス、関数を作る→
不備があればmain関数を弄る→エンドレスって感じなんだが、
どうも、しっくりこない。何かいい方法ある？

>>95
最初から全部は考えない。部分目標を作ってちまちま継ぎ足していく。
まずはウィンドウを表示する、とか。ランキングデータを取得して表示してみる、とか。
必要と思った関数、クラスはそのつど作成する。
その過程でリファクタリングしたりもする。
２，３回は全部投げ捨てて最初から作り直したくなる衝動にかられる。
そして完成する前に飽きてエター。

コード書く前に設計する
どうやって設計するかは本で勉強してください
設計が終わればあとはそのとおりにコードを書くだけ

そんなやついねえ

>>95
既存の枯れたコードやアルゴリズムを使って、その長いプログラムを短くすることを考える。

まず必要なクラス名を列挙して大雑把に設計する。
同時に、曖昧な手続きはmainにテストコードを書いて確認する。
あ、これでいいんじゃね？となったら書き始める。

アプリケーションなら実行の流れと論理構造は別物なので分けて考える。
コマンドラインアプリのようなひとつの仕事をして終了するタイプや、GUIアプリのような
恒常性のあるタイプといった類型があるので、それぞれのタイプに沿った設計手法をとる。
大まかに全体像を把握したらそれを関数やクラス構造に落とし込んでいく。

いずれにしても、このスレでする話じゃないな。

設計はどこで話せばいいの？

>>103
スレタイ検索するとか↓とか。
http://hibari.2ch.net/test/read.cgi/tech/1312926165/

つい最近bullet使い始めてみて、疑問に思ったことなんだが

void* ってかっこよく型を戻すことできないの？
getType()を仮想関数にして、判別しているんだがもっといい設計がある気がする。
http://codepad.org/SOTom56e

こんなこと出来ないの？
void *p = hoge.getUserPointer();
static_cast<typename getType(p)>(p);

>>105
型情報を別途持つ特殊なポインタクラスを造れば実現できるけど、それは既にvoid *じゃないね。
つーか、型情報を持たないvoid *を例えば関数の引き数として受け取ってどうやって元の型を知るのかと。

Baseから派生してるんだからBase*を使えばいいのであって、void*にする必然性が無いな。
ついでに言えば仮想関数で呼び出せばRTTIもいらない。

bulletライブラリがvoid*を使う仕様なんだからしょうがないんじゃね

クラスの継承で質問があります。
privateで継承した場合って、派生クラスでも基底クラスのメンバにはアクセス不可能なんですよね？
ではこのprivateで継承することって何か意味あるんですか？

public以外の継承は考えたことなかったなあ・・・
↓に詳しく書いてあったよ。アクセスできるって
http://www.geocities.jp/ky_webid/cpp/language/032.html

>>109
例えばboost::noncopyable
private継承することでコピーコンストラクタと代入演算子を無効化できる。

ただ
private部分の親クラスの動作を変えたい、
とかは親がそう設計されていなければやはり無理。
親を修正するしかない。
この点においてオブジェクト指向の限界というか、
柔軟性の無い点だとも感じるがなぁ

ただ〜からは必要のない不適切な話だったスマソ

ほぼ包含で代用できるので忘れていいです

>>110-113
派生クラスからは、privateで継承したとしても、基底クラスのprotectedやpublicのメンバにはアクセスできるんですね。
皆さんありがとうございました。

つっこむの面倒になるレベル

そういうのは書きこまなくていいです＾＾

prot
まぁいいか

ちょっと待ってください
私が何か勘違いしているのなら教えて欲しいです

>>105
というか一回Baseにキャストしておｋという設定だったらmewとhawlを抽象化するのが普通だろう
struct Base { virtual void make_sound(void) const = 0; /* (ry */ } ;
void Cat::make_sound(void) const { mew(); }
void Dog::make_sound(void) const { hawl(); }
void func(void * p) { static_cast<Base *>(p)->make_sound(); }
int main(void) {
Cat * p = new Cat;
func(p);
delete p;
return 0;
}

>>106
＞つーか、型情報を持たないvoid *を例えば関数の引き数として受け取ってどうやって元の型を知るのかと。
すいません。書き方悪かったです。templateからうまくやりたかったんですが…
こんな感じかな
templateClass<voidPtr>::type voidPtr;

自分でもよくわかりませんｗｗ　というかvoid*を渡してどうする気なの自分。
virtualな typedef をしたいんだと思います。
初期案はこんな感じでしたが、書けませんでした。http://codepad.org/tMVtOiyZ

>>119
仮想関数で処理するのが一般的だと思いましたが、bulletのコールバック関数内で型別に処理したほうがいい場合があるかなと感じたんで、とりあえずあんな感じにしときました。
最終的には　IActor　みたいなクラス作って、仮想関数で処理すると思います。

>>109
protectedだけど
http://codepad.org/s7Vlq2BL

ああーContainerのアドレス消し忘れた
要はvirtualじゃないデストラクタのクラスを委譲しようとしたときに便利なことがある。
ぶっちゃけ、理解する必要はない

いろいろなデータ型を格納出来れば便利だなと思って、
どんな型でもセットできるdataクラスをつくり、それをvectorに入れようと思ったのですがうまくいきません。
std::vector<data<T> > foo;でコンパイルエラーになります。
こういうことは出来ないのでしょうか？

template<typename T>
class data{
public:
data(const T &value){this->value = value;}
T value;
};

int main(void){
data<int> d1 = 1;
data<float> d2 = 1.2;
std::vector<data<T> > foo;
foo.push_back(d1);
foo.push_back(d2);
}

>>122
data<int> と data<float> は違う型なので、それらをまとめてひとつの型とすることはできない。
どんな型でもまとめて格納できる配列が欲しいのなら、 boost::any の配列を使うといいかもしれない。

誤爆です。

>>123
ありがとうございます。
やっぱ、無理ですよね…

なんでも入れれる配列があったら便利なのにってたまに猛烈に思うよね
で、やってみたら取り出す時に面倒だしたいして便利でもないことに気づくんだが
なぜかしばらくするとそのことを忘れる

そこまで馬鹿ならそういう気付いたことを書きこむメモを用意しておいて都度読むようにしたら?

バリアント型でもいいな

dataクラスを継承した個々のクラスを作っといて
data* data_child1 = new child_data1();
data* data_child2 = new child_data2();
とかしてdata_child1とdata_child2をコンテナに突っ込んどいて
get_data()したら個々のサブクラスのデータが取り出せるとかいう話じゃなくて？

なんでも詰め込めてんぎも”っぢいいいなんてやってるような情弱はアプリ設計力皆無のスクリプト土方

Smalltalk に対する禿の批判がそういう方面の話だったな

急にキレてるヤツなんなの
嫌な思い出でもあるのか

キレてる人なんていないけど…？

c++のために大量のエラー処理や書法を覚えて
ゲロゲロなコードを書くやつ奴がバカなのか、
それとも覚えられない奴がバカなのか教えて下さい。

>>134
それは C++ に限った問題じゃないだろ

ioccc の中の人はバカだと思うか？
あれが読めないとバカか？

// ioc++cc は今できないだろうな

STLのQueueの用途が解らん。
非同期ならパイプやOSのキュー使うし、
同期なら必要ないし、いったいどういう用途を想定してんだろ

あんなアーティティックなコードを例に挙げられてもな…。
気になっているのは、cとc++の間にある大きな隔たりだよ。
STLや例外処理なんて本当に必要だったのか？
綺麗なcのコードを読んだ後に、ゲロゲロとした自分のc++のコードを見ると
もはやc++の存在自体が邪悪に見えてくるんだよ

>>137
なんで自分のせいだと思わないの？

奇麗なcのコードなんて存在しない

そりゃ、おまえの回りに派遣グラマや土方しかいないからだろ

>>137
なんでCで満足してるやつがC++使ったらゲロゲロなコードになるんだ？
ほとんど同じコードで同じ動作するのに。

C 好きだからこそ例外と RTTI が早く醒めて欲しい悪夢なんだよ
STL は中途半端がいやなだけでそれ自体が消えて欲しいわけではない

使わなきゃいいじゃん
Cだって標準で用意されてるからってgets使うやつはいないでしょ

例外とRTTIは規約で禁止してるとこも多いんじゃないかな？

>>142
俺は使わんけど実行時型情報の何がだめなのか解らん。
構造体情報を短期的に保存するなら実行時型情報便利じゃん。
短期保存用途にも関わらずわざわざ同じ仕組みを用意するのは無駄。

decltpypeも似たようなものか?

というか、こちらの方が便利さよりも混乱をもたらすように思うが。

ﾃﾞｸﾙﾄﾊﾟｲﾌﾟｯ

例外批判するやつは多いけどそういうやつで戻り値とerrnoチェックしてるやつが少ないんだよな
結局エラー処理のないコードが綺麗に見えてるだけ。そりゃそうだろうよ

もちろん大半がそうってだけでちゃんと書いてるやつもいるけど

>>136
単にインターフェースが制限されたdequeだと思えばいいよ

エラーなんて 「どこで起きたか」 が大事だし、それに応じてエラー処理したいのに
例外みたいに 「try でくくることでどこで例外が起きても大丈夫！」 のメリットが分からない。
１つ１つ例外で括ってたら行数食うし、else 文も書けないし…。

try func_start();
catch (ExceptionA e) error_func_A();
catch (ExceptionB e) error_func_B();
nocatch {
　// 続きの処理
finaly func_end();
}

みたいに書けないかなぁ。もちろん try 文の中で宣言した変数は nocatch 内でも使いたい。

finaly の位置がおかしいけど気にしないで

ああ、例外自体を否定してるわけじゃないです。
戻り値とは別にエラーを返せるのはありがたいし。
ただ、try 文でスコープを完結させるのはマジ勘弁

>>144
便利というだけで言語がサポートすべきなら GC もそうなんだが
だったら C++ 自体がいらない子

>>149
場合によりけりかなぁ
例えばprintfはエラーを返すけどその中のどこでエラーが起きたか……なんて気にしないでしょ。標準ライブラリでなくてもPOSIXやWin32でも。

どこで起きたかって情報を完全に不要にするのは難しいしそれが必要になることもあるけど、その情報が頻繁に必要になるのは関数が持つエラー通知のインターフェースの作りがよくないんだと思うよ
これはエラー処理にC++の例外を使用するかは関係ない

>>149
どこで起きたかの情報を保持する例外投げればいいんじゃない？あなたはあほなの？

本当定期的に例外が使えない奴が沸くよな
組み込みやゲームとか処理がタイトなものならともかく、
普通使うだろ

例外使ったほうが速度も出るってレポートどっかにあったよね

>>152
主張は理解できるが
GCが便利かといわれるとちょっとどうかなｗ

RTTIはテストやデバッグ実行時のときは便利だよね
それ以外ではコンパイラでoffにしてる
エラー発生位置もそうだけどRTTIつかいまくりの設計もどうにかしたほうがいいと思うぞ
便利なのはわかるけど普通不要だから

仮想関数を正しく使うとRTTIが必要な場面は滅多にないな
if文の羅列とかもうやめたい

>>144
サイズが増える

>>159
組み込みの現場ぐらいでしか問題にならんだろ

>>158
dynamic_castってRTTI使ってたっけ?
仮想関数テーブルで判定してるだけじゃない?

>>161
使ってる

dynamic_castはクロスキャストもいけるからな
結構複雑

class IItem {};
class IDrinkable {};
class IEquipment : public IItem {};
class Weapon : public IEquipment {};
class Armor : public IEquipment {};
class Potion : public IItem, public IDrinkable {};

std::list<shared_ptr<IItem>> items;

コンテナにつっ込まれた要素の、元の型を知りたい時に、IItem クラスは何を用意することがベストだろうか

1. 何も用意しない。dynamic_cast を使用する

2. virtual ItemType GetType() = 0
　enum ItemType {
　　ItemType_Weapon, // Weapon クラスはこれを返す。
　　ItemType_Armor, // Armor クラスはこれを返す。
　　...
　}

3. virtual Weapon * CastToWeapon() { return NULL; }
　Weapon クラスはオーバーライドして、this を返す。
　他の派生したクラスへキャストする関数も用意する。

4. その他

型の判断が必要な処理は全部仮想関数にする。
そういう風に基底クラスのインタフェースを定義する。

仮想関数で完結するのがベストだな
じゃないと何の為に派生してるのやら分からん

ただ、AにBの派生クラスを登録して、
Aの派生クラスからBの派生クラスを使う、
というような場合にはdynamic_castもやむを得ない場合もある

コンパイラスイッチ一発でgc走るようにならんかな
メモリリーク周りのバグだけ残して、期限までに納品とかできるのにな
バックログは後々で修正してさ

今どきCならともかくC++でメモリリークって起きにくくね

言語に関係なく解放しなければメモリリークする

デストラクタのあるC++でメモリリーク
させる奴は殺害もの

>>164
なんのために抽象化したリストに突っ込むかによるだろ。
ダウンキャスト的な動作が必要なら、少々とこばっても最初から
元の型を保持したリストを別途用意しとくほうがマシ。
そもそも抽象化したリストに投入する事は、元の型を捨てるという意味だから。

std::list<shared_ptr<Weapon>> weapons;
std::list<shared_ptr<Armor>> armors;
std::list<shared_ptr<IItem>> items;

Weapon weapon;
weapons.push_back(&weapon);
items.push_back(&weapon);

標準のファイルでcloseに失敗したとしてそれを復旧する方法ってあるの？
無視してそのままアプリ実行したらまずいのかな

書き込み完了を確実にしたいならflush();
flush()で失敗したら、書き出し先ドライブを変えるとかユーザーにリカバリーを選択させる。
closeで失敗したら、失敗したよってユーザーに通知することぐらいしかできないだろ。
あとは、ダンプを作成してどっかに吐き出しとくことぐらいか。

>>170
そうはいってもメモリ管理はミスる時にはミスります。malloc()/free() となんらかわりません。

なるほど
フラッシュで失敗したばあいはいくらでも復旧可能
フラッシュで成功したばあいは直後のクローズで失敗しても特に実害は無いのでご自由に
というかんじか
フラッシュの使い道初めて知ったよとんくす

コンストラクターでメモリ開放してなかったりな。
そもそもコンストラクターでオブジェクトの作成なんてする必要があるか疑問だが。
配列を確保するならまだしもね。

>>176
何が言いたいのかさっぱりわからない。
コンストラクタでオブジェクト作成しなかったら何するの？って感じなんだけど。

オブジェクトの作成というかnewか。
基本的にはメンバー変数に実体を置くか、
外部のオブジェクトを参照するだけで十分な筈。
メモリー操作が必要となるのは、配列かAPIのリソースぐらいじゃん。

一応close()が失敗しても回復処理とる事もできなくは無いけどな。
新たに別のファイルを開き直して、もう一回出力とか。

>>178
お前がそう思うんならそうなんだろう、お前ん中ではな（AA略

>>176
もしかして誤字ではなく本気で open と言っているのか？

他にどんな用途でオブジェクトをnewするんだよ。
まさか、クラスのメンバーにfstreamのポインター置いて、
クラス内で new と delete を繰り返してるとか?
それともfunctionクラスみたいに型をカプセル化する
オブジェクトを内包しててnewで生成してるとか？
前者は作りを見直すべきだし、後者は滅多に
つくるようなもんじゃないよな。

>>181
誤爆か？

ポインタにNULLを代入して何回でもdeleteしてやる

>>176 はたぶん
「RAII の徹底が不十分な場合、コンストラクタの途中で例外が出てメモリリークする
　ことがある」
ということを言いたかったんだと思うんだけど、合ってるかな？

コンストラクターの途中で例外でメモリーリークはその通り。
例外が発生すればメモリーリークになるわけじゃないけど、
ちゃんと例外発生時の例外処理を書いてないとメモリーリークになる。

RAIIはどうでもいいけど。いくら例外処理で対処できるとはいえ、
NULL初期化とかが必要になるコンストラクターのメモリ操作自体は減らすべき。

pimplとか

要するにこう書くのがミスしやすくて問題なんだろ

class Type
{
        Example *a,*b,*c;
public:
        Type():a(0),b(0),c(0)
        try
        {
             a = new Example();
             b = new Example();
             c = new Example();
        }
        catch(...)
        {
             delete a;
             delete b;
             delete c;
        }
};

なんのためにスマポがあると思ってん

ユニポでおｋ

それって「素直にスマートポインタ使っとけ」で結論でてると思ってたんだけど違うの？

>>186
なんでその文脈でRAIIを選択肢から外すんだよｗ

例外とRAIIを否定する奴は大抵の場合アホ

>>188
その catch の中の a,b,c へのアクセスはすべて未定義動作。ミスとか関係ない。

もともとメンバーに実体で割り当てりゃいいものをいちいちスマポで割り当てる理由が解からん。

>>194
なんで未定義になるんだ？

>>195
実体で割り当てたんじゃ要求を満たせないときに new するに決まってんだろ。
メンバの寿命とクラスの寿命がずれてるとか、途中で具象クラスを入れ替えるとか、
考えれば出てきそうなもんだ。

>>194
え？

>>196
http://blogs.wankuma.com/episteme/archive/2011/02/20/197105.aspx#197169
15.3 p10 でそう決められているから、らしい。

そんなのコンパイルエラーにしろよとは思う。

まともにやってるヤツは構わんけど、よくよく考えれば無意味にnewした
メンバー割り当てるヤツがいるから書いたんだよ。
pimpとかは大事だけど、単にリソース開閉のためだけにメモリ操作するなんて無駄じゃん。

>>199
そこ見ても解るけど問題起きるのは規格に準拠してないコンパイラだけでしょ。

>>199
ああ >>188 よく見たら function try block になってる（？）のか。
コンストラクタ本体の中で try ... catch するぶんには問題ないよね。

>>200
そこから「コンストラクタでnew」まで攻撃対象を辺に拡大するから話がおかしくなってる。
ふつうにその無駄を叩けよ。

すまん。

>>202
そうだけど、188が function try block のつもりじゃないとしたら、 throw; が抜けてる。

>>199
これは : がないからfunction-try-blockじゃなくて普通にコンストラクタ内部のtryブロックだろ
{}を書き忘れただけじゃねーかな

>>201
どこにそんなこと書いてあるの？

delete 0;は常に何もしないことが保証されてなかったか？

親クラスで例外が出た場合、
メンバー関数が初期化された状態で、
例外処理に入るとは限らない。
的な事じゃ無いんだろうか。

WinRTで>>52が望んでいたものがそのまま出てきたな

>>208-209
コンストラクタでfunction-try-blockを使ってるなら
function-try-block中で例外が発生した時点で構築済みの基底クラスやメンバ変数は破棄されて無効なオブジェクトになるので
その後のcatch節の中ではアクセスしてはいけない、ってこと。
ttp://codepad.org/6zad5CVy

もっとも>>188はfunction-try-blockではないようなので>>211とは関係ないんだけど

もうみなさんはlambdaをガンガン使ってコード書いてるの？

>>211
引数はどうなんの？やっぱり未定義かえ？

発見しちゃったんだけどなんか使い道あるかな？
class a{
operator a(); // これ作れちゃうんだ
};

mmapで確保したメモリー空間にヒープを構築しようと思う。
プールを渡してやったらファーストフィットやらベストフィットやらを
サクッと構築できるライブラリとかないかな。

>>214
引数の寿命はfunction-try-blockのハンドラを抜けるまで延長される。だから引数にはアクセスできる。
ttp://codepad.org/0wwV4V4w

延長されるっていうか、普通に考えておｋってことだね。

char*が引き数ってなんなんだよ…

>>217
規格上はやっぱりセーフなんだ。良かった。

>>215
aにキャストしても呼ばれないし、
aの派生クラスbを作ってaに代入やキャストしても呼ばれないし、
operator aを直接呼ばないと呼ばれないっぽ
環境依存かもしれないけど
使い道はなさげ

C++でググったサイト見てると、C++の例外はgdgdなので使わない方がいいという意見があり、スコット・メイヤー先生の著書ではエラー処理には例外を使えとあるのですが、みなさんは例外使ってます？

うん。

>>222
> 使わない方がいいという意見
どこ見たの？

類は群れる

ラムダは割と使う
便利だし

ラムダをループ毎に一回一回生成すると無駄にコストが掛かりますか？

>244　本人じゃないが
試しにググって見たら、「C++ 例外 使わない」 で12,400件でたぞ。意外と多い。ｗ
おれは、半々だな、使う部分と使わない部分がある。

>>216
構造としてのヒープじゃなくて領域としてのヒープか？
ファーストフィットだけならsimple segregated storageってのがあるからそれを実装したライブラリで領域を外から与えられるやつ探せばいいと思うよ
一応boostにもあるけど領域を外から与えられるかどうかはわからん


データ構造のほうならstd::make_heapで

Google先生は例外を使わないと規約で決めてるっぽいけど
それを達成するには例外を利用する標準ライブラリを
例外の出ないタイプのものに置き換える必要があるから
正直そこまでやるのもどうかと思う

徹底したくなるほど過去の資産の価値がすごいんだろう

1. 戻り値として true/false か NULL を返せない
2. エラーが発生したときに落ちることを許可しない

1 && 2 であれば、例外を使用する

bool TryGetHoge(Hoge * pOutput) // Nothrow
const Hoge * GetHogeOrNull() // Nothrow
const Hoge & GetHogeOrThrow() // Hoge が取得できないばあいはスロー
const Hoge & GetHogeOrDie() // Hoge が取得できない → 死

>>227
無駄にコストが掛かる、ってのはどういうこと？
C++は原則的に要求された機能を実現するのに必要なだけのコストしか掛けない。
プログラマが実際には使わない機能を含めて要求していたならその分無駄にコストが掛かるといえるけど
それは具体的な状況次第。

キャプチャ次第じゃないの
関数の本体自体を生成してるわけじゃないんだし

キャプチャしないとただの関数に最適化される

[&]ならどうせスタックフレーム渡してるだけだろうから
大した事ないよね

>>232
例外が発生したところで、根っこでキャッチする限り落ちることはなくね？
それが良いわけでもないけどさ。
逆にエラー無視してたらまずくね?
いずれセグメントエラーでも起こして無断で死ぬでしょ。

ごめん例外を出さないパターンとはやとちりした。

int main(void)
{
try { return Main(void); } catch(...) { Message("Fackin Error !!!"); return 1 ; }
}

あまり酷いエラーはそのまま死んだ方がいいってこともあるよね

>>229
simple segregated storageかいいね。ありがとう。

コンストラクタのメンバ関数ポインタって取得できますか？

とれませんよそんなの

ありがとう。そして素早い回答に感動した

>>225

チムポも蒸れる

コンストラクタのメンバ関数ポインタを取得する裏技はないものかねえ

そんなものいらん

コンストラクタはメンバ関数じゃないから

>>246
初期化のコンスラクタを呼びたいだけじゃないのか?
それならるぞ。

可変テンプレートを自作すりゃ見せかけは出来なくはないがね。

Type (*constractor)(int) = &Constractor<Type(int)>;
Type object = constractor(10);

標準のnewやmallocはスレッドセーフですか？

>>251
マルチすると一部の人はヘソを曲げて答えてくれなくなっちゃうぞ

>>252
すいません
向こうは違う人が連投してるので埋もれてしまうかと思ったのでこっちにも書きました

>>251
VCならmtライブラリの物はスレッドセーフだろうけど他のコンパイラは知らん
一応アトミックにしとかないとまずいんじゃね？

C++11以前のC++はスレッドの事を知らんだろ。
処理系依存じゃね。

new delete malloc freeは単体ではスレッドセーフだが、
new - delete malloc - free はついだから、注意がとても必要。

まあスレッドセーフじゃないとな

えっ標準でいちいちロックしてんのか
規格表にあったっけ

>new - delete malloc - free はついだから、注意がとても必要。
これ、誤解受けそうだから、
new　　deleteが別のスレッドでもいいが、主にタイミングの問題な。

mmapとかVirtualAllocとか、低レベルなOSの実装部がやってるだろ。
newのコンストラクタ呼び出しとか、deleteデストラクタ呼び出しとかは、
スレッド関係ないから、その辺は排他なんて何もしてないだろうけど。

まとめると
malloc, free, operator new, operator delete
はそれぞれの関数内ではスレッドセーフということですかね
ありがとうございました

OK

>>261
向こうのスレに解決したこと書いておくように
マルチすると解決したあとも面倒だぞ

単純にoperator newとoperator deleteと言うと基本的にスレッドセーフじゃ無い
上の方でヒープを自作するといってる人がいたが、そういう自作できる人が
排他を組み込んでなかったらアウト。

オーバーロードされたらその限りではない、
ってのは演算子の基本ではあるわな
&&と||のショートサーキットとか

>>251-265
C++11 から、それら自体に要求される Data race 耐性が規定されるようになったよ。
18.6.1.4 [new.delete.dataraces]

11が普通に使えるように普及するのは何年後になるかねぇ。

streamの拡張について相談です。
ここ( http://www.jah.ne.jp/~naoyuki/Writings/ExtIos.html )を参考に自作ostreamクラスの出力をメンバ変数のvector<char>として取っておいて、適宜取り出せるようにするのは出来たんですが、
コンストラクタから渡したvector<char>から入力を行わせるistreamの拡張がどうにもうまく行きません(boostのistream&を引数としているクラスに渡すと例外を吐く)。
上のを見るかぎりint underflow(void)内でstd::vectorの中身を一つずつ渡せばいいんだと思ったのですが……。
どこかに上記URL先のostream拡張並に平易な例で解説している場所ないですかね？

目的としてはboost.serializationの入出力をファイルでなく、vector<char>で行わせたいんです。

>>268 http://www.boost.org/libs/iostreams

>>296
boost.iostreamsのページは一応読んだんだけどもうまく頭に入らなくて……
寝て起きたらもう一回読んでみる

std::stringstreamじゃだめなのか

シリアライズして機種間の依存を無くしたいのでは？
stringstreamではエンディアンの問題が残ってしまう

cout << "name1 " << name1 << " name2 " << name2 ...
みたいなデバックプリントをもっとタイプ数少なくやってくれるlibraryとか便利関数ないものでしょうか
stdの中にあるとincludeするだけで使えて一番いいのですが

自分でそういう関数作れば可変長引数とsprintfとかですぐできそうだが

バグベアードでも使っとけよ

setjmp/longjmp をクラスのデストラクタと一緒に使うとおかしなことおきるみたいですが
http://d.hatena.ne.jp/chiharunpo/20110509/1304942799
常に安全側に自動的になるような仕組みないでしょうか？

普通の関数でも
boost::functionに代入してからいろいろしてるので
setjmp/longjmp
使うの不安だ

>>276
ない

>>276
mallocとdeleteを組み合わせるようなもんじゃねーの

std::ostringstream と std::sprintf どっちが早いですか？

>>279
sprintf

そもそもC++でsetjmp/longjmpは使うな
絶対にだ

c++0xでもダメなの？

C++03
The function signature longjmp(jmp_buf jbuf, int val) has more restricted behavior in this International Standard.
If any automatic objects would be destroyed by a thrown exception transferring control to another (destination) point in the program,
then a call to longjmp(jbuf, val) at the throw point that transfers control to the same (destination) point has undefined behavior.

C++11
The function signature longjmp(jmp_buf jbuf, int val) has more restricted behavior in this International Standard.
A setjmp/longjmp call pair has undefined behavior if replacing the setjmp and longjmp by catch and throw would invoke any non-trivial destructors for any automatic objects.

std::longjmp
なんてものがあるんだね

C++03
シグネチャ longjmp(jmp_buf jbuf, int val) はこの国際規格では(Cの規格）より振る舞いが制限されている。
任意の自動変数が例外によってプログラム内の制御が別の所に移動する事により破棄されようとするような場合に、
その throw を行う地点での別の場所に制御を移動するような longjmp(jbuf, val) の呼び出した際の振る舞いは未定義である。

分かりにくい表現だけど、要するに、
throw だと制御が他に移動した時にもちゃんとデストラクタ呼んでくれることが保証されるけど、
throw の代わりに longjmp を使った場合はそれが保証されない（未定義になる）ということ。

C++11も文言は変わってるけど似たような事を言ってる。

何か日本語おかしくなってたけど
直した所で分かりやすくならないのでいいや

C++でsetjmp/longjmpが必要な時点で何かがおかしい

例外使用禁止だお
だからsetjmp/longjmp使うお

やーーめーーろーーよーー
戻り値エラーコードで我慢しろ

そんなに例外が嫌いならEC++でも使ってろ

俺は禁止される側だお

インターフェースがエラーコード返すようになってないお
インターフェースは変更できないお

例外catchしてエラーコード返すようにラッピングすればいい

それ例外使ってるやん

利用してないだろ

それってC++例外を有効にするをいいえにしても使えるのかお？
どっちにしろコードレビューではねられる気がするお

そもそも例外を使うなという条件で
そのインタフェースを提示してる時点で
コードレビューにひっかかるだろw

インターフェースはコードレビューする人が決めるお

例外使う前提でインタフェース決めてるってことだから
そこに例外使うなというのを後から突っ込んでる時点で
まともな話にならないのは当然だお

template <typename T, typename U>
bool try_lexical_cast(const U & input, T * pOutput)
{
　try {
　　*pOutput = lexical_cast<T>(input);
　　return true;
　} catch (bad_lexical_castだっけ？ &) {
　　return false;
　}
}

>>288
signalかerrnoを使えばいい

すべての関数をnothrowにして返り値型をoptionalで統一すればいいよ

boost::optional<void>

関数を全て継続渡し形式にしたら遅くなった

C++11のlambdaって
まさかコンパイル時じゃなくて実行時生成なの？

>>304
普通の関数オブジェクトになるよ
キャプチャしてればその領域の確保を実行時に行う
してないなら普通の関数と同じ

もちろん処理系によってはそうじゃないかもしれないが

>>302
エラーの種類やメッセージとか全部捨てていいならな。

ifstreambuf_iterator を使って構造体をバイナリファイルから順に読み出す方法があれば教えて頂けないでしょうか

たとえば

typedef struct _abc {
int i;
float x;
} ABC;

と言う構造体が連続してバイナリーデータとして書きこまれているファイルが
/home/Hoge/hoge_bin.dat にあると仮定します。


ifstream ifs( "/home/Hoge/hoge_bin.dat", ios::binary );
istreambuf_iterator<ABC> pABCend;
istreambuf_iterator<ABC> pABC(ifs);

while( pABC != pABCend ) {
cout << "(" << pABC->i << "," << pABC->x << ")" << endl;
pABC++;
}
（このコードはコンパイルエラーとなってしまいます）

のような使い方をしたいのですが、参考書を見ても istreambuf_iterator<char>での
例題しか載っていません。

bool TryGetHoge(Hoge *pHoge)
っていう関数があるとする

戻り値が false であったばあい、*pHoge は
1. NULL が代入されている
2. 全く手付かず
どちらの方が連想されて、どちらの方が望ましい？

色々とミスったので再投稿

bool TryGetHoge(Hoge **ppHoge)
っていう関数があるとする

戻り値が false であったばあい、*ppHoge は
1. NULL が代入されている
2. 全く手付かず
どちらの方が連想されて、どちらの方が望ましい？

>2. 全く手付かず
意味不

>>306
オプショナルを真似て自作すればいいじゃん
template <class T, class U> class optional { ... } ;
optional<string, Hoge> MakeHoge(Param p) { /* do something */; if(good) { return Hoge(p); } else { return "ERROR_XXX"; } }
optional<string, Hoge> obj(MakeHoge(p));
if(obj) { obj->hello(); } else { cout << optional_cast<string>(obj) << endl ; }
こんな感じのインターフェースで十分だろ

>>309
エラーが発生した場合
�@保証なし
�Aメモリリークなどが起こらない保証
�B関数を呼ぶ直前まで巻き戻る保証
基本的に数字が大きいほど親切な設計
ただし数字が大きいほど無駄なコストが掛かる場合が多い
コストが気にならない処理なら常に�Bを心がけよう

>>307
残念ながらifstreambuf_iteratorはそういう風に使うものじゃない
charかwchar_tしか使えないものと思うべし
（traisを定義したらうまくいくのかもしれないけど、まずそういう使い方しないのでよく分かんない）

>>307
boost::serialization 使え

>>308
実際に存在するasprintfという関数だと実装で真っ二つなんだよなぁ
ただC++だとまずそのプロトタイプがどうなのよ？

C++なら普通参照じゃね？ってことか
newして返されてもなー

の前に、*pHogeの型はHogeだから
NULL代入ってのがよく分かんないってことか

確かな話、Hoge * GetHoge() でエラー発生時に NULL 返すのが正しいわな

>>312
bool Piyo::Process(Foo * pFoo)
{
　return pFoo->TryGetHoge(&this->pHoge);
}

利用者がその項目の数字が大きいほうを「予想する」ほど、設計者に大して親切な、呼び出し側の処理になる

bool Piyo::Process(Foo * pFoo)
{
　Hoge * pH;
　if (pFoo->TryGetHoge(&pH)) {
　　this->pHoge = pH;
　　return true;
　} else {
　　return false;
　}
}

で、利用者はパッと見、どういう処理だと予想するかなって話
俺が利用者として>>309を見たとき、
　1. 戻り値が true であれば、Hoge を指すポインタが *ppHoge に渡される
　2. 戻り値が false であれば、少なくとも Hogeを指すポインタが *ppHoge に渡されない
　　　（つまるところ、未定義）
と予想する
つまり、設計者としては *ppHoge はどうなってもいい、という考えでコーディングしてもいいのだろうか

>>316
お前が何をいっているのか理解不能状態

>>315
まさにそれの話やで
C#ならout引数にnullなりdefaultなりをつっ込まれることが予想できるんだが・・・

ごめん
引数がHoge*に見えてた

ぶっちゃけるとそういう細かい違いは「プロジェクトによって異なる（プロジェクト内では揃えたほうがいい）」以上の答えはないよ
その時々でサイコロでも振るか多数決でもすればいい

エラーが発生したならその後は*ppHogeの値を利用してはいけない、
って意味でドキュメントには
　この関数がHogeの取得に失敗した場合はfalseを返し*ppHogeの値は不定となる。
って書いておいて実装は好きにすればいい。

どうなるか規定してあれば使う側でどうとでもするよ

>>313, >>314

アドバイス、ありがとう。

参考書に　template <typename T> istreambuf_iterator(istream &stream);

との記載があったので、 T != char でも使えるのかと思ったのだけど、難しそうですね。

だったら、なんで template <typename T>　などと書かれているのだろかと疑問が湧いてきますが。。。。

T = char or wchar_t の２種類（１種類ではない）で使うから　template 宣言されてるの？

boost::serialization　を調べてみます。

template <typename charT, typename traits = char_traits<charT> > だな
あくまで文字型を指定することを想定して作られてる

意図的にメモリを断片化させてヒープ使用量を大きくする単純なサンプルないですか？
アプリ起動からどの程度でprivate bytesの上昇が落ち着くか見たいんだけど、自作のアプリじゃ処理を繰り返しても一向に横ばいにならなくて。
リークはしてないはずだけど同じ処理を100回ぐらいするとなぜか50KBくらいprivate bytesがぽこっと上がってメモリリーク疑われてます。

リークはしてないはずという自信はどこから来るのか

valgrindなりページヒープ使えって

10000回で5MBなら間違いなくリークしてる

質問
テンプレートクラスをヘッダファイルと定義を書いたcppファイルに分けて記述した場合、
これを更に他のファイルからヘッダのみインクルードし具体的な型にして使おうとすると、
その具体的な型の定義が見えないらしく、ヘッダかどこかで具体化してやる必要があります・・・か？
つまり、
テンプレートクラスの宣言をヘッダファイルに、定義をｃｐｐファイルに別々に書いた場合、
使うには一々具体化してやらねばならず、例えば将来定義する新たな型に対してはその都度
具体化してやらなければなりませんか？
言い換えると
任意の型に対しこれを適応するには宣言と定義別々に書いてはだめ、ということですか？
長くてスイマセン

>>330
例えばこういうやり方はできる

/*swap.hpp*/
#ifndef SWAP_HPP
#define SWAP_HPP
template <typename T>
void swap(T& lhs,T& rhs);
#include <swap.inl>
#endif

/*swap.inl*/
template <typename T>
void swap(T& lhs,T& rhs)
{
　T tmp(lhs);
　lhs = rhs;
　rhs = tmp;
}
cppはつまり具体的な型がないとコンパイルできない

>>331
ヘッダにcppインクルードしちゃうんですね
そんなやり方が有りとは
２重定義になったりしそうと思うのは杞憂ですかね？

cpp違うのか、inl...
別に記述することはできるが、h-cppの組みでは無理そうですかねぇ
というのもこれまではテンプレートクラスは使わずよく使う関数・クラスをヘッダに宣言
cppに定義を、というスタイルでやっていたのでそのスタイルを保てるかなーと思ったんですが

>>326
template<unsigned U>struct h{char a[U];h<U>*next;};
template<unsigned U,unsigned RB,unsigned R=RB&~1>h<U>*const f(){
h<U> r[R]; for(int i=0;i<R;++i)r[i]=new h<U>;
for(int i=0;i<R;++i){r[i].next=&r[i+2];delete r[++i];}
return &r[0]; }

334の配列と返値無茶苦茶だった。まいいや

nothrow信者向けのSTLっぽいライブラリってありますん？

>>330
テンプレートクラスは定義も直接クラス内に書くのが一番だよ
外に出すと記述がやたら複雑になって読み辛いから

クラス内に書くとinline扱いになるけど、実質大して変わらない
（最適化レベルが上がれば大体の処理系でinlineの有無は関係なくなる）

>>336
Googleに入社すれば好きなだけ使えるかと

なるほど、どちらが良いかは一概にはいえないってことか
未定義の線で進めることにするよ

天ぷらクラスのメンバは外に書くとめんどくさい
中に書くと関数の一覧性が見えにくい
どっちつかずだよ
template <class T> class hoge {
public:
/* 宣言 */
void foo(void);
void bar(void);
void baz(void);

/* 定義 */
void foo(void) {}
void bar(void)
void baz(void);

みたいに分けれたらいいのに

他の言語じゃ一覧性なんてないからそこは別にどうでも
オブジェクトブラウザやアウトラインみたいなので見ればいいじゃんいいじゃん

>>326
そんな方法より、newとmalloc、deleteとfreeをオーバーロードかマクロで置き換えて、
確保されたメモリのアドレスがちゃんと解放に渡されてるか調べたほうが確実だろ。

VC++ならメモリリーク検出関数があるぜ

ツールの静的解析は既にやってるし、new、deleteも問題ないんだよね。
メモリのスナップショットとって解析したけどアプリ分のリソースに問題なさそうだし。
スレッドをバカバカ作成するポンコツアプリだから断片化してる可能性があるかなと。
常に斜めにメモリが上がるんじゃなく、不特定のタイミングで100回に1回ぐらい50KBくらい上がるってなんなんだろう？

リソースリークの可能性は？

>>345
RAIIは徹底しててその状態なの？

本当にリークしてるのかってことがまず問題。そして

> ツールの静的解析は既にやってるし、new、deleteも問題ないんだよね。
> メモリのスナップショットとって解析したけどアプリ分のリソースに問題なさそうだし。
本当に問題ないかは最終的に原因が判明したあとで原因ではなかったところについてしかいうことはできない。
真犯人(=リークの原因)が明らかになるまでは可能性のある人全て(=リソースを扱う全ての箇所)が容疑者。

＞new、deleteも問題ないんだよね
と書いてるけど、自前でnew/deleteやってんのか？

質問の仕方が悪かったみたいですね。すみません。
リークしてない前提でヒープをバシバシ使いメモリを断片化させる作りの悪いアプリを使い続けたときの動作を検証したいんです。
OSがデフラグして動きが安定するか、それがどんなタイミングなのか、またOS毎に違いがあるのか。
半年ぐらいかけてメモリの増加量を1/10ぐらいにして、もう分らなないので外部のコンサル会社に調査依頼したら、
「リーク以外にメモリの断片化がありますね」って回答なんだけど、断片化については運用環境で違うから環境毎に検証して、うちのアプリと動作を比較したいんです。

>>350
そういえば、windowsだとマルチスレッドの場合、ランタイムはスタティックリンクするとリークするってのがあったと思うけど、それはどうかな？

断片化くらい沢山newして歯抜けでdeleteすればいいだけだろ

メモリを必要分確保して自前で管理したら断片化しないが。

>>352
そのnew、deleteの繰り返しが断片化の原因なんだが。
一度、確保したらアプリ終了までその領域を使い回せば断片化なし。

>>354
お前は何を言ってるんだ？

なんか用語の意味がずれてて話がかみあっていないような。

一般的にいわれる断片化による問題ってのは空き容量は充分にあるのに
空き容量以下だけどある大きさ以上の連続した領域が確保できなくなるってもので、
謎のメモリ使用量があるっていう>>326の話とは違うものだろ。

>>326がいってるのは任意の大きさでなく既定の大きさ(固定や2のべき乗)でしかメモリ確保できない環境での
要求量と確保量のずれによる無駄の話なんじゃないのか。

>>351
以前はそれもあったのでリークしないほうの新しいAPIに置き換えてます。

>>353
自前で使う分はなんとかリファクタリングしたんですが、スレッド生成とかでもヒープを使用するとかで、スレッド部分は見直したけどまだあるみたいです。

アプリ起動時からメモリ領域の再利用が始まり安定するまである程度期間がかかるらしいんだけど、その安定ポイントがいつなのか説明できなくて。
「メモリ使用量は少し上昇してますが、これはＯＳのオーバーヘッドで時間がたてば落ち着きます」って説明できればベストなんだけど、今その時間を調べてるところで。
逆にそれで落ち着かなければまたリークを見直す必要もあります。

いろいろすみません。

なにそのjemalloc
要求を2の累乗にしろってのも馬鹿な話だよなアレ

リークしているように見える原因はLow Fragmentation Heap割とガチで

>>356
OSのある環境だと「連続領域が確保できなくなる」→「新しい連続領域がプロセスに割り当てられる」
ってことが起こるから、違う話だとは思わんな。

double test_fn(){ cout << "test fn called " <<endl; return 100;}

auto fn_obj=std::ptr_fun( test_fn);


なんでエラーになるんだ
std::ptr_funは関数オブジェクト返すはずなんじゃないの？

>>361
ひとりごとのつもりじゃないなら完全なコードとエラーメッセージ貼れよ。

>>361
test_fnの引数が一つもないからダメ

スクール水着を履いてオナニーしてます。

mapみたいに1対1の対応じゃなくて
候補キーが2ついじょうあってそのどれからでも効率よく検索ができるようなmapを
STLを組み合わせてパパっとつくれますか？

値としてアドレス持っときゃいいんじゃないの
どこかに実体は必要だけど

shared_ptrでいいじゃん

挿入削除が倍以上の負担になるからハッシュテーブルならまだしも二分木だときついな

C++0xの可変長テンプレートで、引数の総数を知る方法を教えてください

ググったらすぐに見つかったわけだが
http://en.wikipedia.org/wiki/Variadic_template
sizeof...(Args)

>>370
ありがとう。
日本語しか読めなくて。

あるクラスのコンストラクタでメンバ変数のcharをnewした場合、ヒープ領域を確保すると思いますが
クラスのヘッダーにchar name[MAX_PATH]と定義してクラスをnewした場合、ヒープかスタックどちらの領域を使用しますか？

ヒープ

>>373
ありがとうございます。
と、いうことはクラスをdeleteする時にメンバ変数も同時にdeleteされるということですね。

>>374
自分でnewした奴は勝手にdeleteされないよ
スマポを使え
それかデストラクタにdelete書いておくか

char name[MAX_PATH]はnewしてないからdeleteの必要ないだろ

間抜けな回答はスルーでよいですよ

初心者が真に受けたらまずいだろ

+ hoge
　+ shapes
　　- PointShape.h
　　- CircleShape.h
　　- BoxShape.h
　- ShapeManager.h

1ヘッダー1クラスかつフォルダ構造と名前空間名を一致させるものとする
例えば、hoge::shapes::CircleShapeクラスは"hoge/shapes/CircleShape.h"に存在する

全ての〜ShapeクラスはIShapeクラスを継承している
ShapeManagerクラスはIShapeクラスを使用する

この状況で、"IShape.h"はどこに置くべきなんだろうか
hoge::ShapeManagerが使うインターフェイスだから"hoge/"に置くべきか、
それとも素直に"hoge/shapes/"に置くべきか

hoge/shapesに置くべきだろう

ShapeManagerもshapesに置かないの

下のコードをgcc 4.6.1でコンパイルすると、自分の環境ではコンパイル中にsegmentation faultするのですが、コードに問題があるのでしょうか。
それとも単にgccのバグ？
ちなみに、(1)の関数をコメントアウトして(2)の関数のコメントを外すとちゃんとコンパイルできます。

template <int n>
class foo
{
public:
constexpr foo() : array_{}, sum_{} { }
// (1)
template <typename ... Args>
constexpr foo(Args... args) : array_{args...}, sum_{make_sum(args...)} { static_assert(sizeof...(Args) == n, "invalid"); }
// (2)
/*template <typename ... Args>
constexpr foo(Args... args) : array_{args...}, sum_{} { static_assert(sizeof...(Args) == n, "invalid"); }*/

// (1)
constexpr int sum() const { return sum_; }
// (2)
/*constexpr int sum() const { return sum_impl(0); }*/

private:
constexpr int make_sum(int value) const { return value; }
template <typename ... Args>
constexpr int make_sum(int value, Args... args) const { return value + make_sum(args...); }
constexpr int sum_impl(int i) const { return i == n ? 0 : array_[i] + sum_impl(i+1); }

int array_[n];
int sum_;
};

int main() { constexpr int n = foo<4>(1, 2, 3, 4).sum(); return 0; }

(1)をクラステンプレート外に出したらちゃんと動くね（constも取り外して）
こりゃgccのバグだな

＞コンパイラ内部エラー: Segmentation fault: 11
＞完全なバグ報告を送って下さい。
＞適切ならば前処理後のソースをつけてください。
＞<http://gcc.gnu.org/bugs.html> を見れば方法が書いてあります。

staticメンバにしても動くね

>>379
名前空間とフォルダ構成を一致させるのはめんどいしファイル探しにくいし親が複数だとルール崩れるしでいいとこないぞ
Project-Namespace-Class.hpp
こっちがオススメ

http://codepad.org/wwipNSob
これの上の方法を文字２つじゃなくて文字列でやりたいんだけどどうにかならないかな
Func<"[]">(3, 5);
Func<"[)">(3, 5);
っていう感じにしたい

素直にtype出しにしろよ
namespace braket{struct close{enum{v=0};};struct open{enum{v=3};};struct lopen{enum{v=2};};struct ropen{enum{v=1};};}
template<typename T>struct Func;
template<>struct FNC<branket::close>{〜};

>>386
何でテンプレート？関数オブジェクトとかじゃだめなの？

>>381
ShapeManagerは説明のために適当に名づけたもの・・・なんだけど、
ShapeContainerみたいなコンテナ系のクラスであればshapes/に置くべきかな？

>>385
結構前からその方法を使おうか迷ってたんだが、踏み切れないな
どこか、ある程度の規模のプロジェクトで使用されていた実績でもあればやってみたいんだが

>>385
フォルダわけされてないほうが探しにくいような気がするし、
「親が複数」がどんな状況を指してるのかよくわからない。

探すも何も普通は覚えてると思うけど
分からなけりゃ検索すりゃいいじゃん

１つのフォルダにぶち込んでアプリで管理だろ
手動でフォルダ分けとか前時代的すぎる

Javaは名前空間でフォルダ分けしてるね

関数オブジェクトを使って、変数と配列の加算をしたいんだけど、
algorithmを見ると配列同士の操作しか無いように見える。
これってvalarray使えって事？速度より利便性が欲しいんだけど。

>>394
配列の各要素にみんな同じ変数の値を足すなら、 transform() じゃないかな？
なんで valarray が出てくるのかよくわからないんで読み違えてるのかもしれないけど。

Javaだとフォルダ分けがメンドイんでインターフェースに突っ込んでるわ。
C++ likeな使い方ができる。

interface Arg extends arguments.Package{} //パッケージインポート
interface Package //パッケージ定義
{
        //公開するクラスだけ中に書く
         class TypeA{}
         class TypeB{}
}
//公開しないクラスは外に書く
class TypeC{}

>>395
transformじゃ配列(コンテナ)同士じゃないとできなくない？
動かないイテレータを自作するなら別だろうけど。

>>397 transform(c.begin(), c.end(), c.begin(), f) で。

ああ、bind1st,bind2ndか。解ったありがとう。

sumみたいな処理をしたいのかな？
名前忘れたけど専用の関数が標準にあるよ

>>400
accumulate？

そうじゃなくてやりたいのは
std::transform(v.begin(), v.end(), v.begin(), std::bind2nd(std::plus<int>(), value))
みたいなのでしょ

>>401
やろうとしてたのはそういうヤツ。

bindはC++11だと非推奨だっけ？

>>403
古いbind1st bind2ndはね。代わりに強化された汎用のbindがある。

boost::bindみたいなもんか

boost::bindのが入ったんでしょ

_1とか_2とかのやつだっけ

あの気持ち悪い仕様のまま標準に入るの？

気持ち悪くないC＋＋なんて存在しないよ

lambdaあるんだから11でbindなんかいらんだろ

魔術的な実装だというだけで
使う分には使いやすいんじゃない？

俺はstd::functionにメンバ関数入れるときなんかによく使うな

>>410
lambdaでbindの代わりをするには手間がかかるうえにわかりにくくなるだけのときもある。

std::map<int, double> func(std::vector<int> const & v, std::list<double> const & l)
{ return std::map<int, double>(); }

int main()
{
using namespace std;
using namespace std::placeholders;
// funcの引数の順序を入れ替えた関数オブジェクトを作る
auto f2 = bind(func, _2, _1);
auto f3 = [](list<double> const & l, vector<int> const & v) { return func(v, l); };
}

バインダをインクルードするコンパイル時コスト
std::functionの実行時コスト(型消去など)
名前空間をタイプする労力
これならautoとλを使ったほうがマシ

struct array{
　int *p;
　int &operator[](int t){return p[t];}
　const int &operator[](int t)const{return p[t];}
};

こういうconstメンバ関数が冗長なのをなんとかできませんか？

どうにもならない
関数内がどうしようもなく複雑になるようなら
実装をまとめてconst_castするのも手だが
まあ普通はそこまでする必要はないわな

getter以外でconstと非constが共存することはほぼないから我慢する

const_castもどきオブジェクトの皮一枚を被せればいいんじゃないかな
やった事無いし、オーバーロードが面倒で反ってラビリンスな感じだけど
struct array{
int *p;template<typename T>struct eqint{T v;const eqint<T>&operator=(T a){v=a;return *this;}operator const T()const{return v;}};
eqint<int>&operator[](size_t t)const{return *reinterpret_cast<eqint<int>*>(p+t);} };

>>417 arrayとかstringとかのライブラリを作って勉強しているので、
getterのような関数ばっか書いててこう思ったのです。

>>416 関数が複雑になったときはそうしようと思いますが、
最適化に影響がでないでしょうか？

int &operator[](int t){return (int&)((const array&)*this)[t]);}
const int &operator[](int t)const{return p[t];}
こうすると、constによる最適化には影響ない？

int &operator[](int t){return p[t];}
const int &operator[](int t)const{return ((array&)*this)[t];}
こうすると、constによる最適化がなされない可能性がある？

>>418
> operator const T()const{return v;}
intを例に書きましたが、汎用性を持たせると、やはり参照を返したくなってラビリンスでした。
といはいえ、１つ作れば良いので、この方法を検討してみます。

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

同じ名前のヘッダってどうやって作成すんの？
Sequenceフォルダ内に
Parent.h
Gameフォルダ内に
Parent.h
を作成したいんだけど…

無理です

え？　VC++だとできるぞ。

あぁ別のフォルダだったか・・・
じゃあ普通に作ればいいんじゃないか

>>420
VC++の話だったら手作業でフォルダとファイル作って後でVC++に項目追加する

ごめん言葉が足りなかった
Sequenceフォルダ内に
Parent.h
Sequenceフォルダ内のGameフォルダに
Parent.h
を作りたいんだ。サンプルでは作成出来てるんだけど、
俺が作ろうとすると、すでに存在すると言われ作れない。

>>425
vc++のソリューションエクスプローラじゃなくて、
普通にOSのエクスプローラでファイルを追加してから、ソリューションエクスプローラにドラックアンドドロップする

>>422 >>423 >>424 >>426
出来た！皆ありがとう！！

なんでVCはフォルダとフィルタ別構造なの

扱うのが簡単だから

可変長の配列をファイルから読み込みたいんですが、どうしたらいいんでしょうか?

ttp://codepad.org/qllGCv19

>>430
ポインタを値渡ししてるだけじゃデータ受け取れないぞ

まずmain関数内でpの領域を確保しないのは何故？
readFile関数内で割り当てるつもりなら、main関数では
readFile(&p, &size);
の形で呼び出すでしょ。まぁそんな作りには普通しないと思うけど。

>>432
読み出すサイズがファイルを読み込まないとわからないんです。
自分もありえないつくりだと思っています。クラスでも作ります。

>>431
参照渡しにしました。というか2重ポインタ?でやったほうがかっこいい

関数の名前下のほうがいいよね。
void readFile( int* &pOutArray, int* pOutSize )
void readFile( int* &pRefOutArray, int* pOutSize )

途中で書き込んでしまいました

返信ありがとうございました。

bool readFile(std::vector<int>& output);
とかでよくね？必要ならファイル名でも増やせば
もっとエラー処理が必要なら例外でも使うがよろし

>>419
> constによる最適化
何のこと？たぶん何か勘違いしてると思うんだけど。

ファイルの丸読みはメモリがもったいない
かといってストリームのエラーを毎度チェックするのはめんどくさいからまる読みしたい
僕はどうすればいいんだ

>>437 stream.exceptions(badbit | failbit)

>>428
フォルダだと非ツリー構造(グラフ構造)を表せないから
単一継承ならツリーにはなるけど、多重継承はツリーにならんでしょ
継承に限らず依存関係はグラフ構造がメインなんでフォルダわけってのは使い辛い

>>436
constの効果を以下のように認識しているのですが、
間違っているところがあればご指摘ください。

1 値を書換えられない。値を書換えられる型に暗黙に変換できない。
2 constがついている変数からは値を書換えないことが保証されているので
キャッシュからメモリへの書戻しをスキップするなどの 最適化を行える。（実装依存?）
3 constがついているものを外してしまうと 外したことを認識できる場所では2の最適化を
行わないようにしてくれる(inline展開された場合など?)
4 constがついているものを外して値を書換えると 外したことを認識できない場所では、2の最適化が
そのまま行われて、キャッシュ不整合になる。 (constを外すと動作保証外になる要因?)

この場合はconstを外しても値を書換えないので4が起ることはないと思うのですが
3が起ってしまう可能性を考えたのです。

constは最適化には影響しないんじゃなかった？

コンパイラによっていくらでも変わりそうだな

struct hoge { static int const v = 0; };
void Func(int const & v) { const_cast<int &>(v) = 1; }
int main(void) { Func(hoge::v); return 0 ;}

未定義？

元々constな変数をconst_castしての変更は未定義だな

元々constなののconstはがして変更ってのは未定義
元がconstじゃないものをconstにしたものなら大丈夫だったはず

と言うことは関数の外からどちらがくるかわからないから
Funcの動作も未定義ということか

Funcにhoge::vを渡すのが未定義なだけ
元々constじゃないものを渡す分には問題ないはず

はず、はず、じゃあれなので規格から

5.2.2-5
[Note: a function can change the values of its non-const parameters,
but these changes cannot affect the values of the arguments
except where a parameter is of a reference type (8.3.2);
if the reference is to a const-qualified type, const_cast is required
to be used to cast away the constness in order to modify the argument's value.
Where a parameter is of const reference type a temporary object is introduced
if needed (7.1.5, 2.13, 2.13.4, 8.3.4, 12.2).
In addition, it is possible to modify the values of nonconstant objects
through pointer parameters. ]

関数は非const仮引数の値を変更出来るが、
パラメータが参照型 (8.3.2) である場合を除いて、
実引数の値に影響を与えない。
（const参照の場合は、実引数の値を変更する為に　　　　　←←←←←
const_castを使ってconst性を除去する必要がある。）　　　　←←←←←
仮引数がconst参照である場合、必要であれば
一時オブジェクトを導入出来る (7.1.5, 2.13, 2.13.4, 8.3.4, 12.2)。
（訳注：const参照にリテラルを渡した時に一時オブジェクトを作成して渡すというアレの事）
さらに、ポインタの仮引数を通じても、定数でないオブジェクトの値を変更することができる。

>>440
生成時点で const が付いていた値について、 1, 2 は正しい。
const_cast で書き換えるようなコードは書けるが、その場合は
未定義動作となるので動作保証する必要が無く、それにより
最適化が可能になる。

後から参照やポインタとして const が追加されたものについては
const_cast やグローバル変数経由などによる書き換えが可能なので
2 のような最適化はできない。

ただし const に頼らず、値アクセスの間にある操作をすべて
解析した上で 2 と同様の最適化を行うことは可能。

const 外しを認識したところで、対象の値に生成時点で const が
付いていたのを知らない限り、生成されるコードに影響は無い。

実測しろ

constはprivateみたいな可視性の制御に過ぎないって禿が言ってた。

ただしコンパイル時定数は除く

スレチだったらスマン。
ゲームのプログラマってアルゴリズムどうしてんの？
全部自分で考えてる訳じゃないよな？本やネットから引用してるよな？

Gemsとか

STGの敵の動きとかは既存のもの影響はどうしても受けてるだろうし
入力に合わせて自キャラが動くなんてのはほとんど定番的なやり方があるだろうけど
独自のルールやゲームシステムがあるならそれに合わせた独自のアルゴリズムを考える必要があるだろ

>>453
ほとんど自分で考えてるよ。

コアな部分ではほとんど再利用可能なので最利用する
アプリケーション独自の部分は拘ってクールなアルゴリズムとか考えても費用対効果薄いからやりたいことを素直にシンプルに書く

質問させてください。

行列の指数計算（eの行列乗というか）をC++で行いたいのですが、
そのような計算ができるライブラリなどを知っている方がいたら教えてください。

C言語によるスーパーLinuxプログラミングで紹介されてる

…されてたような気がする

boostあたりにあるんじゃねえの

boost::numeric::ublasとかで出来るんじゃね
blasは行列計算とかで業界標準だとかなんとか聞いた覚えがある

質問です。
グローバル変数として宣言したオブジェクトのコンストラクタを呼び出すスレッドは、
main()を呼び出すスレッドと同じということは、規格は保証してくれるのでしょうか。
どうかご教示夜露死苦お願いします。

くれます

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

vc++で、タスクトレイにアプリケーションを格納する方法を教えてください。

>>466 http://ja.lmgtfy.com/?q=vc%2B%2B+%E3%82%BF%E3%82%B9%E3%82%AF%E3%83%88%E3%83%AC%E3%82%A4

ソート済みの配列から一定の値の範囲を取得するアルゴリズム教えてください。
const int a = {4,5,6,7,8,9,10,11};
から6以上10以下を取得するような感じです。

6と10をサーチするだけ。

追加すると。
a[0]〜a[7]で6をサーチしてi=2がわかったら
a[i]〜a[7]で10をサーチ。
すこしだけ計算量が減る。大差はないと思うが。

１：a[0]4〜a[7]11から6-10の範囲(10-6)/(11+1-4)=50%、(11-4)*50%=4、
　4〜11から6の位置(6-4)/(11+1-4)=25%、(11+1-4)*25%=2
　a[2-1]とa[2-1+4]の値を確認
２：両方大ハズレなら (a[2-1]かa[2-1+4])と(a[0]かa[7])の組み合わせで範囲が残ってる方の値を基に１：からやり直し
２’：片方ハズレなら(a[2-1]〜a[7])か(a[0]〜a[2-1+4])の値を基に１：範囲の再算出をやり直し

小さい配列なら前から順に見ていくだけ
大きいなら二分探索二回でおｋ

>>472 後者
探索位置が2つの探索対象の間に入るまでは共通だから単純に2回ではない

std::lower_boundとstd::upper_boundで

既存の二分探索を二回使えよ。

２回使います

あかん綺麗に書けない
template <class BidirectionalIterator, class T>
std::pair<BidirectionalIterator, BidirectionalIterator> my_range(BidirectionalIterator begin, BidirectionalIterator end, T from, T to)
{
BidirectionalIterator pos1 = std::find(begin, end, from);
//std::reverse_iterator<T::iterator> riterfrom(to);
//std::reverse_iterator<T::iterator> riterto(from);
//ForwardIterator pos2 = std::find(riterfrom, riterto);
// 組み込み配列には逆反復子はないので自前で調べる
BidirectionalIterator pos2 = --end;
do {
if (*pos2 == to)
break;
if (pos2 == begin) {
pos2 = end;
break;
}
--pos2;
} while (true);

return std::make_pair(pos1, pos2);
}
int main()
{
const int a[] = {4, 5, 6, 7, 8, 9, 10, 10, 11};

std::pair<const int*, const int*> p = my_range(a, a + sizeof(a) / sizeof(a[0]), 6, 10);

if (p.first != a + sizeof(a) / sizeof(a[0]) && p.second != a + sizeof(a) / sizeof(a[0]))
std::copy(p.first, p.second, std::ostream_iterator<int>(std::cout, " "));
}

あほっぱい

>>478
本当はコメントアウトしてあるように

std::reverse_iterator<T::iterator> riterfrom(to);
std::reverse_iterator<T::iterator> riterto(from);
ForwardIterator pos2 = std::find(riterfrom, riterto);

で一発で後ろから調べられたはずなんだけど、intは逆反復子を持ってないと
コンパイラに叱られた

>>474
lower_bound()とupper_bound()は既存の順序を崩さないように要素を挿入出来る
位置を返すだけなので、該当の要素が存在する事を確実にするにはbinary_search()
を併用しないといけないから、この問題は見てくれよりも難しいぞ

STLがラムダ式を使う事を前提に書いてあればいいのに const T& val とか
決め打ちで値を入れるから使いにくい
find_if()ならラムダ式は使えるが最初に見つかった一個しか返さないし

うむ
互換性無くしていいからもっと使いやすい標準ライブラリを追加してほしいわ

でも禿の事だからやらないんだろうな
というかもうC++11の規格固まっちまったし
右辺値参照によるスピードアップだけだな

const int a[] = {4, 5, 6, 7, 8, 9, 10, 11};
const int n = sizeof a / sizeof *a;
const int *l = std::lower_bound(a, a + n, 6);
const int *u = std::upper_bound(l, a + n, 10);
std::copy(l, u, std::ostream_iterator<int>(std::cout, ","));
これじゃだめなん？

>>484
lower_bound()は該当要素が存在しなければ「存在したであろう位置」を返す
だから4,5,11とかだと11の位置をを返してしまう

upper_boundは該当要素が存在しなければ「存在したであろう最後の位置」を返す
だから1,2,3とかだと3の位置を返してしまう

あ、間違い
×3の位置を返してしまう
○past-to-the-3の位置を返してしまう

const_iter result_low = beg;
const_iter result_upp = end;

while(true) {
const_iter cen = GetCenter(result_upp, result_low);
if(*cen < low) result_low = cen; continue;
if(*cen > upp) result_upp = cen; continue;
result_low = BinSearch(result_low, cen, low);
result_upp = BinSearch(cen, result_upp, upp);
}

break;抜けてた

ソート済みなんだから頭から順番に探すのが確実だな
でも要素数が多くなるとなんとかlower_boundとかbinary_searchを使えないかと思う

>>468が一般的な『値の集合からm以上n以下のすべての値を取得する』
という問題の具体化にすぎないなら元の集合にmやnが含まれている保障も必要もない。その場合なら>>484で充分。

>>484では重複して検索してるから遅い

重複？upper_boundの検索範囲はlower_boundの結果で絞り込んでるけど
それと線形探索の話をしてるのもいる中で二分探索同士の差で遅いとかいってもな

>>485-486
確かに4,5,11,endに対してlower_bound(...,6)は11の位置を返す。
ただしupper_bound(...,10)も11の位置を返すので結果は要素数0の空の範囲となりなんの問題もない。

配列の参照に変換するoperatorはどのように書けば良いですか?

template<typename T, int SZ> class array
{
T t[SZ];

operator T (&)[SZ]()
operator T (&())[SZ]
(operator T &())[SZ]

{return t;}
};

typedef T (&A)[SZ];
operator A() { return t; }

typedef、decltype、std::identityを使わず、その場で完結する方法を知りたいです。

無理です

法と@に何か関係ってあるのだろうか・・・
sting　ssss;
ssss.substr(0,ssss.find('@'))
ssssの文字列に法の字が入っていると法の字が消えて代わりに・,って入ってしまう

>>498
"法"はシフトJISで0x4096
@は0x40

だからじゃね

おっと0x9640だ
エンディアンが逆になってるのか

なるほど

うーん@を改行代わりにするのは失敗だったか

>>498
文字コードは Shift-JIS だな
'@' は 0x40、'法' は 0x96, 0x40 だから find() が 2 バイト目にヒットする

回避策は _mbschr() を使うか、地道に自分で文字コードをチェックしながら検索
するか （Shift-JIS の 2 バイト文字の範囲はググれ）、処理する文字コードを
Shift-JIS 以外のものに変えるしかない

サロゲートペアにはもっと泣かされるぞ

俺は改行マークを'@'から"@@"に変更した。コレなら被らないな

しかしこんなこともあるのか。覚えておくか・・・

それって "法@" でも大丈夫なの?

ソ系ダメ文字とポ系ダメ文字について読んでおくといいよ
多分同じ問題にぶつかる

void Hoge()
{
　int alpha;
　int * pBravo;
　const int * pCharlie;

　for (size_t i = 0; i < 100; ++i) {
　　alpha = this->GetAlpha(i);
　　pBravo = this->GetBravo(i);
　　pCharlie = this->GetCharlie(i);

　　// alpha、pBravo、pCharlie それぞれを使用する。
　}
}

void Piyo()
{
　for (size_t i = 0; i < 100; ++i) {
　　const alpha = this->GetAlpha(i);
　　int * const pBravo = this->GetBravoPtr(i);
　　const int * const pCharlie = this->GetPiyoPtr(i);

　　// alpha、pBravo、pCharlie それぞれを使用する。
　}
}

Hoge()とPiyo()、以下の視点から見て、どっちの方が良いコード？
　�@ 最適化を期待した上でより高速に動作すること
　�A ソースの綺麗さ（見易さ）

Piyo()

>>505
なんかダメそうに見えるな・・・
>>506を調べておくことにするよ

http://smdn.jp/programming/tips/check_ngchar/

これなんかはC#だけど同じような問題だ
「全角半角混在」でぐぐるとたくさん引っかかる

boost::program_options::variables_map
がstd::mapをpublic継承しています。

ソースはここhttp://www.boost.org/doc/libs/1_47_0/boost/program_options/variables_map.hpp

仮想デストラクタを持たないクラスを
public継承したら危険だと考えていたのですが、
variables_mapのケースはどうなのでしょうか。
boostはレビューがあるし、そう簡単に危険な
コードは入り込まないと思っていますが・・・。

>>511
class CBase {
};

class CSub : public CBase {
};

CBase* pbase = new CSub;
delete pBase;
こういうのがダメなのであって
CSub sub;として使う分にはなんの問題もない

>>512
ありがとうございます。
ということは、variables_mapは
public std::map<std::string, variable_value>* p
= new boost::program_options::variables_map();
delete p;
と使ってはいけないということですね。
使っちゃだめよとドキュメントに書いてあるか要確認ですね。

ご存知の方もいらっしゃると思いますが、こっちのスレにも貼っておきます

謹んでお悔やみ申し上げます。我々は、偉大な逸材を失った
ttp://tech.slashdot.org/story/11/10/13/0328230/dennis-ritchie-creator-of-c-programming-language-passed-away

>>508
レスありがとう
言い切ってくれるのは非常に助かる

2ch ソースに言い切ってもらったから何だよｗ
不都合な事実が出てき瞬間オワるぞ

何いってんだコイツ

C++03でunique_ptrっぽいスマポを作るにはどうする？
shared_ptrより軽くてコンテナに入れられるスマポが欲しい

ヘッダからコピペすればいいいんじゃないかな

内部で持ってるポインタをmutableにして
コピーコンストラクタをムーブ的に実装すればなんとか

>>520
できた、ありがとう
auto_ptrってシンタックスの問題でしかなくて、論理的にはコンテナに入れてもいいものだったのね

まあちょっと怖いけどね

さらにboost::optionalで包む

boostありならboost::interprocess::unique_ptrを最初から使うだろｗ

コンテナに入れる用途ならptr_containerでいいだろ

> auto_ptrってシンタックスの問題でしかなくて、論理的にはコンテナに入れてもいいものだったのね
だめだろ。
03までのコンテナ周りの実装はコンテナ内の要素の値をコンテナ外やコンテナ内の複数の場所にコピーすることがあるので
コピーでポインタの所有権が移るauto_ptrを入れるとしねるぞ。

VC++は何故かそのままauto_ptrを入れられたような

>>526
どこの実装よそれ

普通にremoveとかヤバそうじゃね

>>527
VC6時代の糞仕様のことは忘れてください

ポインタの配列でremoveなんて使わないと思う

コンテナ内部で無意味にコピーをとって置いても規格違反じゃないならアウトか

std::unordered_mapとstd::mapって、コンテナに要素を追加した時は
コンテナ内の他の要素を指すポインタ無効になりますか？

実装上はならんだろうけど規格で保証されてるかはわからんなぁ

>>533
unordered_mapの場合、要素への参照は無効にはならない。イテレータは無効になるときがある。
mapの場合、参照もイテレータも無効にはならない。

イテレータは無効になる事があるけど
参照は無効にならないってのは
どういう実装なんだろう？

>>536
iteraotrは少なくとも次のelementへのiteraotrへのreferenceを持っているのだけれど、
containerにelementsを追加した時に順序的に対象のiteraotrの次のelementに入る場合はそのiteratorは無効になる。
しかし、referenceというのはiteratorのallocateには直接関わりを持たない構造になっている。
iteratorがelementへのpointerを持っていると言えば分かりやすいかな。
だからiteratorが無効になってもreferenceは無効にならないし、elementsを追加する度に
他のelementsもstd::vectorみたいにallocateしなおしになったら大変なコストになるでしょ？

listなんかだとノード自身が次の要素への参照を持ってて
追加時にその参照を書き換えるから大丈夫なんだけど
unordered_mapだと何が問題なんだろう、と思ってね

ハッシュテーブルのバケツはdequeが使われてることが多いからかな。

イテレーターで巡回するときに要素の追加が発生する場合はどうするのがいいのだろう
�@そのまま巡回（挿入する値とタイミングによっては、新しい要素が巡回されたりされなかったりする）
�A追加分は別のバッファにとるように書いて巡回の後で追加する（追加した分は巡回しない）
�B�Aと同様だがもう一本バッファを増やして、追加された分も巡回して、新たに追加される要素がなくなるまで繰り返す

>>539
dequeだと参照も無効にならねーか？

>>541
横からだが、ハッシュテーブル自体の参照は無効になっても要素への参照は無効にはならない。

ランダムで1〜55の数値を出力。1回出た数値は2度と出さないようにするコードを書け。

わかんねぇ・・・

>>543
宿題は宿題スレへ。
60個出力しろって言われたら無理だから、出力する個数についても情報を添えてな。

C/C++の宿題片付けます 152代目
http://hibari.2ch.net/test/read.cgi/tech/1312201995/

線形合同方の値域と周期を調整するだけ

int main() {
std::vector<int> v(55);
std::iota(v.begin(), v.end(), 1);
std::random_shuffle(v.begin(), v.end(), &std::rand);
for(int i : v) { std::cout << i << std::endl; }
}
こんなんでどうか

>>543
長さ55のブール型の配列作ってn-1で中身がTrueかFalseか比較すりゃ良いだろ

あ、nはランダムな数値の入ってる変数な

C++でゲーム作成をしたいのですがオブジェクトの使い方で躓きました。
分からないのは、【�@関数の戻り値にオブジェクトを使う時】【�Aオブジェクトインスタンス化して処理を書く時】の2つです。
まだオブジェクト指向を始めたばかりで、どこを直さないといけないのかさっぱり分かりません。

ソースコードを下に書きますので、よろしければどこが悪いか教えてください。

//モンスター一覧
class MonstersList{
public:
Monster Item(char key); 　　　　　//�@
};

//キーに対応したモンスターを取得する
Monster MonstersList::Item(char key){
Monster objMonster;　　　　　　　//�A
return objMonster;
}

//固有のモンスター情報を持つ
class Monster{
public:
int Index;
char Key;
char Type;
char Name;
char Text;
bool GetMonster;
};

>>549
(1):
Monsterクラスが巨大じゃなければ、宣言はそれでいいよ。
場合によっては、Monster Item(char key) const;にすべきだけど。

(2):
これも別にいいんでないかい?

何が問題だと思っているのか知らんが、エラーが起きるならエラーコードを。

つーか、オブジェクト指向云々以前のレベルじゃね?
char Name, Text;とか、どんなデータを持つ積もりだよ。
モンスターの名前や情報なら、std::string Name, Text; だろ。

その部分は誰も問題にしてないっていうね

MonstersListなんて作らずstd::map<char,Monster>にすればいいんじゃね
直さなくて済みそう

>>550
とりあえずエラーコードを書きます。

MonstersClass.cpp
.cpp(6): error C2146: 構文エラー : ';' が、識別子 'Item' の前に必要です。
.cpp(6) : error C4430: 型指定子がありません - int と仮定しました。メモ: C++ は int を既定値としてサポートしていません
.cpp(6) : error C4430: 型指定子がありません - int と仮定しました。メモ: C++ は int を既定値としてサポートしていません
.cpp(6) : warning C4183: 'Item': 戻り値の型がありません。'int' を返すメンバ関数とみなします。
.cpp(17) : error C2143: 構文エラー : ';' が 'MonstersList::Item' の前にありません。
.cpp(17) : error C4430: 型指定子がありません - int と仮定しました。メモ: C++ は int を既定値としてサポートしていません
.cpp(17) : error C4430: 型指定子がありません - int と仮定しました。メモ: C++ は int を既定値としてサポートしていません
.cpp(18) : error C2146: 構文エラー : ';' が、識別子 'objMonster' の前に必要です。
.cpp(18) : error C2065: 'objMonster' : 定義されていない識別子です。
.cpp(19) : error C2065: 'objMonster' : 定義されていない識別子です。

>>551,553
お二方の仰る事は正しいんだと思うのですが、
自分の現段階では飲み込むスキルが無いっぽいです。
もうちょっと良く考えます。

設計の話じゃなくて文法レベルの話だったのか＾＾；

>>554
エラーのメッセージを読んで一つ一つ順番に対応すればいいよ

型指定子がありません - int と仮定しました。メモ: C++ は int を既定値としてサポートしていません
となるのは何が引っかかってるんでしょうか？

>>557
MonsterとMonsterListを書く順番変えてみな
エラーがだいぶ減るから

>>558
おおおおおおおおおお
確かに直りました！

ありがとうございます。

エエエエエエ

> 型指定子がありません - int と仮定しました。メモ: C++ は int を既定値としてサポートしていません
↓翻訳
この行に宣言されていない型識別子が使用されています。

>>549がまんまソースコードだとしたら、
> Monster Item(char key); 　　　　　//�@
この地点でコンパイラは"Monster"が何か分からない（型名であるかも分からない）ので、上のエラーが発生する。

VC2008対応のMSDNライブラリってどこにあるんですか？

ストリームのオープンモードをあとから調べられないの？
bool IsTextStream(std::fstream const & f);
的な関数を作りたいんだけど

fd()で取れるからそれに_setmode()を2回

>>564
さんくすこ

テキストファイルの読み込みで、指定した区切り文字ごとに読み込むことができる関数って無いかな
具体的には　テキストファイルで改行した所までを１文字列として読み込みたい
これをループさせて全ての行の文字列を取ってくる。　みたいな事をしたい

>>566 std::getline()

>>567
ｻﾝｸｽ!

getline

getline関数を使おうと思ったんだけど、「引数が違います。もしくは足りません。」みたいなエラーが帰ってくる。（C2780）
getline関数の引数教えてくだしあ。

>>570
つ [std::ifstream::getline()]

使ってるコンパイラのマニュアルに書いてある

超初心者で申し訳ないんですが質問させてください。

文字列を指定する際の”a"と'a'はどのように使い分けするのが正しいんですか？

'a'は文字列じゃなくて文字（っていうか整数）

'a' == 97
"a" == { 'a', '\0' } == { 61, 0 }
"hoge" == { 'h', 'o', 'g', 'e', '\0' } == { 104, 114, 106, 104, 0 }

'abcd'
は？

>>576
そういう書き方は出来ない

implementation-definedだろ。

intになることだけは決まってるんだっけ

>>576

'a' -> char型の値
　char test = a;

"a" -> char[]型の値
　char test[] = "a";
　char test[10] = "a";

'abcd' -> char型の値・・・ではない
　char型（1バイト）に4文字も入らないのぉ・・・

手元のvc2008はprintf("0x%08x\n", 'abcd');で0x61626364と出る
もう一文字増やすとコンパイルエラー

規格では処理系定義らしい
こういう仕様だ、と決めてあればどういう値でもいいしコンパイルエラーでもいい

jsでは同じだよね？そっちから入ると少し混乱しそう

>>579
Yes

>>581
古いCコンパイラとの互換性を考慮したのかね
C++になったときコンパイルエラーで統一してくれてもよかったのに

処理系定義なのはマルチバイト文字用の仕様じゃないのかな
まあチャンクコードのような使い方を考えてる可能性もあるけど
（ビッグエンディアンじゃないと意味ないけど）

逆にすりゃいいだけだろ

可読性がだな

文字列”ABC , ef , ghi”から"ABC"っていう文字を取得するっていうのはどうすればいいんですか？
VBでいうsplit関数みたいなのは無いですか？

strtok

>>588 http://www.google.co.jp/search?q=C%2B%2B+split

つ[sscanf(foo, "%[^,]", bar);]

strtok関数って第一関数にchar配列しか指定できないの？　std::stringとかもできるのかな

>>592
中身書き換えるから、std::stringだとダメ。

>>588の場合strtok使えないんじゃないか
charは一文字しか入らないから失敗した記憶があるんだが

ttp://codepad.org/7ZwUoWoN
前後の空白も切り取りたいって話か？

ゲットライン関数で取ってきた値を切り取る―で失敗した苦い記憶

>>588
http://codepad.org/24QWR6tq

>>588
http://boost.org/libs/tokenizer/tokenizer.htm

std::list<Base> baseList;
std::list<Derived> derivedList;

std::list<Base> * pBaseList;
std::list<Derived> * pDerivedList;

pBaseList = &baseList;
//pBaseList = &derivedList; // error C2440 �@

//pDerivedList = &baseList; // error C2440 �A
pDerivedList = &derivedList;

�@、�Aはどうやってキャストしたらいい？

reinterpret_cast

reinterpret_cast< std::list<Base> & >(derivedList)

>>599
std::list<Base>とstd::list<Derived>は何の関係もない型

reinterpret_castしても死ぬだけだお

レスありがとう。
リスト要素がポインタだとしても、キャストする方法は無いと考えていい？

typedef std::list<Base *> BaseList;
typedef std::list<Derived *> DerivedList;

BaseList baseList;
DerivedList derivedList;

BaseList * pBaseList;
DerivedList * pDerivedList;

pBaseList = &baseList;
pBaseList = &derivedList; // error C2440

pDerivedList = &baseList; // error C2440
pDerivedList = &derivedList;

// ---

class Hoge {
　virtual BaseList * GetList() = 0;
};

class Piyo : public Hoge {
　virtual BaseList * GetList() { return &this->list; }
　DerivedList list;
}

基本クラスのオーバーライドの戻り値に関して、派生クラスでは戻り値もその派生物を返したいんだけど、どうしたらいいんだろう

C#のジェネリックと違って共変性も反変性もないから簡単には無理。

ぶっちゃけポインタを格納するコンテナならreinterpret_castで動くと思うけど保証されない。

DerivedListを定義して何をしたいのか不明だけど、
PiyoはBaseListを保持していて、その要素にDerived *を突っ込むのが普通だと思う

class BaseList {
protected:
  std::list<Base*>  list_;
public:
  class iterator {
    std::list<Base*>::iterator  base_;
  public:
    iterator(std::list<Base*>::iterator i) : base_(i) {}
    Base* operator*(){ return *base_; }
  };
  iterator begin() { return iterator(list_.begin()); }
};

class DerivedList : public BaseList {
public:
  class iterator : public BaseList::iterator {
  public:
    iterator(std::list<Base*>::iterator i) : BaseList::iterator(i) {}
    Derived* operator*(){ return static_cast<Derived*>(BaseList::iterator::operator*()); }
  };
  iterator begin() { return iterator(list_.begin()); }
};

うーん…

Cstringとstd::;stringの違いって何？

Cstringもstd::;stringも存在しません

w

typedef void* Bucchake;

608は何処へ

D3DXVECTOR3 p;
の時
p = D3DXVECTOR3(0,1,2);
と
p.x = 0; p.y = 1; p.z = 2;
はコンパイラが気を利かせて処理速度的に等価になるのでしょうか？
それとも差が出るのでしょうか？

↓コンパイラによるとか気の利かない回答するアホ

どうせインライン化されるでしょ

上のほうが最適化しやすいよ

>>613
その質問をする人が、そんなレベルの最適化さえも必要な程に
高度な要求をされる可能性はごくごく僅かだから、
気にしない方が良いと思う。

コンパイラとそのオプションスイッチに依ります。マジで

亀レスになってしまった。すまん

>>607
自分でも色々やってみたんだが、どのみち遠回りな実装になってしまう
>>606の言うとおり、素直にコーディングした方が良さそうだなぁ

>>613
前者の方が最適化されやすいと考えていい
D3DXVECTOR3はともかく、ベクトル化を狙ったコードの一部だとしても同様

>>620
616で既出

>>621
知ってた

これって64bit環境じゃレジスタ使うからアウトだよな。
64bitでもvolatileとか使って上手いこと動かせる方法ってある？
void Function( double x, double y, double z )
{
　double *trivector = &x;
　trivector[0]; //x
　trivector[1]; //y
　trivector[2]; //z
}

最初から配列で渡そうぜ

環境関係なく規格上アウト
規格無視するならdoubleの引数をスタックに積む関数の呼び出し規約を指定すれば期待通りに動くこともあるだろ

64bitの呼び出し規約は最初のいくらかをレジスタ渡しして、
その分スタック空けた状態で残りを積んでcallだっけ（順番逆だが）
ただし、スタックは16バイト境界に合わせる、と
>>623はﾑﾘﾀﾞﾅ

なんでこんなキチガイなことをやりたがるんだと思った

色々試すのはいいことだと思う

64bitでcdeclとか使えないの？

ゲーム技術の本でそういう書き方してる本があった

インラインアセンブラすれば・・・と言いたいが
64bitだと使えないんだよな
何でだろ

VC++ならあのコードが動いてしまうようになるデバッグ用コンパイラオプションがあるが救済したくないな
コードを直すべき

こういう用途で、配列に代入しなおすとコストが2度の代入が無駄だと思ったんだが、
virtual Vector Function( double x, double y, double z )
{
　return Vector( reinterpret_cast<(*)[3]>( &x ) );
}

そもそもレジスタ渡しになるんだったら、配列への代入コストに気を使う必要もなかったな。

メモリからメモリへのコピーより
レジスタからメモリへの代入の方が速いべ

どうしてもそこがボトルネックになるのならいろいろ試すのもいいかもしれないが……それでもその書き方はないな
その関数の場合素直に書くのが一番速いと思うよ

コンパイラだって少数のトリッキーなソースより大多数の最適化しやすい普通のコードを最適化するよう方向に傾倒するだろうしな

古株のユーザに不利な最適化をしたら寝返られるからそんなに甘くない

>>630 書名晒せ

inlineでpacker作れと言いかけたけど需要なかった

C++から Access2010のファイル、例えば C:\DAT\TEST.accdb を起動するにはどうしたら良いでしょうか
パスワードを含めたいので、GetObjectみたいのでなくオートメーションで起動したいのですが

これ、http://support.microsoft.com/kb/306686
見たのですが、マクロの起動は不要で、択画面の表示も不要で、Access2010のファイルを起動して自身は終了するだけで良いのですが
どの部分を使ったら良いのか全く分かりません

全くの素人でスミマセン

>>640
つ[ShellExecute()]

>>641
スミマセン、それだとパスワードが渡せないんです
Accessオブジェクトを作って、AccessApplication.OpenCurrentDatabase(引数にパスワード渡せる) メソッドで開かないと

>>642
http://msdn.microsoft.com/ja-jp/library/ff965871.aspx

>>643
スミマセン、DAOやADOでAccessデータベースにデータアクセスするのではなく、アクセスアプリケーションを開きたいんです

少しかっこよくシングルトンを作ろうとしたのですが、
コンパイルエラーで詰まってしまいました。
どうすれば通りますか？
ttp://codepad.org/f10NR3dM

循環してるんじゃね

class Single : public singleton<Single>

Singleが完成しないとsingletonが完成しない。
singletonが完成しないとsingletonが完成しない。
以下無限ループ。

関係ないけど、C++なんだからSingletonなんてダサいもんじゃなく、
モノステート使ったら？
モノステート：全てのメンバー変数はstatic、メンバー変数にアクセスする関数は全て非static

>>646-647
ああ、そうか落ち着いて考えたらループしてまね・・・
やはりnewしないとこの形では無理なのですね

モノステートがええですかね、助かりました、ありがとうございます。

mainで初期化してアプリ用のMain関数に引数で渡せばいい。シングルトンは甘え

何十階層も引数で渡していくの？
途中の階層で全く使われてなくて下層に渡すだけとかでも？

何十回層も書くほうがアホなので設計を見なおす

デバッグ用スタックトレースとログは、引数渡しすると、
通常運転時にデッドウェイトになりすぎてマズイ。
あと固定デバイス関係も引数で引きずると、
高速ループで引数渡しが発生してこっちもマズイ。

ただ、設定とかスレッド間変数をモノステートやら
シングルトンやらにするのはアホ。

>>652
どうするのがいいの？

グローバル変数にしたいだけなのにシングルトンとか間違ってる

グローバル変数は駄目だと言われたら如何なる状況でも使うべきでないと思うらしい

>>655
よほどの理由が無い限り広域変数を使うもんじゃないのは確かだろ。
せいぜい許されるのは、PCIデバイスを開発する時とか、
割り込み制御するときぐらい。その時でさえstaticにするのに。
b = function( a );
こう呼び出したとき、functionの結果にa以外の何が
影響するかなんて到底想像できん。
下手したら無限ループや、不安定な分岐が発生する。

> class Single : public singleton<Single>
この形自体は問題ない。
ただしこの形の場合singletonの中でSingleの(完全な)定義が必要なものを使っていたらだめ。

template<class T> class Base
{
// T t; // だめ
// enum { E = sizeof(T) }; // だめ
T * pt;
T func() { return T(); };
void func2( T t ) {};
};

class Deri: public Base<Deri> {};

int main()
{
Deri d;
return 0;
}

ソフトウェアの構造によるが正解

>>657
やるならポインタで、ってことですかねー、どうもです。

クロスプラットフォームでzip rar lzhファイルの中身のファイル名を列挙したり、特定のファイルをメモリ内に解凍できたりするライブラリないですか？
できれば渡したファイル名の拡張子から自動判断で処理切り変えて抽象化されて纏まっているようなのがいいです
すれ違いだったらすいません

>>653
何を？設定の事か？
設定なら、設定を読み込んだオブジェクトが、
既存の設定対象のプログラムを操作するようにする。

ProcessorA a;
ProcessorB b;

Configuration config;
config.RestoreA( &a );
config.RestoreB( &b );

あくまで設定は本来プログラム内にある値を外部に置いてるだけ。
実処理してる部分は、設定は、プログラム内で定数で渡された値と同様に扱うべき。
実処理が設定部に依存してちゃいけない。

>>660
クロスプラットフォームなのに拡張子でファイルを判断するライブラリは
多分無いと思うぞ。拡張子でファイルを判別するOSはWindowsぐらいだし。

>>662
そうなの？
じゃあファイルの中身見てファイル形式判断して処理切り替えてやってくれるのでいいからない？

ゲームプログラミングでサウンド再生処理をクラス化した場合にシングルトンにせずに引数で渡して使った方がいいの？

タイトル画面とかプレイ画面とかエンディング画面とかでソフトウェアを分けると思うんだけど
そのどこからでも使われるわけで引数で渡すと面倒なんだけど

シングルトンにする事と引数で渡す事の関連性が分からん

シングルトンやグローバル変数は絶対使ったら駄目で引数にすることで回避すべきと主張してるんじゃないの

適材適所

getterでおｋ

>>669
？

下駄履きでもどうぞってことだろ。言わせんな、恥ずかしい。

シングルトン使わずにサウンド再生クラスを使うゲームプログラムのうまいソフトウェア設計を答えろや

引数で渡せばぁー？

基本構造をグラフ化してたら、深くまで設定引きづらなきゃならんとかいう事は起きないはずだが？
>>665の話を例にざっくり書くとこんな感じ。

TiltlePhase title;
PlayPhase play
EndingPhase winner_ending, loser;

//Bindで次に実行する状態をヒモ付する
title.BindPlay( &play );
play.BindSuccessFinish( &winner_ending );
play.BindSuccessFinish( &loser_ending );

ConfigLoader loader;
ConfigSaver saver;

// 設定の読み込み、書き出しをヒモ付する
loader.Bind( &play );
loader.Bind( &title );
// 他略

saver.Bind( &play );
// 他略

title.BindLoad( &loader );
play.BindSave( &saver );

Driven( &title ); // 初回phaseを指定してゲームの実行を開始する

こんなんするの？センスなくね

main{
　　Sound snd;
　　while(1){
　　　　mainloop(snd);
　　}
}

mainloop(snd){
　　switch(state){
　　　　case TITLE:
　　　　　　　title_func(snd);
　　}
}

title_func(snd){
　　if(...){
　　　　　some_func(snd);
　　}
}

some_func(snd){
　　if(...){
　　　　snd->play_se(SE);
　　}
}

前半が誤字だらけだった。
一応修正。

TiltlePhase title;
PlayPhase play
EndingPhase winner_ending, loser_ending;

//Bindで次に実行する状態をヒモ付する
title.BindPlay( &play );
play.BindSuccessFinish( &winner_ending );
play.BindBadFinish( &loser_ending );

良く分からんけどloaderとかsaverってのがグローバル変数みたいなものじゃないの
外部ファイルを介してデータを入出力してるようなイメージしか持てないんだが

>>677
いや。まず関数の中に設置されるし。
loader,saverに渡したオブジェクト以外の値はなんら影響はしない。
もっと言えば、広域変数のようなクラスの利用者側が意図していない振る舞いが起きることはない。

Drivenが解らないと、BindXXXXの部分が何をしてるか解らないかもしれないんで、
一応一番簡単なDrivenの実装書いて補足しとく。(この短い例はゲームに不向き)

void Driven( Phase *phase )
{
       while( phase = phase->Do() );
}

Doを実行すると、phaseがBindXXXで取り込んだオブジェクトの
ポインタを、一つ選んで返す。PhaseのオブジェクトはDoが呼ばれている間、
オブジェクト自身に課せられた課題(Play画面とか)を実行する。
BindXXXXはポインタを取り込むだけで、取り込んだポインタのメンバー関数を呼んだりはしない。

音を鳴らしたい場所に
Sound::play(SE);
と一行書けばいいだけなのになんでそんあ面倒なことするの
としか思えない

playだけじゃダメなの？

音だけじゃなく画面とか全てを一貫して管理するからだよ。

>>680-681って>>665じゃ無かったか。
画面と設定値の管理だと思って書いて話が食い違ってた。
余計なこと言ったわ。ごめん。

loaderって毎回ファイルから値読むのか？
起動時設定覚えておけないじゃん

int main(void) {
try {
Framework f ;
f.init(...);
AppMain(f);
}
catch(...) {
if(f)
f.term();
errstr << "fatal err" << endl;
return 1;
}
return 0;
}

void AppMain(framework & f) {
SPScene s(new RootScene);
while(s) {
s->attach(f);
s->run();
s->detach(f)
s = s->getNextScene()
}
}

これでいいじゃん
引数で渡すっていっても毎フレーム律儀に引数で渡す必要はない

>>684
意味がわからんが、loaderは、読み込み指示が
あったときだけ実行される。
読み込んだ値は各種phaseが適切な形で保持する。

>>685
何に向かって言ってるのか分からんけど、
そのやりかだとシングルトンと同じで拡張性がない。
1.Frameworkクラスがシーンより後に定義され、
各シーンが抽象化クラスを通して、
framework に
アクセスしている場合はダウンキャストが必要。
2.Frameworkクラスがシーンの前に定義してある場合は
メンバー追加のたびにFramework を変更するので、
シーンをライブラリ化できない。

更に言えば新しいシーンを追加したとき、
新しいシーンはFramework 以外のオブジェクトを
設定として受け取れない。

シングルトン否定厨はバカでＦＡ

引数で渡すコストがーっていう人はシングルトンのgetInstanceのコストは無視なの？
引数ならinline化でコスト減らせるかもしれないけどgetInstanceはその性質上最適化できないよね

シングルトンはインスタンスを1つしか作らないならグローバル変数と同じ
getInstanceに置き換えてるだけだもの

通信とか、複数がありうるけど無制限は許されないときに使うもの
シングルトンて名前がよくないんだな

インスタンスが複数あったらシングルトンにならないだろ

シングルトンの本質は生成するインスタンス数が制限できることだろ
良く使われる利用法では1個しか作らないだけで

「シングルトンパターン」はインスタンスがひとつの場合
複数作る場合はシングルトンもどき
元々デザインパターンってよく使われるのをパターン化したやつだしそんなもん

シングルトン使わずにサウンド再生クラスを使うゲームプログラムのうまいソフトウェア設計を答えろや

論理的に１つでないとダメなんじゃなくてハードの制限とかで１つになるんだから
カウントして例外投げるほうがわかりやすくていい
数値オーバーフローで例外投げるときと同じ感覚

オブジェクトの数を一つだけにできるメリットってなんなん今市有効活用法が見つからないんだけど
それよりもどこからgetobjしても最初のgetobjでだけオブジェクト生成して２回目以降は状態が保存されてることの方がメリットとして大きいと思うんだが

>>696
単なるstatic変数とかでいいんじゃね？

本に書いてあることそのまま垂れ流してるだけだろ

>>692
面白い見方だな
FILE[] はシングルトン？

複数作るのは別名があったようななかったような

ファクトリなんちゃらだろ

>>692
シングルじゃねぇー

namespace hoge { class _fuga ; }

_を前につけるのはどんな場合でもダメなんだっけか？

どんな場合でもというわけではない
でも細かい規則を覚えるの面倒だしつけるなら後ろにしてる

>>696
Nullオブジェクトとか、不変オブジェクト。あと状態のないI/O系。

Example *example1 = Null::Instance();
Example *example2 = Null::Instance();

Mode *mode1 = AlphaMode::Instance();
Mode *mode2 = AlphaMode::Instance();
mode2 = BetaMode::Instance();

実体が一つなんで無駄が無くなる。
I/O系は、元々副作用があるから、シングルトンでも
引数渡しでも大して変わらん。

あと、シングルトンをグローバル変数替わりに使うのは間違い。
シングルトンのInstance();を呼び出すのは、他のクラスであれば
コンストラクタを呼ぶタイミングに限らないといけない。

__は駄目
_＋大文字も駄目
_＋小文字はグローバル名前空間でだけは駄目

だっけ？

>>706
実は、全大文字変数もだめ。
全大文字はマクロ用だからね。

>>707
そんな規則はねえよ（規格上）

>>708
規格には無いが、禿がマクロ用だから絶対大文字で変数を書くなといってる。
http://www.libjingu.jp/trans/bs_faq2-j.html#constplacement

マクロで変数上書きしても警告でなかったり、エラーにならない事があるからな。

リンク先間違えたこっちだ
http://www.libjingu.jp/trans/bs_faq2-j.html#Hungarian

マクロを全部大文字で書かないバカは死んだほうがいい

#ifdef __cplusplus
# undef >>711
#endif

そこは自分好みの命名規則について語ってるところだし
規格中にもoffsetofとか非予約語小文字マクロが混ざってるのがいたい

まあ自分が書くときは大文字にするけど

C++11を勉強しないとダメなの？

windows.hのmin/maxだけは死ぬまで許さない

far、near、THIS、smallモナ

hage*

homu

>>709
確かに全て大文字はマクロ用として使うのが普通だけど
今は規格の話だ

>>715
ほーれほーれ
int c = (std::min)(a, b);

>>715
#define NOMINMAX

>>714
autoとかラムダ式とかはガチで便利やで？

>>714
VCがC++11にほとんど対応してない以上、仕事としては覚える意味はない。
趣味で何か作ってるなら覚えてると便利。

>>721
stdafx.hいじらせてもらえないんだ・・・

>>724
自分のcppの範囲内だけ有効になるように書いても問題ないよ

NOMINMAXするにはもう手遅れじゃん
min, maxを#undefするしかない

しかないってカッコで括るとかusingするとか型を明示するとかあるだろ

コンストラクターのアドレスを高速に取る方法って無い？
シンボルテーブル漁れば取れるっちゃ取れるけど遅い。
ちなみに用途はデバッグ用。
int Function()
{
   ScopeTrace tracer;
}
スタック情報を元に関数の開始と終了時点で
ログを出力するクラスを作ったんだが、
呼び出し元の関数がインライン展開されると
呼び出し情報が消しとぶんで、ScopeTrace tracer( Fuction );
ってな感じでアドレスを渡してる。コンストラクターの
アドレス取得だけが手間がかかってひたすら遅い。

インライン化を抑止したほうがいいんじゃない？

しかし、VC++は何でtypedefで別名つけるのが好きなんだろ？


ワレ、いいかげんにせいよ！この糞マイクロが！
と言いたくなる。

インライン化自体はしてもらわないと困るんだよね。
ScopeTraceの呼び出しはインライン化で消し飛んでくれる。
デバッグじゃなく通常モードだと、関数のアドレス代入と
if文2回だけのコストしか掛からないから、それはそれでありがたい。

typedefじゃなかったらどうやって別名つけるんだ

>>730
コンパイラによって型が違うからだろうけど、
それにしてもやりすぎだよな。WPARAMとかDWORDでいい。

>>727
そうしなくて良い方法について話してるんだが

そういやWinAPIってハンガリアンな時点でクソだけど、
構造体や型名が大文字ってのも糞だな。
どういうつもりで命名規則作ったんだろ。あのタコども。

WORDとつく型名なんて作らなければよかったのに

intですらINTってつけてるからなぁ

LPCTSTRとかもうね

>>733
それだと64bit環境で困っちゃう

>>737
一貫性してていいと思う
でもPINTなどのポインタのtypedefはいらんよね

constもいらんね

16bitと32bitの過渡期にはintが16bitの処理系と32bitの処理系があったりしてな・・・
で、なんでtypedef int LONGにすりゃいいのにlongが64bitじゃねぇんだよ。

ま、スレ違いなので続きは他所で。

newでクラスの配列を実体化する場合、コンストラクタに引数を渡せないということは、
デフォルトコンストラクタを用意して、後で引数を渡すのが一般的ですか？
それとも何か一発でやる方法が？

std::vectorを使うのが普通

Cでも、確保したメモリーを0ぐらいでしか初期化できないし、
実際配列をデフォルト値以外で初期化する意味もないしな。
やるとしたらテンプレートでラップして初期値を与えるぐらいじゃね。

char配列でメモリ確保してreplace newを使うんだよ

んな中途半端な事するぐらいだったら、
fill使えばよくね。
Type *array = (Type*)new char[n];
fill( array, arrray + n, Type( x, y ) );

と思ったが、delete[]でデストラクタがこける気がする。

>>737
大文字で名前統一したいなーっていうのはまだ許せるんだけど
WinMainでいきなりint使ってるるところに怒りを抑え切れない
INT使ってやれよって

>>743
#include <vector>
class hoge { int x, y ; public: hoge(int x, int y) : x(x), y(y) {} } ;
int main(void) {
std::vector<hoge> v;
v.reserve(100);
for(int i = 0; i != 100; ++i)
v.push_back(hoge(i, i));
return 0;
}

>>743
C++11限定なら
ttp://ideone.com/3pGz0

ちなみに03でもこんなことはできたり
ttp://ideone.com/KTWB9
(おっと、ideoneだと不定値にならんな、ローカルで試して)

>>744-750
ありがとうございます
とりあえずvectorなら自分にも使えそうです
他の方法は勉強いたします
ご教示感謝

テキストファイルの読み込み時に
指定した行を1行だけ読み込む為の関数って無いですか？

あるウインドウに指定した画像が描画、表示されてるかチェックする関数ってありませんか？

>>746
placement newな

>>752
ないから自作

行先頭の位置をキャッシュしとけ

static変数とnew使う以外で、関数から、抽象化クラスのオブジェクトを返す方法ねぇかなぁ。

malloc

ヒープ確保すんのが嫌なんだから変わんねぇよ

boost::optional みたいな仕組みで返せばいいと思うよ

>>757
TMPで派生クラス全部のサイズとアライン調べて、全部入るストレージを用意
ストレージをラップしてインターフェースを整える
ラップしたクラス内で配置newして返す
ってやれば出来るけどぶっちゃけ高速化をアロケータ−に任せてスマポ返すほうが正解だろうな

関数の引数に「インデックスまたはキー」のどちらかを指定してね
みたいに表現するにはどうしたら良いんですか

>>761
やっぱアロケータ自作か。

>>762

class Order;
class Index:public Order;
class Key:public Order;
Exampe operator[]( const Order& );

>>762
知らない訳はないと思うが、単純にオーバーロードすりゃいいんじゃね。

インデックスとキーが同じ型だったらどうしよう

>>766
traitsでラップすればいい
っておい、利用者はどう使い分けているんだ？？

static_cast<const Key&>( complex_order );
static_cast<const Index&>( complex_order );
とか
complex_order.To<Key>();
complex_order.To<Index>();
とか
Key &key = complex_order;
Index &index = complex_order;
とか
好きなのを選べ。

シングルトンの実装を考えているんですが、インスタンスの確保の仕方で迷っています

(1) 静的メンバ変数であるunique_ptr<>に、静的メンバ関数instance()内でnewで確保したメモリアドレスを入れる
(2) 静的メンバ関数instance()内で、static変数としてメモリを確保する

これらの実装に何か違いはあるんでしょうか？
あと、速度面では、やはり(2)の方が速いのでしょうか？

ttp://ideone.com/oMMR8

unique_ptrをわざわざ使う理由がわからん

賢く見せたいお年頃なんじゃね

スマートポインタだけにな！

どっちもダメな実装だけどunique_ptrを使うことでよりダメになっている

馬鹿はＣ言語だけで組めよ

>>769
まず
X xinstance;
では嫌な理由から説明してもらおうか。

>>769
まずSingletonを使わない事を考えろ。
次に、Monostateパターンを検討しろ。
それでもダメなら、本当に実体が一つでないと困るか
クラス図を書いて本気で考えろ。
そうすりゃ、どういう実装にすべきかおのずと決まる。

>>769
newはいらないよ。↓でおｋ
class Homu : noncopyable {
private: int init_;
private: Homu(void) : init_(0) {}
public: static Homu & Homu::instance(void) { static Homu homu; return homu; }
private: bool Homu::init(void) { ... ; init_ = 1; }
private: bool Homu::term(void) { ... ; init_ = 0; }
public: void func(void) { assert(init_); ... }
friend int main(void) ;
};
int main(void) {
Homu & homu( Homu::instance() );
if(!homu.init()) { msg.puts("error homu::init"); return 1; }
/* main code */
if(!homu.term()) { log.puts("error homu::term"); return 1; }
return 0;
}

>>775
別のシングルトンクラスがある場合に、どの順番でデストラクタが
呼ばれるのかはっきりさせたいんです
終了処理を明示的に記述して、呼び出した方がいいんでしょうか

>>776
どうしてもシングルトンが必要な場合について、教えてくだしあ

>>777
関数ローカルな静的変数ですか…
やっぱりnewするのはC++には合わないんでしょうか

それっぽくまとめてみました
状況によって、最適な実装を選択するしかないんでしょうか
ttp://ideone.com/7CrfO

>>777
場合によるだろ。
あとその組み方あんま良くないね。
未初期化か、初期化済みかは、未初期化を表すオブジェクトと、
初期化済みを表すオブジェクトで表現すべきだ。
bool値で判定するもんじゃない。

>>778

どうしても必要な場合 >>705

コンストラクタの定義内で、
別の引数のコンストラクタを呼び出すことって出来ないのですか？

VC++ 2010 Expressつかっています。
Javaだとそんな書き方したりしますよね？

よろしくお願いします。

C++11をお待ちください

C++11で可能になったがVC10では実装されていない

>>781, >>782
即レスありがとうございますっ！

落ち着いて考えると、
他にメソッド用意して両方からそれを呼ぶだけでイイか、
と思ったのですけど、
C++11 で実装されるって事は、あった方が便利って事なんですよね？
継承とか使ってると無いと不便になるんでしょうか？

>>778
そもそもシングルトンじゃなければ使う側で同じ関数内やクラス内に
変数の定義を並べるなどするだけで順番を確定できるのに。

その状況でさらにシングルトンを増やすとか、何がしたいのか。

数学関数をまとめたクラスとかシングルトンにするなよ

>>779
>未初期化か、初期化済みかは、未初期化を表すオブジェクトと、
>初期化済みを表すオブジェクトで表現すべきだ。
>bool値で判定するもんじゃない。
？？？

>>785
最初はそうしていたんですが、シングルトンにしろと
叩かれてしまいまして…

たぶん皆さん基本的に、static領域に確保するんだと思います
ただ、タイミングを指定してデリートできるようにするには、
やっぱり生ポインタしか駄目なんでしょうか？

できるだけ、例外安全に実装したいのですが…

あと、メモリの確保についてなんですが

○スタックに確保
○ヒープ／フリーストアに確保
○静的領域に確保

速度的にどれくらいの差があるんでしょうか？

スタック ＞＞ 静的領域 ＞ ヒープ／フリーストア
みたいな感じになるんでしょうか？

なんでデリートせないかんの

>>787
class Device
{
        PhisicalDevice *core;
        Device(void){DeviceUpdate(NULL)}
public:
        void DeviceUpdate( PhisicalDevice *device )
        {
              if( device )
                   core = device;
               else
                   core = NullDevice::Object();
        }

        static Device *Object()
        {
                  static Device object;
                  return &object;
        }
        /* 他メンバー */
};

>>788
> 最初はそうしていたんですが、シングルトンにしろと
> 叩かれてしまいまして…

どういう理屈で叩かれたのか、気になる。

>>789
異なるクラスのデストラクタで、順序に依存するリソース解放を行っているんです
１つのクラスに統合できればいいんですが、それだとカプセル化が壊れる…

こっちを取ると、あっちが立たない状態なんです

外部でデリートされる可能性があっても、スマポ管理のシングルトンを
注意して使えば、例外安全だしおｋかな。。

>>788
ヒープは確実に遅いが、スタック領域と静的領域どっちが速いのかは用途による。
単純な変数ならスタックが一番早い。

>>792
コードを上げてみ。

>>788
一般的にはこんなもんかね？
静的確保（実行時コスト０）＞スタック（レジスタ減算）＞＞＞フリーストア

初期化も含めれば割合的にどうでもよくなってくるし、起動時に済ませるんなら
なおさらどうでもいいと思うけど。

>>792
> １つのクラスに統合できればいいんですが、それだとカプセル化が壊れる…

どういうことなの・・・

>>784
メンバ初期化子使ってると、メソッド用意しても無駄だからね

>>791
他の開発者が誤ったコード書いても、致命傷にならないクラス設計してね、みたいな…

>>793
静的領域にメモリ確保した方が、newするよりも断然速いんですね。。

スタックが一番速いのは聞いたことあったんですが、
ヒープと静的領域の速度差がよく分からなかったんです

静的領域へのメモリ確保って、結構速いんですね。ありがとうございます

そういや、大抵の実装じゃ関数内static変数には分岐が入るから、
クラススコープの初期化の方がいい。

>>795
staticは大概レジスタに乗らないから、
スタックの方が速いべ。

まぁこの辺気にするぐらいだったら、
アルゴリズムをどうにかすべきだが。

静的領域へのメモリ確保は、単にプログラムロード時のメモリ使用量が変わるだけでしょ
まあ多すぎるとメモリが足りないとプログラムロードに失敗するという問題もあるけど
よほどでかい配列作らない限りは大丈夫だと思われ

シングルトンって一旦作ったらずっとそのまま使いまわすものじゃないの？
ローカルクラスみたいになってんの

singletonオブジェクトの終了処理の順番を決めたいなら、
意図的に終了処理の逆順でオブジェクトを生成するか、
終了処理を自前で書くか、だな
終了処理を実行する関数をオブジェクト生成時にatexitで登録しておけば
main終了後に勝手に終了処理してくれる
（クラスAとBで両方同じ関数を登録するので、二度呼ばれても大丈夫なように作る必要はある）

うーん、何とかして >>778 のサンプルコード36〜65行目を
修正して、クラス外でのインスタンス削除を禁止できないものでしょうか…

外部での削除を禁止したいので、デストラクタはprivateにするしかない
でもそうすると、スマポのデリータークラスが削除できない

といって、フレンドを設定すると、意図した用途で削除はできるけど
外部で同じスマポから削除されると、二重デリートになる…

これは詰んだかOTL

>>798
Singletonは、ガワだけにして本体を外に出せ。
そうすりゃ順番制御なんていくらでもできる。

int main()
{
       RealTypeA instanceA;
       RealTypeB instanceB;

       Singleton *object = Singleton::Object();
       object->ChangeInstanceA( &instanceA );
       object->ChangeInstanceB( &instanceB );
}

てか、その前にSingletonはヤメロ。せめてMonostateにしろ。

>>803
ポインタじゃなく参照で返せばdeleteするバカは減るだろ。

Javaみたいに、無名インナクラスが使えればいいのに…

>>802
自前で終了処理を書くことにします。

そもそも、関数ローカルな静的変数を使って実装した時点で、デストラクタの
呼び出し順がはっきりせず、Javaと似た状況になるんですから
Javaと同じように終了処理関数を明示的に呼ぶのが適切なんでしょうね

あと、関数ローカルな静的変数なんですが

メモリ確保…プログラムのロード時
コンストラクタ実行…変数宣言に制御が移った時

でいいんでしょうか？
基本は、大域変数と同じで、コンストラクタ実行が遅延される、という理解ですよね

コンストラクタ実行は、やはり変数宣言時ですね
ttp://ideone.com/Tj1BA

メモリ確保がロード時に行われるのかどうかは、確かめる術がないのであきらめますOTL
みなさん、アドバイスありがとうございました

初期化解放の順番を守りたいだけならカウンタ使えばいいよ
少し遅くなるけど事故るよりマシだから気にしない

>>804
シングルトン＜モノステートの理由は？

賢く見える

>>809
1.Singletonは実体が1つである必要がある場合に使うものだから。
　今回の質問者の言っているようなケースは大概そう用途じゃない。
2.モノステートは、見た目は他のクラスと全く変わらないため、
　テンプレートやらで扱いやすい。
3.上の理由によりnew,deleteも自然に可能。
4.呼び出し地点を観測できる。コンストラクタ、
　デストラクタで参照カウントとかも可能。
5.必要に応じ呼び出し側に合わせて制御もできるので
　整合性を取りやすい。

質問なのですが、
ある関数で正常に処理された場合は戻り値にオブジェクトを、
処理に以上が発生した場合などにはNULLか何かを返したいのですが、
return NULL;とすると"オブジェクトの型ではないから駄目"みたいなエラーがでます。

こういった場合はどうしたら良いか教えてください。

NULLじゃなく例外を投げる。

戻り値をboost::optionalにする

異常が発生したのにoptionalって・・・

例外を使いたくないならアリだろ

>>812
その関数の戻り値はポインタ型だよね？

>>811
なるへそ

>>813
例外は今ひとつ好くわかんないんですが
これから勉強しようと思います。

>>817
いえ、ポインタ型ではなくクラスの型(？)にしています hogeClass a(){} 見たいな感じです。

hogeClass a() {
　if (!flag) {
　　return NULL;
　}
}

↓

hogeClass * a() {
　if (!flag) {
　　return NULL;
　}
}

こうしてみ

>>819
ポインタじゃなけりゃNULLは返せん。
例外が導入された理由の一端でもある。

>>820
無理にNULLで返すようにさせるなよ。
>>819は例外のことすら知らんレベルだし。
どうしてもNULLで返さなきゃいけない理由を持ってないんだから。

これでいいじゃん
bool func(type & buff);

あぁ、多分色々と無理だろうな。>>820は無視してくれ
NULL は hogeClass に変換できない
戻り値の型は hogeClass だが、NULL の型は hogeClass * だから

皆さま、色々とサンクス！
参考にさせてもらって修正をかけたいと思います。

前に書いたコードを再利用しようとして読んでいたら、
std::mapのキーをintで使ってたのだけど、これをlistにしたら何か変わるかな？

>>826
比較に時間が掛かるのですごく遅くなりそう

listで大小比較どうすんの

>>826
数や目的にもよるけど、
基本読み出し計算量オーダーがO(logN)からO(N)になる

>>820
標準コンテナにはoperator<が最初から定義されている

std::vector<char> v(100) ;
void * p(NewData()) ;
if(p) { DeleteData(p) ; }

これがコンパイラに再配置されて

void * p(NewData()) ;
std::vector<char> v(100) ;
if(p) { DeleteData(p) ; }

こうなって
v(100)でbad_alloc、pがリーク
なんていう現象って起こりうるんですか？

>>827-829
レスありがとう。詳細を調べるのがラクになりました。

もうひとつお願いします。
namespace A
{
class Class B
{
static 型 hoge();
}
namespace D
{
型 hoge();
}
}
という感じのメソッドhoge()があるのですけど、何を意図してこういうつくりにするかわかります？
「静的クラスメソッドと名前空間指定した関数と」なんですけど、違いがわからない。
「どちらにするか」というルールが途中で変わって、片方は後方互換性のために残ったという感じが予想されますか？
それとも「静的クラスメソッドと名前空間指定した関数と」で用途が違いますか？

↑すみません。半角のインデントが消えました…。

namespace A
{
　　class Class B
　　{
　　　static 型 hoge();
　　}

　　namespace D
　　{
　　　型 hoge();
　　}
}

>>832-833
そのソースの意図はわからないけど
クラスの静的メンバ関数はそのクラスの非publicなメンバにもアクセスできるので普通の関数とは別物

レスありがとうございます。

本当に申し訳ないです。
「静的関数はpublicです」と書くのを忘れて、もう一回投稿するかしないか迷ってしませんでした。

おっしゃるとおりで、「private static メソッドである」且つ「static フィールドにアクセスしている」ならわかるんですよね。
ソースを追ってみると、プライベートのフィールドにアクセスしていなくて、
結局「namespace D」のfoo()に合流していました。

オーバーロード関数がたくさんあったので、まとめるのに時間がかかりました。
ここまで確認してから投稿すべきでした。申し訳ない…。

×「static フィールドにアクセスしている」
○「private static フィールドにアクセスしている」

×「private static メソッドである」
○「public static メソッドである」

落ち着け、俺！

>>679ってお前じゃないだろ
あと、静的関数メンバーは、staticに限らず
オブジェクトの変数を操作できる。
言ってしまえばfriend関数と同じ。
普通は静的変数を弄るよりこっちの用途の方が多いと思う。

class Base
{
protected:
      virtual int Value(void) const {return 0;}
      static int PeekValue( const Base &base )
      {
           return value();
      }
};

class Derived:private Base
{
public:
       void Example( const Base &base )
       {
             std::cout << PeekValue( base ) << std::end;
       }
};

間違えた。

class Base
{
protected:
      virtual int Value(void) const {return 0;}
      static int PeekValue( const Base &base )
      {
           return base.Value();
      }
};

template< typename T > class IsClassType {
typedef char One;
typedef struct { char dammy[2]; } Two;
template< typename C > static One test( int C::* );
template< typename C > static Two test( ... );
public:
enum { Yes = sizeof( IsClassType< T >::test< T >( 0 ) == 1 };
enum { No = !Yes };
};

ありがとう static 関数。

>>838
レスありがとうございます。
まず、>>638を名乗ったこと、申し訳ないです。
落ち着きがありませんでした。678は、「Boost総合スレ part9」で書き込んだ残骸です。

理解出来ました。
protectedは、意味は知っていたのですが、使ったことがなかったので教示いただいた用途は思いつきませんでした。
ありがとうございます。

>>831
結果が変わるような最適化は基本的に許されない。
一部のオブジェクトのコピーは例外。

ただし未定義動作に踏み込んでしまえばこういった点も含めて
何の保証もなくなる。

規格はあくまで規格だから
準拠率やコンパイラのバグを考えると
あらゆる事に保証が無い事に気付く

WIN32APIで、透過PNGを読み込んでDCに貼り付けたいのですがうまくいきません。
LoadImage関数で読み込む方法を教えてください。

それと、LoadImage関数でBITMAPを取得したら背景透過は消えるのでしょうか？
合わせて教えてください。

↓躓いている部分
HBITMAP hBitmap = (HBITMAP)LoadImage(NULL,"Test.png",IMAGE_BITMAP,0,0,LR_LOADFROMFILE | LR_CREATEDIBSECTION);

http://www.youtube.com/watch?v=KTc8vUpI_5Q
これの前半にある画像を左右に揺らすPGって結構簡単？

> 841 名前：832-833[sage] 投稿日：2011/10/31(月) 22:40:22.73
> >>838
> レスありがとうございます。
> まず、>>638を名乗ったこと、申し訳ないです。
> 落ち着きがありませんでした。678は、「Boost総合スレ part9」で書き込んだ残骸です。
> 理解出来ました。
> protectedは、意味は知っていたのですが、使ったことがなかったので教示いただいた用途は思いつきませんでした。
> ありがとうございます。

>638と名乗ったのか>678と名乗ったのか>679と名乗ったのか知らんが、兎に角落ち着けw

>>844
環境依存OKのスレか、WinAPIのスレへでも。
つーか、LoadImage()とやらはPortableNetworkGraphics画像フォーマットに対応しているのか?

>>847
分かりました。
そっちへ行ってみます。

メモリが足りるかどうかは
try
{
char * p = new char [k256Mega];
delete [] p ;
return true ;
}
caych(...)
{
　return false ;
}
でわかるけど、速度が足りてるかどうかってどうやってしらべるべき？
正確でなくて大雑把でいいんだけど、行列計算とかではかるのかな

＞でわかるけど
いいえ。

クラスに対するoperator<やoperator==などの比較関数を、
クラス自身のメンバ関数にする方法(引数は1つ)と、
グローバルなフレンド関数にする方法(引数は2つ)があるようですが、
この2つはどのように使い分けるものなのでしょうか？

>>851
自分自身と比較する時はメンバーに持ってもいいが、operator<<みたいに
std::streamみたいな別のクラスも引数に取る時はフレンドにするしかない

それから叙述関数にする時はフレンドにしないとそもそも呼び出せない

>>852
ということは、メンバ関数にもできるものは、
わざわざフレンド関数にする必要も無いということですね。

フレンドにすると保守が面倒になるからな
でもフレンドでしか出来ない場合もあるという事
メンバ関数で出来るものはメンバ関数でした方がいいに決まってる

めっちゃ無理して強引にメンバ関数にしてる某言語を、こういうときくらい笑い飛ばせなきゃ

>>849
メモリは実際に書き込みが行われるまで確保されない。
OSの割り込み監視対象になるだけ。

フレンド使わんでも、staticメンバーで本体定義して、
グローバルのoperatorでそれを呼び出す手もある。
意外とこっちの方が便利。

スレッドを作ったらデタッチかジョインしないとならないのはどうして？
メモリリークするのがどうしてなのかさっぱりわからないです。
逆にデタッチするとヒープにある何が開放されるのですか？スレッド自体はデタッチしても動き続けられますよね？

一件お願いします。
複数ファイルからなるプログラムを作成しているのですが、
各ファイルでincludeするのが面倒なので、
ひとつのヘッダーファイルにincludeするヘッダーを全て記述して、本体ファイルたちはこのファイルのみincludeしてます。
なんかコンパイルがすごく遅いんですけど、どうしてでしょうか？
件のヘッダーファイルは、複数回読まれないように#pragma onceしているのですけど…。

>>858です。
自己解決しました。
スレッドに関する情報を格納した構造体が、用意されて、スレッドを生成したときの変数はそれを参照してるのですね。
変数自体が情報を記録する構造体だと思っていました。
だから、呼び出し元の変数がスコープから外れて開放されても、ヒープにあるものは開放されないと。

pthreadのマニュアルみてたら、pthread_self()を見つけたのですけど、自分を指すってどういうことです？
スレッド起動時に用意される新しいスタックの一番下にスレッドに関する情報(か、それへのポインタ)がとられていて、そこを参照しているとか？

>>859
ソースコード度に全てのヘッダーを取り込んでるから。
インクルードガードが効くのは個々のソースの中だけ。

>>860
特定環境の話題は環境依存スレへ。

不透明な型を継承する（あるいはしたように見えるでもいい）テクニックってないですか？

内包すれば

クラステンプレートをなんだと思ってんのか

class Hoge {
public:
　shared_ptr<Piyo> GetPiyo() { return pPiyo; } // 1
　shared_ptr<Piyo> & GetPiyo() { return pPiyo; } // 2

private:
　shared_ptr<Piyo> pPiyo;
};

1と2、どちらの使用方法がより正しいですか？

間違えました。

誤：shared_ptr<Piyo> & GetPiyo() { return pPiyo; } // 2
正：const shared_ptr<Piyo> & GetPiyo() { return pPiyo; } // 2

どっちも違うんじゃね？

CRTPの話かと思ってた

>>868
非const Piyo を指すshared_ptrを取得する関数を書きたいのですが、正しい書き方を教えていただけますか？

なぜ参照なんだ

855ではなくて866でした。失礼しました

>>871
値返しというか、コピー動作の価値が分からないからです

>>872
普通に生ポ返せばよくね？
パフォーマンスが気になるほどgetしないなら別にコピーしてもいいと思うけど

ポインターって面倒くさいから参照ばっかり使っちゃう

>>872
一般的に
参照を返すと、内部に実体を持っている（その後も持ち続ける）ことが必要になってしまう。
コピーを返すようにしておけばそんなことはなくて、そのぶん実装が自由になる。

実際にどの程度の差になるかは場合によるんだけど。

一時的な使用のみを目的としている　→　生ポ
保持してしばらく使うが、無くなったら無くなったで良いものとする（無くなった事の検出は必要）　→　weak_ptr
完全に共有する　→　shared_ptr

いずれにしても参照は使わない（使ったら意味が無い）
あと循環参照には気をつけれ

内部のハンドルを返すのはやめよう（メイヤー）

でも実際問題マニアックな使い方されるケースもあるので
ハンドルを公開するのは保険として必要なんだよね

public公開する必要はないけどな。

>>876
・抽象化クラスは値返しできない。
・かといってnewするのはコストが大きすぎる。
・受け取るときにコピーすりゃ十分。

そういう時は、static変数を参照で返す手もある。
ただし、関数実行後、コピー前にその関数が呼ばれるとマズイので
関数呼び出しに側に配慮を求める必要がある。

ボトルネックでもなければ安全に倒すのがC++だろカスが

テンプレート関数でどんなクラスも指定できると困ったことになりませんか？
たとえば数値のintやfloatで大小を比べるhikaku<int>(a,b)やhikaku<float>(a,b)とつかうものに
hikaku<char *>(a,b)などとやられる可能性もありますよね？
オーバーロードで書いたほうがそれしかできないためわかりやすいと思うのですが

だったら、特殊化すればいいんじゃね？＾＾
template <> hkaku< char * >( a,b ) { fおちんぽだいすきじゅぽじゅぽ(); }
とでもやっておけばSFINAE原則によりchar*で呼び出せなくなる。

あ、ぜんぜん構文間違ってるよ、おれ＾＾

ヌルポインターを返す関数って駄目なんですか？
別の設計に変えるほうがいいんですか？

関数テンプレートは特殊化できません。多重定義できるだけです。

>>885
なんでダメやねん。返してええねん。
メモリ確保に失敗した場合とかヌルポ返さんでどうすんねん。

そのときは切腹や

>>887
そういうケースは例外返せよ。

NULLを登録したものから、
NULLが取り出せる事は問題ない。
そういうケースならNULL返せばいい。

>>881
スマポじゃ共変の型を使えんぞ。

>>889
例外はほんとうに例外の時以外は返してはいけない。

デバイスロストは個人的感情的にはどうみても例外なのに通常フローにしろって怒られた

>>891
正しい値を返せなきゃ例外事項だ。
禿のQA読め。

>>893
nullptrは正しい値。

>>894
こう書いてまともに動かないなら例外事項。
FunctionA(FunctionB());

>>891
「ほんとうに例外の時」って、客観的に判断できるの？

メモリ確保の失敗にどう対処するかはメイヤーの本にあるとおりだな。
例外でもぬるぽでも強制終了でも、それぞれに正当な理由がある。

>>896
逆に、客観的に判断できないとき、返却値の定義がおかしくないか疑う

そもそも例外ってのは、
cross = InnerProduct( line1, line2 ) + direction;
ってなオブジェクトを組み合わせた数式から簡潔にエラーを
綺麗に取り出す意味がある。もしoperator + がNULLなんかだしたら、
とんでもないことになる。あと、nullptrは基本的に初期化や代入用。

std::for_eachでbreakができない
C#ではbreakができて便利だった
breakが出来ないなら価値が半減する

いや、おまえらの意見なんかどうでもいい。
メイヤーの方がずっと偉いし、はるかに正しい。

愚者は経験に学ぶ、賢者は歴史（すなわち書籍）に学ぶ。

じゃほっとけよ。

>>900
BOOST_FOREACHつかえば？

>>898
つまり「ほんとうに例外の時」＝「返却値の定義に従えない時」ってこと？

多分ネットからHTML取ってきて、DOMを返す関数作るときも、
エラーが発生したら、NULLで値返して、エラー内容をerrnoに記述する関数書くんだろうよ。

例外って遅くないの？

そりゃ、mallocよんだりするし、例外用コンテキストの構築したりするから遅いよ。
ただ、例外が発生した時点で、望んだ計算結果が得られないんだから、
速度なんて0.1秒以上止まるとかじゃなきゃ問題ない。
1フレームが何ミリ秒とかいってる世界で、例外が発生してもなお
処理を継続するなんてことはまず無いだろ。処理を放棄して
再試行をユーザーに問い合わせるぐらいだ。

逆に言うと、処理を続行できる場合は例外を出すべきではない？

例外が遅いのは発生した時だけ
まあtryもコスト0ではないけど、以上に細かくtry書かなきゃ大したことは無い

例外はファイルサイズ膨らむから使ってない

何をもって処理を続行できると行ってんのか解からんが、
正しい値を返せる、または、戻り値が重要ではない場合は例外を返すべきじゃないな。

>>910
ご自由にどうぞ。4GBメモリと500GB以上のストレージが一般的になっても、
200KB程度の増加が気になって仕方ないんなら使わないのも一つの手だ。

>>873-881
レスありがとう
とりあえず素直に値返ししておきます。

まず非const shared_ptrを返そうとしている理由ですが、これはMCを使いたいからです。
次になぜ参照を返そうとしているかですが、これは単純にパフォーマンス上の理由です。
BOOST_SP_DISABLE_THREADSを使わないとこのコピー動作がボトルネックになりかねる重さだったと覚えているのでそうしました

>>912
そんな環境じゃないし。なんでPC前提なんだよ

>>911
呼び出し元がメモリ管理していて、呼び出し先がメモリ確保に失敗した時
一旦 NULL 返して、呼び出し元がいらないオブジェクト削除するとかメモリ
整理して再び呼び出す場合とかかな

>>910
どれぐらい膨らむのが問題なの？

>>916
４MBしかメモリない

>>917
へぇ。
で、例外使うとどれぐらい膨らむの？
何%とか、何KBとか。

>>918
800KB

>>915
そういうケースなら例外扱いだわ。
尤も、関数がNULLを返す前に、
メモリーアロケーターが通常のメモリ確保に
失敗した時点で、解放ハンドラを起動して
メモリーの確保に務めるべきだろうし。
それでも確保できないなら、メモリアロケーター内部から例外で抜ける。
ハンドラの呼びかけでメモリーを確保出来たなら、
メモリーを使用する関数はNULLなんざ返さなくても処理を
続行できる訳だし。

その800KBをcab圧縮しなさい

>>917
だから、そういう環境なら使わないのは自由だって。

>>922
おめーが勝手にPC前提で決めつけた癖に何いってんだ

>>919
なるほど。そりゃキツいな。
ちなみにコンパイラの情報をもらえるとうれしい。
gcc ならバージョンがいくつだとか。

>>923
気になるんなら自由だって書いたじゃん。引きずんなよ。

>>920
その時に解放できるオブジェクトをメモリアロケータが知らない時（という場合が多いと
思うんだけど） はどうするの？

>>912 の言い方は「自由だ」か？
特定のハード構成を一般的と言い切る御仁の、○○程度の××という皮肉を飲まないと、そう読めない

どこの馬の骨とも知らんやつに、何でそんな侮辱をされにゃならんのだ

>>926
今回問題になってる場所以外でも、他にどこでアロケーターを
使って確保したか解ってるんでしょ？
それに、アロケーターを使った場所は、メモリーがいつになったら
不要になるか知ってるんでしょ？
だったら、不要かどうかは判断できる筈じゃん。

Allocator allocator; //内部のstatic変数と関数でoperator newと繋がってる。
//contextが無効になったらtargetの解放処理を呼ぶ。
allocator.RegisterHandler( new MemoryHandler( context, target ) );

>>927
その程度が嫌なら肥溜めに書き込むなよw

未だに2chを肥溜めと呼ぶ奴がいるんだ

だからメイヤー本に一つ一つ理由が載ってるだろ。
おまえらのクソみたいな議論は無意味なんだよｗ

組み込み用のコンパイラで
そもそも例外なんて実装してあるのか？

>>931
ドヤ顔で書き込んでいるが、
えらいのはメイヤーであってお前ではないからな？

環境によっていくらでも結論が変わるものに対して、
いちいち揚げ足とらんで煽らんでもよろし

>>932
http://japan.renesas.com/products/tools/coding_tools/compilers_assemblers/sh_compiler/child_folder/sh_compiler_components_child.jsp

そもそも gcc が使えるしな。

int型の変数xがあります
これを符号なしの形で保管し、必要とあれば符号つきに戻したいのですが

単に符号つき整数を同じビット数の符号なし整数にキャストし
それをまた同じビット数の符号つき整数にキャストした場合
元の数値への復元は仕様で出来ると保証されますか？

>>936
保証されません。
２つめの符号つき整数への変換が実装依存となる場合があります。

4.7 p3
> If the destination type is signed, the value is unchanged if it can be represented in the destination type (and
> bit-field width); otherwise, the value is implementation-defined.

問題ないだろうけど、保証はできん。

符号つきを符号なしに変換した物を変更してない状態で符号つきに戻すのくらいは
どっかで保証されてないのかな
ポインタにして戻すのが大丈夫と保証されてるのと同じように

>>906
例外が起こっていない間は例外のほうが早いよ
コードサイズはでかくなりやすいけど

>>939
負の値を、符号なしに渡しても、符号なしから負の値で
符号付き変数に代入できる実装したって問題ないんだから仕方ない。

>>937
そうですか…ではちょっとやり方を変えてみます

符号つき整数を単に同サイズの符号なし整数へと変換した場合
その結果は一意に定まりますか？

つまり
同じ符号つき数からのキャストは同じ符号なし数へ、
違う符号つき数からのキャストは違う符号なし数へ、
となるかどうかです

この変換結果を配列の添字として利用するつもりです

素直に大きいサイズに入れて
INT_MAX(だったっけ？)の半分を足した数とかを使ったほうがいいのかなー

>>942 4.7 p2

reinterpret_castなら保証されてるでしょ。
　int x = 100;
　unsigned int ux = *reinterpret_cast<unsigned int *>(&x);
　int x2 = *reinterpret_cast<int *>(&x);

unsigned intはすべてのビット表現に対する値が
定義できる型なので戻せるはず。

そういう話じゃないだろ。
しかも、unsigned intに負の値をキャストした場合が非常にマズイ。