C++相談室 part74

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

前スレ
C++相談室 part73
http://pc12.2ch.net/test/read.cgi/tech/1254746834/

クソスレ

>>2
クソレス

STLつかうと一気に実行ファイルサイズが10倍に?！

環境によるだろ。
俺はBorland-C++5.6.2に -D_RTLDLL オプションを指定して、極力
ランタイムを使用するようにして使っているが、例えばstd::vectorを
使っても使わない時と比べ10Kほどしか増えない

すげえ。ダイナミックリンクしといてファイルサイズが増えないとかいってるよ。この人。

C1010: ﾌﾟﾘｺﾝﾊﾟｲﾙ済みﾍｯﾀﾞｰの検索中に予期しない EOF を検出しました。
とかいうエラーが出るんだけどこれってどうすればいいの？

#include <stdafx.h>
後死ね。

言葉が悪いな。それで教えているつもりか。
まぁヒントぐらいにはなったな。
うむごくろう。

このスレッドは天才チンパンジー「アイちゃん」が
言語訓練のために立てたものです。

アイと研究員とのやり取りに利用するスレッドなので、
関係者以外は書きこまないで下さい。

　　　　　　　　　　　　　　　　　　京都大学霊長類研究所

>>5
や、やめろ
このスレは真面目なスレだぞ

プログラム言語の訓練か。
チンパンジー恐るべし

基本的にガーベジばかり使っているものなんですけど、ネットで調べてもでてこなかった疑問があるのでお聞きします。
cやc++でガーベジを使わずにやるときに配列に一度newで値を入れて、今度は別にnewで入れたときに、
初めにいれたどこからの参照されないnewのデータはどうなるでしょうか？
そのまま開放されればガーベジの意味がありませんし、だからと言ってnewで入れ替える前にdelete[]を使用してその後にnewを使って入れるのはdeleteが配列の中身を消せても、配列自体を
消すことができないと言うことになりますし。どうも解けません。

言語仕様をちゃんと理解してください
deleteは配列の中身を消すわけじゃありません

新しい言語を学ぶときは別の言語の知識はすべて捨てたほうがいいよ。
CやC++の仕様にガベジコレクションはない。
メモリはフラグメンテーションを起こすし、
解放されないメモリは死蔵されてシステムに緩やかな死をもたらす。

メモリは十分あまってるのにnewがstd::bad_alloc投げたときはびっくらこいた。
後で調べたら多量(数十万回〜)のnew/delete濫用によるメモリのフラグメンテーションだったようだ。

C++ではこんな事もあるから面白いよね。

またテンプレ無しでスレ建てやがったのか。

スマートポインタで動的削除子をやりたい方などはどうぞ。かなり速くなります。
ttp://codepad.org/cXkLu4rt

>>13
とりあえずどの環境でどれだけ速くなったのかぐらい示せ。

プロジェクト全域でshared_ptrで生ポインタ排除とかってアリ？

アリどころかそうすることを強くお勧めする

>>13
STLportのNODE_ALLOCATORでイナフ

>>14
XP SP3
AMD Athron 64 X2 Dual 1.8GHz
BCC5.5
最大で65％以上高速化しました。

>>18 何の 65% だよｗ

同じ環境で普通にnew,deleteしたときに対して、です。

BCCという点がアレだよなぁ・・・

このコード main で作って消すだけだから、最適化したらいろいろ
無くなるんじゃないか？中身なんか入れないと実際のコードの参考になる
かわからんのでは。

あと、bcc ってあまり使わんから icc, g++ 位で比べて欲しい。

>>20
「何に対して」なんて誰も聞いてないんだが。

あとな、高速化ってのは問題の処理全体のうちのどれだけを高速化できるかが大事なんだ。
仮に new/delete の処理時間が 65% 短縮できたとしても、それが全体の 0.65% ぐらいである
ことだってよくあること。「何の」 65% かってのは本当に大事。

ちなみに、サイズ固定のアロケータなら segregated storage と呼ばれる手法がほぼ最適。
おそらく >>13 のコードより速い。

struct Hoge{
char a[256];
EASY_ALLOCATOR( Hoge )//new,deleteの宣言マクロ
};
int main(){
for(int j=3;j--;){ //3回ループしてみる
unsigned int time = timeGetTime();
for(int i = 0;i < 100000000;i++){ //1億回
volatile Hoge* h = new Hoge();
delete h;
}
time = timeGetTime() - time;
cout << time << endl;
}

return 0;
}

上記コードをVC++2008で最適化効かせて実行してみたところそれぞれ下のような平均が出ました。
アロケータON:　 3500
アロケータOFF: 20900

なんか、最初は軽い気持ちで張ったのに、ムキになっちゃいました・・・。
あとsegregated storageは初めて知りました。自分のとはちょっと趣旨違うけど面白いですね。
スマポの次はアロケータにハマるかも

>>24
segregated storage は趣旨が違う？
固定サイズの高速アロケータってことで、まったくいっしょじゃないの？

pool_allocatorより速いなら使ってもいい

>>25
ほんとだ。ちゃんと読んでみたら、同じですね。これは完敗だ。すごいです
皆さん、詳しいんですね・・・。精進せねば

shared_ptrに渡すなら、newよりmake_sharedの方が速かったような気がする

>>27
いい経験を積んだね。こういう経験は後に役立つよ

Googleメモリ管理は速くはなるけど、アプリに組み込んでも大差はない。
メモリ確保のみで、アプリが動いているわけではない。
たとえ10倍速になったとしても、他がメモリ確保に比べて時間食ってたら意味ない。

>>cやc++でガーベジを使わずにやるときに配列に一度newで値を入れて、今度は別にnewで入れたときに、
>>初めにいれたどこからの参照されないnewのデータはどうなるでしょうか？
誰かこの質問に答えてくれませんか？
あとガーベジですがvisualstudioのアレのことです。それを使わずに普通にcやc++でやるとって事です。
deleteは開放すると言うことくらいしか本やネットに書いていなく、詳細なことが書かれたものが見つからなくここで質問しました。

>>31
宙に浮きます

メモリリークでググれや。
メモリ保持しているポインタに別のnewいれたら、先のやつは手を出せなくなる。

そのままヒープ上に実体が残ったままになります。デストラクタも呼ばれません。
誰もポインタを持っていないならそのオブジェクトは、アプリケーションから実質開放不能になります。

そこで、男らしくアプリケーションを終了します。

メモリ確保を多く使う処理、アプリを見つけて
それで比較するなら良いが、単純にメモリの確保と解放するだけなら価値がない。

そして、PCの電源コードを引っこ抜きます。

>>31
とりあえず「ガーベジ」と Garbage collection とをごっちゃにしてるみたいだけど、
「ごみ」と「ごみ集め」とをごっちゃにしてるぐらい迷惑だからやめろ。

＞visualstudioのアレ

アレってなんだよ。もしかして.NETフレームワークのソレのことをいってるのか？
ソレならナニだからアレだよ。C++とは関係ない。

言語はGCを導入するか、入れないかどっちかに分けた方が良いと思う。
C++のboostのように中途半端だと、速度面、保守性が悪くなると思う。
メモリリークを発見するツールのいいだろ。
メモリリークしなければboostの処理入れる必要がない。

VC++はデバッグモードで実行すると自動的に
アプリ終了時に開放されないメモリをリストアップしてくれるから便利＾＾
何度助けられたことか。

でも、そのVC++とも2010でお別れ。
Standardエディションを終了して値段を3倍にするそうなので
もう手が出せません。

>40
ちゃんとauto_ptrとshared_ptr使い分ければいいだろ。
手動でdeleteなんて面倒だわ。

あと、リークするのはメモリだけじゃないぜ。

VC++ 2008 EE がいきなり使えなくなるわけでもあるまいに。

関数内だけ生成して解放するなら、デストラクタ使えばすむじゃん。
string buf(1000, '\0');と確保すれば自動開放。boostの処理より速いだろ。

自動変数から&でとったアドレスと、newされたアドレスって区別つくの？

>>31です。皆さまありがとうございます。
つまりメモリーリークを起こさないためにはnewで入れ替える前にdeleteで以前のを開放してからnewを入れるって事でいいのでしょうか？

>>46
いいえ。 std::auto_ptr や std::shared_ptr を使うのが正解です。

>>46
初心者はnew使わない方が良い。stringやvectorで確保する方が安全。
関数や括弧を抜けると自動で消されるのが欠点だが、関数や括弧の前に確保しておけばすむ。

一次元で確保無理ならクラスにしてデストラクタつける。
クラスが複数必要なら、 vector <クラス>にしとく。

>>45 渡された側では区別できません。

違うよ。
メモリリークを起こさないためにはメモリを開放するまで
メモリへのハンドル（すなわちポインタ値）を管理しておく必要があるってことで、
ポインタ（変数）への代入とは無関係だよ。

new使うならデストラクタが付く、クラスだけで使用するのが推奨。

>>52 その切り分けは無意味だろう。

>>50
TCB見に行けば、スタックかどうかは判別できる。
かなりOS依存になるがな

>>48
逆だろ
言語を憶える時に、それ自体を使うなってのは無理な話で、
問題点をろくに認識する前から刷り込まれたおまじないを
不適切に使ったり無用な争いを始めるほうが実用レベルではまずい
かつての goto 論争と同じこと

初心者にあえて解りづらく説明する能力になんて長けた人たちなんだ

>>56
っていうかね。
C#やJavaは配列のメモリを new で確保して要素の参照を保持するけど
CやC++はぜんぜん構造が違うじゃない？

>>31＝>>8の質問はそれを前提にしてるみたいなんだよね。
ガベコレとかVisual Studioのアレとか
C++に関係のない寝言を書くのもそのせいじゃないかと。

>>45
以前それを解決するための処理を書いたことがある。
要はnew演算子をオーバーロードしてそこでリストに追加したりする訳だが
かなり重くなると思うんでお勧めはできない。

>>31です。ありがとうございます。
私はjavaやc#はそこそこに慣れてますけど、cやc++は本を読んだ程度です。
C++/CLIなしのものは簡単なものしか作ってません。

誤解を恐れずに書くと（自分はC#よく知らんので）
C#やJavaの配列をCのコードにした場合、

int a, b, c;
int **p = ( int ** )malloc( sizeof( int * ) * 3 );
p[0] = &a;
p[1] = &b;
p[2] = &c;

みたいなイメージになる。だから、free( p ); すると
a, b, c が使ってるメモリはどうなるの？って感じちゃう。
（もちろんこれはランタイムが自動で管理・開放してくれる）。
これがクラスオブジェクトになると厄介で
C#やJavaはオブジェクトを new で確保するので

class C;
C *a = new C;
C *b = new C;
C *c = new C;
C ***p = new C **[3];
p[0] = &a;
p[1] = &b;
p[2] = &c;

みたいな感じになる。
この場合のa, b, cはプログラマが管理するしかないので
delete *p[1], *p[2], *p[3]; の後、delete [] p; をしなければならない。

…CやC++ではこういう「ゲーム」（←メイヤーズ風に＾＾）はやらない。

お前らってソフトウェア開発をビジネスとして捉えて考えたことってあるのか？無いだろ？

それは相談なのか? 人生相談??

>>60
＞cやc++は本を読んだ程度

なんて本だ。名前を書いてくれ。
その本を推薦図書スレにあげて
未来永劫手にしてはいけないクソ本として広めるから。

The C++ Programming Language (special edition)です

ハゲ涙目ワロタ
つまりC++がクソ言語ってことだなw

>>65
またまた冗談を!
Elements of Programming だろ?

ブラウザ使うと簡単な、HTTP通信ですがC++言語でやると困難です。
HTTP HTTPS FTPを簡単に扱えるライブラリはないでしょうか

.NET

これはよさげと思って調べてみたら、ファイルの一部だけgetが出来ないんです。
ファイルを書き換えれば対応できるとは思いますが。バグ出る可能性もあります。
CURLは動作が出来ないです。必要DLLが足らないとか出てこれるとバージョン違いで止まります。
依存が少なくwindowsXP以上で動くいいやつないですか。

http://clx.cielquis.net/

.NETフレームワークス無しで動くやつが良いです。バージョン違いなどにも影響しないやつがいいです。
どのwindowsでも動作するwindowsAPIだけを使うか、必要なものが静的ライブラリで組み込める物が良いです。

なぜwindows、linuxで動くラッパーを誰も開発しないんですか。
知ってるところだと、70のCLXくらいです。でもhttps通信はOpenSSL必須です。
あとは巨大なGUIライブラリの一部としての通信機能くらいしか知らないです。
簡単でバイナリでは無いやつは無いんですか。

ソケット通信から作るのは大変で、
InternetOpenUrlで自分でとってくるか。
InternetOpenUrlはバグがあった気がしててちょっといやなんだがな。

65は釣りです。

>>70
一部だけgetってHTTPのGETの動作を否定してないの？そうでもないの？

つ　http1.1 レジューム　

多くのサーバーで、ダウンロード中断してやり直せたり、部分だけ取り出せる。

部分的 GET とレンジ単位
HTTP/1.1 では、リソースの一部だけを取得できる部分的 GET というものがあります。部分的 GET を使えば、例えば接続途中におけるエラーによって取得できなかったリソースを、その続きから要求するような事もできます。
http://www.studyinghttp.net/body#Range_Units

VS2008expは豪華すぎるっていったたやついたな。
コマンドだけしか付いてない配布形態もある。
Windows SDK for Windows Server 2008 and .NET Framework 3.5
http://www.microsoft.com/downloads/details.aspx?familyid=F26B1AA4-741A-433A-9BE5-FA919850BDBF&displaylang=en

>>72
C++崇拝者なら何でも自分で作るのが原則です甘えないでください
RFC・W3C・ITU-T・ISO/IEC等で定められた規定や勧告の何万頁にも及ぶ資料の全て熟読し
その仕組みを骨の髄までしゃぶり尽くした極一部のプロフェッショナルだけがそれらの機能を利用することが許されるのです
それがC++の世界です！嫌なら.NETを使って楽をしましょう！.NETなら全てを安価に解決してくれます！！！

>>79
windowsやlinuxに標準装備の部品を組み合わせたラッパーでいいんです。
ソケット通信から作る必要はないです。
ネイティブで動作して、
ブラウザの様にhttp://やhttps://やftp://を認識して
部分GETが出来たらいいです。

httpget (buf, "http://hoge.jp/hage.zip", 100, 1000);
みたいなやつです。

２ちゃんねるブラウザってオープンソースのブラウザとかからHTML解析と描画部分をマルパクリしてるんですか？

C++の世界の住人は
「無い物は自分で作る」「ある物も自分で作る」
みんなそうやっています　以上

もちろんC++コンパイラも自家製よ

get post headが一行で出来るコード無いですか。コピペして使いたいんです

幼稚園のころ保育士さんに「折り紙で鶴折りましょう」と言われたときに
テーブルの上に置いてあった折り紙で鶴を作り始めるの園児がC#やJava
紙を作るから製紙工場のプラント建設計画を練り始め材木の伐採に旅立ってしまう園児がC++

>>84
IEコンポーネントでだめか？

>>80
WinInet
http://msdn.microsoft.com/en-us/library/aa385483(VS.85).aspx

WinInetはらくな方ですが、http https ftpが一行で使えないんですよ
ブラウザは一行でエンター押したら出来るのに。

.NET使えば2秒で実装出来るぞ

>>88
うちなんてスイッチ押すだけでWindowsが起動するぜ
一行でWindowsが起動するプログラムないかな

.NET使うぐらいならPython使う

そう言えば、幼稚園児のとき、折鶴を折るために山に植林に行ったなぁ（遠い目）

俺は隣の子が折った鶴を貰って、折り目のない紙を渡した。

WinInetの関数を使って自作するかのお

>>85
折り紙に折り目が付いてないから折れないと騒ぐのが(ry

WinInetの情報少なすぎ
https通信が簡単すぎて話題にならないのだろうか

http://www.google.com/search?q=SECURITY_FLAG_IGNORE_REDIRECT_TO_HTTPS&lr=lang_ja

一方ロシアはブラウザを使った。

みたいな。

クロスプラットフォームなHTTPのライブラリくらい、ここで聞くまでもなく、
ググればなんか誰かが作っているのが見つかりそうな気がするけどなあ。

ここ数日ヲチしてるけどWindowsプログラマーが圧倒的に多そうだね

>>98
うpうp
Curl以外で

Curlがデファクトスタンダードだろ

Curlはlibsasl.dllがないとか出て動かん。
どこにもバイナリ置いてないぞ

HTTPの仕様ぐらい自分で実装しろよ
ヘタレ過ぎだろう

うp!うp!ﾌﾟﾘｰｽﾞ

ソケットだけでなくHTTPも、将来の標準入り目指してまずはBoostに入れようぜ。

HTTPだけでいいなら困ってないと思う

将来的にはファイルの非同期入出力なども同じ枠組みでサポートされる予定だそうですが、 現在のところは、要するに、ネットワーク通信のライブラリです。
http://www.kmonos.net/alang/boost/classes/asio.html

#include <iostream>
#include <string>
#include <boost/asio.hpp>
using namespace std;
using namespace boost::asio;

int main()
{
// www.boost.org の http サービスに接続
ip::tcp::iostream s( "www.boost.org", "http" );

// 送信
s << "GET / HTTP/1.0\r\n";
s << "Host: www.boost.org\r\n";
s << "\r\n";
s << flush; // バッファに溜めずに確実にネットワーク送信

// 受信
string line;
while( getline(s, line) )
cout << line << endl;
}

Boostに入れたければアプリケーション層のプロトコルを
メジャーどころからドマイナーなのまで最低100種類は取りそろえてコミットしないと

すみません。この様にデータを定義したとき、配列数を調べる方法ありますか。

string euc[]　= {"EUC-JP","euc-jp","x-euc-jp","eucJP-ms","CP51932","cp51932"};

自己解決しました

char *euc[]　= {"EUC-JP","euc-jp","x-euc-jp","eucJP-ms","CP51932","cp51932"};
cout<<sizeof(euc)/sizeof(char*)<<endl;

>>110
std::stringがポイントなんじゃなかったんかい？

WinInet、楽チンだね。自分でwinsockで実装する前に知っていればよかった。
まあ、よくあることだけどねｗ

109ならsieof(euc) / sozeof(string)で出せるね

>>113
std::stringってよく分からんSTLもどきなわけだが、
それでもsizeofを使ったそのワザは有効なの？

組み込み型やPOD型に限らず？

template<class T,int N>
int number(T a[N])
{return N;}

これじゃいやん？

いいよ。最高だよ。っていうか、同じ回答をしている人がいなかったか？
テンプラーにはごく普通のテクニックだけど
まだ一般には浸透してないのかしら？＾＾

っていうか、ほとんどの人はvectorを使うからかな？

>>114
何か勘違いしているが、型がPODだろうが非PODだろうが
今回は静的に決定される配列の要素数を取得したいわけだろ？
コンストラクタで中身がどう初期化されようが要素そのものの型レベルの大きさが変わるわけじゃない。
変わるのはstd::stringの中身のポインタが動的に指すメモリ領域だ。
STLを魔法か何かと勘違いしてるみたいだな。

>>116　逆にこの場合なぜ vector 使わんのかわからんな。

109はどうやったらvector<string>にはいりますか

vector<string> v;
for(;;) v.push_back(string("死ね"));

何から何まで聞くんじゃなく、自分で調べてわからないことを聞いた方がいい。

そうではなく
vector<string> euc = {"EUC-JP","euc-jp","x-euc-jp","eucJP-ms","CP51932","cp51932"};

が出来ないですか

0xならできる

ついでに突っ込んでおくと template <class T, unsigned N> unsigned size (T (&)[N]) { return N; } じゃないとだめぽ

>>123
0x便利そうだなぁはやく使いたい

>>122
vector 初期化が面倒なのはわかるが、だからと言って >>110 の方が vector
使うより良いとは俺には思えんなぁ。価値基準は人それぞれだろうが。

>>126
それは要件によるだろ
vector 必要ないところで「念のため」とかやってるアフォには付き合ってらんねーし

double arr[] = {0.0, 1.0, 2.0, 3.0 ,4.0};
std::vector<double> vec(arr, arr + sizeof(arr));

まあでもこれと大差ないよな

あ間違えた、sizeof(arr)/sizeof(double)だった

+ sizeof(arr)
↑
なんぞ？

template <class T, int N> T* begin (T (&arr)[N]) { return arr; }
template <class T, int N> T* end (T (&arr)[N]) { return arr + N; }

double arr[] = {0.0, 1.0, 2.0, 3.0 ,4.0};
std::vector<double> vec(begin(arr), end(arr));

Ruby使いはいねえがー？

ふつーにboost::assign使えよクズども

うちはブースターパック使用禁止なんだよ。

ライブラリの開発元が複数に分かれているってのは大きなリスクだよね
accept:gzipのhttpsでIEみたいなことをするのにも
ソケットのライブラリ・httpのライブラリ・暗号復号のライブラリ・圧縮伸張のライブラリ・エンコードのライブラリ
正規表現のライブラリ・キャッシュファイルのライブラリ・cookieのライブラリ・Ajax系セッションのライブラリ・ActiveXのライブラリ
これだけ別々のライブラリが必要になる、馬鹿みたい。

sizeof(arr)/sizeof(double)
よりも
sizeof(arr)/sizeof(arr[0])
のほうがいいと思うんだけど。

sizeof(decltype(arr)) / sizeof(decltype(arr[0]))

>>137
そうするメリットは？

いつでもいいので、HTTP(S) FTP(S)の
GET,POST,HEAD,レジュームが一行で出来るやつ教えてください。
windows XPで動かせたらいいです。

無いものは作るしかない

system("wget");

>>139
そういうツール使いなよもう

Curl.exeを使えば、一行で出来るのですが、複数同時にプロセス起動のがいやなんです。
一つで2M、3Mとか使って、パソコンに優しくないんです。

Curl.exeを使えば、一行で出来るのですが、同時ダウンロードすると
複数同時にプロセス起動するのが嫌なんです。
exe1つ毎に2M、3Mとか使って、パソコンに優しくないんです。

文字列の先頭へのポインタSがあったとして、
Sの示す文字列の３文字目を表す場合どう表現すればいいんでしょうか？
S[2]と書いたら、それはint型だとか言われました

よく考えたらC＋＋じゃなくてCの質問だったので別のとこで聞いてきます

Curlは古いインポートライブラリもしくはDLL使ったら動いたのでこれでやることにしました。

テトリスDS持ってる人デフォルトの操作方法教えて
ゲームパッドでテトリスオンラインやってるんだけどデフォルトのキー配置が気になってさ

↑すみません　誤爆しました

>>127
素朴な疑問だけど、vector 使わなくてもいいのでは、という状況もありうるが、
使うのが「アフォ」と貶す程の状況ってどういう状況？

>>144
いまどき2Mや3Mくらいでけちけち言うな

>>151
ビット単位で勝負している俺に謝れ

iteratorのi番目とi+1番目の足し算するときって
i->x　+　(i+1)->x
だと思ったんですけど違うみたいなのでどうするかわかりますか？

i[0].x + i[1].x

>>154
サンクス

>>152
メモリ使用量を100kから80kへ減らす、所要処理時間を1200msから1180msへ減らす。
いかにもC++崇拝者がやりそうなことだな。
そのためには誰が読んでも処理内容が明白なアルゴリズムを性能だけを考慮してチューニングし始める。
改善の相対量では無く絶対量を理解していない。体感では無に等しい改善の対費用効果を考慮する概念すらない。
コードの運用コストがいくら掛かろうと性能が向上することは良いことだと思い込んでいる。
見えているのはコードだけ、それを利用する人間の笑顔じゃない。

まぁ、hpcで100台で稼動なんて現場では1%の高速化でも仕事になるわけだが。

>>156
なんでそんなに目の前の相手のキャラクターメイキングに必死なの？

プロファイルして時間食うところだけ変えろよ

>>156
1.2秒以内に処理が終わらないと子供の命が危ないんだけど。

1.2秒だと子供の命が助かって、1.21秒だと死ぬってどんな状況？ねえどんな状況？
アホらしい

1.2 + �凾ｩもしれんぞ

世の中についての知識があまりに無い人が
自信満々に突っかかってるを見てると、こっちが恥ずかしくなってくる。

ものすごい打鍵音たてて歯軋りしながら>>156書いたんだろうな、恐らく

つーか、あんな文章を書いたところで
どこの誰に影響を与えることが出来るんだろう?
無意味すぎる。

takaga 2ch

２ｃｈといえども
そこそこのコンセンサスすら得られないなら書く意味がないだろう。

リアルタイムな処理を要求する場合だと重要じゃないのか？

インテル Parallel Amplifierは使える。
VC++2008のプロファイラは関数単位しか時間でないだろ? 使いにくいし。たぶん。
こっちは行単位で出るぞ。

>>161
よくあること。

結局具体的には挙げられないのか
まあ、よほど特殊な状況でない限り161みたいな状況なんてありえないよな
みんながみんな宇宙船や粒子加速器作ってる訳じゃないんだからさ

>>170
ねぇだろw

医療機器とかもだな。
このレベルで挙げ始めたら、知ってる人は大量に挙げられるんじゃね？
>>161みたいに、「俺の知らないものはこの世に無い」とでも思ってるかのように
自信満々に「アホらしい」とは言えんなぁ、俺は。

実際にありますよ、じゃ答えになってない
具体的な例をあげて、それがなぜ1.2秒なら良くて1.21秒だとだめになるのかを簡単にでも説明できないと

それを>>160に聞きたい気持ちもあるけど、
>>161は何を根拠にアホらしいと断定してるのかも聞きたい。
この世にそんなものはあってたまるかという自信に満ち溢れてるようなので。

1.21秒とか子供の屁理屈に聞こえるから、もう止めようぜ、そういうの。

聞こえるっていうか、そのものズバリ子供の屁理屈だと思うよ。
常人にはわからない不思議なマッチで火が点いて、引っ込みつかなくなったのでは。

1.21 秒で文句あるなら、何秒なら文句ないの？
例えばで出てきた具体的な物理量をいくら叩いても数学的には何も言えてないだろ
逆に数学的に破綻のある論理でもシステムのライフサイクルとの対比で ∞ に近似できるケースもあるし

結局、基準を「俺ルール」に求めている点で何も変わってない

時と場合による。
オリンピックの100m走の計測だと9.58と9.57はすごい違いだろ。
後者だと長年歴史に名が残る可能性。

ここは相談室ならぬ談話室ですな

一杯やりますか。

車のブレーキ制御とかは0.01秒の差は大きいんじゃないか？

>>182
車のブレーキ制御ってC++使ってしてるの？

>>182
面白い例えだと言えばまあそんな気もしてくる。

時速100kmでかっ飛ばしていたとすると
100(km/hr)*(1000/3600)=77.2(m/s)
だから
0.01秒では
0.77m
の差が出る。

まあ子供の命を救えるかどうかは微妙な所。

C++を使ってるところもあるかもしれないが、まだCだろうな。

>>183
C++かどうかは知らんが組み込み系な言語でしょう。
（スレチってなら1.21秒な話も同様ですぜ）

>>184
101回目のプロポーズなら死んでたかも知れない。
100km/hは出してないけどさ。

>>182
だいたい1ms-10ms
ブレーキ制御はペダル入力だけとは限らないからね

>>183
Cだな
C++なんて絶対に使われない

前にNHKでやってた原子力発電所はCすら使わずアセンブラだった。

最近は組み込みでも徐々にC++が使えるようになってきてる
ただし使い方はbetterCだけど

>188
1bitだか1Byteミスっただけでダメだったって話のアレ？

コンシューマゲーム開発だと、1フレームに収まるかどうかは死活問題だぜ。

ね。
1/60秒以内に処理が終わるかどうか。0.001秒でも遅れたらゲーマーに袋叩きにされるな。
子供も死んじゃうかもしんない

>>192
> 1/60秒以内に処理が終わるかどうか。
> 0.001秒でも遅れたらゲーマーに袋叩きにされるな。

1/60=0.016666666666666666666666666666667
だぞ。

描写速度であってキー入力とは関係がない。　
描写速度以上の反応精度はあるだろう。

>>193
0.0166秒以内に終わらせなくてはいけない処理は
0.0167秒かかってはいけない。

わかる？

>>193
それが何か？
画面更新は垂直同期に合わせることになるから1/60秒という時間制限に0.001秒でも
遅れたら60fpsのゲームが30fpsになる。実際えらい違いになるよ。

うにゃー

>>193
なんでそんな中途半端な桁数に?
普通に0.01666……とでも書けば充分伝わるのに。
或いはいっそ、同じ間抜けを晒すならもっと桁数費やせば清々しいものを。

うにゃー

Windowsについてる電卓で1÷60を計算してコピペしたんだろw

適当に書いた>>193にレスがいっぱい付いて驚いたw

>>198
いや別に、ゲームプログラミングをしたことない俺が
横槍を入れたくなったから入れてみただけだ。
特に深い意図もない。

>>200
おまえ鋭いな。
まあWindows電卓じゃないけど似たような状況。

グーグルを電卓代わりに使うなよ

数msec遅れただけでこんなことになるわけですよ。
株価にも影響するんだぜこれ。
http://schiphol.2ch.net/test/read.cgi/gamefight/1256659345/

なんか想像の話ばかりだね。
>>152がどういう物を作っているのか純粋に気になる。

>>203
ネットワークプログラミングは今の話題とは別じゃない？

「20〜30ms処理が余分に掛かっても体感上なにも変わらないから
高速化の努力なんて無駄ｗ」
で済むプログラムしか書いたことない人は実にお気軽なものですね。

論点がずっとズレ続けている。
20ms余計に時間が掛かることで開発期間と運用コストが5%削減出来るとか、そう言う勘定が出来ないとダメ。
出来ない奴はエンジニアでもビジネスマンでもないよ、ただのプログラミングを趣味にしているだけのおじさん。

言語は適切に選択していかなければならない
あらゆるものをC++で書こうとする人間は
適切なソリューションを選択する能力が低いとしか言いようがない
そしてC++が最良の選択肢となるケースはそれほど多くはない

多量規制の影響ひどいね
ただでさえ書きこみの少ないプログラム板が完全に閑古鳥が鳴いてる

頭を冷やすには丁度いいんじゃないの

>>206,207
「あらゆるものをC++で書こうとする人間」の相手をしなければ
ならない境遇にあるのですね。
痛み入ります。

「C++が最良の選択肢となるケースはそれほど多くはない 」
ってそりゃそうでしょ。
世の中のプログラマーの仕事量で考えれば業務系とか実行
スピードなんてどうでも良いようなのが８割以上だろうから。
そんな事はこのスレに居るC++使いは当然分かってるだろ。

C++のFAQで、一気にダウンロードできるドキュメントはありませんか？

MSDN

> そしてC++が最良の選択肢となるケースはそれほど多くはない

土方ってそういう基準でなるものか？

ひ…土方！？

>>212
http://www.parashift.com/c++-faq-lite/on-line-availability.html#faq-2.2
> ... Learn to use wget instead.

STLのコンテナの各メンバ関数がどんな例外を投げるか知りたいんだけど、どこかに一覧とかないかな？

例外は実装依存だからあるわけねーよ

標準規格に書いてあるよ
例外を投げてはいけない関数はそのことも書いてある

>>218
デタラメはやめなさい

例えば std::vectorのメンバ関数at()は例外std::out_of_rangeを
投げるとか、そういう奴か？

しかし確かにアロケータは実装依存なので、投げられる例外は
少ないわな

手持ちのC++標準ライブラリには標準はvectorとdequeのat()と、
アロケータがbad_allocを投げる事を要求しているに過ぎないと
書いてある

詳しくは規格票のどこかにあると思うが誰か探してくれ

>>220
そうです。

これか

§23.1.1.13
13 The member function at() provides bounds-checked access
to container elements. at() throws out_of_range if n >= a.size().

§26.3.1.6
6 These library functions are permitted to throw a bad_alloc (18.4.2.1) exception
if there are not sufficient resources available to carry out the operation.
Note that the exception is not mandated.

この二つしかない

で、atとallocateが使われてる箇所はどこなの？

ライブラリがどんな例外を投げるか分からないｗ調べる資料もないｗ
C++崇拝者は無駄に調べ物が多くて大変ですねｗｗｗ
ドキュメントさえ整備されていれば本来そのコストは支払う必要の無いものｗｗｗでも現実に整備されていないから浪費ｗｗｗｗ
その無駄な時間を生産へ充てた方が賢明ですよｗｗｗｗｗ

wは句読点じゃないぞ

コンテナの中身が投げる例外は何でも投げます

>>221
アロケータがbad_allocをthrowするってことは、
push_backやinsert内ではどうなってんだろ？
そのまま呼び出し側までthrowしてんのかな？

ライブラリは内部処理を知らなくても扱えるようにドキュメントが整備されていることが前提
でも仕様が明記されていないから結局内部処理を調べなきゃいけないｗ実際に動かしてどうなるか確かめて見ないといけないｗ
生産性を高めるはずの隠蔽の仕組みがすべてが徒となっているｗｗ

そうでもない

-fno-exceptionsを渡している俺に隙はなかった

なんだよC++を揶揄している馬鹿は
ロクに使えもしない癖に文句言うなカス

例外が有効な環境ではどんな例外投げられても構わない
様に普通の人は作るから全く問題なし。

>>233
うん。C++に限らずJava以外みんなそうだと思う。

どんな例外でもいい設計って具体的にどんなよ？
投げるほうは投げるほうで完結するように例外安全にするのはいいとして
受け取るほうはcatch(...)だけにして、エラーの詳細なんて知ったこっちゃないと捨ててしまうの？

>>235
なるべく catch しない。
main() とか、根っこには catch(...) とか置いとく。
これでだいだい問題ない。
個別に問題があれば追加の catch を注意深く配置する。

あぁそうか
不明なエラーと回復不能なエラーはルートまでたらい回しリレーして、
詳細がわかって回復可能なところは個別にいじるのね
なんか例外でなやんでた部分がすっきりした気がする

例外って、対応していない関数などあれば出来ないだろ。

プログラムって、バグってる関数などあれば出来ないですね。わかります。

例えばbad_ballocが投げられた時にどこまで対応するかなんて
作ってるものの性格によってまるで違うだろうしな。
out_of_rangeの場合はまた違うだろうし。あなたなら？握りつぶす？

そういったシステムポリシーに関わる処理をどのレベルで行うのかを
柔軟に選べるようになるのが例外の強力なところだと思う。
汚いif文を大量に掃除した上で。

一掃できることが存在理由
だと思う。

最後の2行はゴミです。すみません。

自分のレスにゴミを残すような奴が
> 汚いif文を大量に掃除した上で。
とか言ったところで説得力は無いな。

専ブラ使ってると編集中に Shift + Enter で誤送信しちまう時があるんだよ
ただし >>240 がそうだったかどうかはわからんがな

説得する気など毛頭無い。

>>240
は記述量増大は必然的にバグ増大につながる
ってことを敢えて示しているのだと思うYO。

try { なんちゃら } catch(...) { ; }
こそが男気あふれる例外の使い方

>>246
クソコードじゃねぇか

空文入れて「例外をガン無視することにしました」と表明してるだけまだまし
catch(...){}が一番困る

でも一番上はそうするしかなくね？
まぁほとんどの場合exception&キャッチしておけば実用上問題ないんだし、気にしたら負けかと。

せめて何かしらのメッセージは吐いとこうぜ。

>>249
そう
要求定義がまとまる前に実装については議論できんはず
何がどう困るのか言えん奴を相手にしたら負け、そこは間違いない
コンソールがない環境でコンソール出力を要求するアフォとかな

何がどう困るって、どういうつもりで書いたかわからないのが困るに決まってるだろ

誰も言っていないアホな主張を仮定してそれを偉そうに否定する。
最近はそういう遊びでも流行ってんのか？

一番上で握り潰すくらいならスルーしてOSに任せた方がまし

OS・・・？
スルーしたらterminateが呼ばれてabortするだけじゃ？

VCだと例外をスルーするとデバッガが例外発生地点まで巻き戻してくれる。 何気に超便利。

そうだよ
abortさせてコアダンプ吐かせるべき
握り潰して見せかけ上正常終了したら情報が何も得られない

例外でずっと気になってるネタ振ってみる。
コンストラクタで失敗した場合に例外投げるべき？
それとも生成するだけして後で値を設定していくべき？

投げればいいと思うよ

>>258
FAQ すぎる。ずっと気になってるって、どんだけ情弱なんだよ。

>>258
http://ja.lmgtfy.com/?q=%E3%82%B3%E3%83%B3%E3%82%B9%E3%83%88%E3%83%A9%E3%82%AF%E3%82%BF+%E4%BE%8B%E5%A4%96

いや、個人的には投げる方なんだけど、
仕事で見るコードはとにかく生成しちゃうやつばかりなんで。
分野とかあるのかしら

>>262
書いた奴に聞けよ。

まぁ昔の C++ 例外の実装がウンコだったこともあって、それなりに迷信として広まってるから、
そういう状態になってるのはわからんでもない。

無料で使用できるC++コンパイラで、
テンプレートとS-JISソースがまともに扱えるものはありませんか？

今のところg++, vc++を使っていますが、
趣味程度としてもう一つくらい使ってみたいと思っています。

bcc はどう？

>>265
実は次にそれを試したのですが、
テンプレート周りがちょっとアレでした。

>>264
iccはどう? 試用で1ヶ月は無料だし。

「まとも」とは何かによるが、この世には存在しないという答えにもなりうる

>>267
Intel C++ Compiler - Wikipedia
http://ja.wikipedia.org/wiki/Intel_C%2B%2B_Compiler
ですか。
ありがとうございます。

>>268
完全にC++テンプレートの仕様を満たしている必要はありません。
Comeauレベルまで要求もしません。
ただ、g++, vc++と並ぶ程度の仕様満足は欲しいです。

>>269
TDM-MinGWはどうよ？
EUC変換を掛ければS-JISも化けないぞ(-finput-charset=cp932 -fexec-charset=cp932)

ああg++使ってるのか
すまんちゃんと読んでなかった

現実問題、その2つ以外に無料でそこそこ使えるものはもうないだろ。

>>272
やっぱりそうですか。
ありがとうございました。

使ったことねーけどさ、
　Digital Mars C/C++ Compiler
ってのがあるけど、あれはどうなんだろう？
テンプレートとS-JISソースがまともに扱えるのかな？

>>274
わからんけどSTLport4.5.3を使っているって随分古いんだね
バグだらけとちゃうか？

>>275
本家スレいって聞いてみるわ

TpAddYenで無理やり通す

>>277
誤爆？

unsigned int型の変数nが
0か、そうでないかについて処理を分ける場合
if(n>0)〜
else***
とすべきか、それとも
if(n)〜
else***
とすべきでしょうか？

可読性的には前者かと思うのですが、速度的には後者ですよね？
どちらがよいのでしょうか？

よろしくお願い申し上げます。

>>279
可読性を云々するのなら、
> 0か、そうでないか
をそのままコードして
if(n==0)〜
else***

速度的には後者？後者は比較をしてないと思ってんのかな。

>>280
それもそうでした。
ありがとうございます。

>>281
> 速度的には後者？後者は比較をしてないと思ってんのかな。
思っていましたが、しているのですか？
コンパイラの最適化があれば同一のコードに行き着く可能性もあるでしょうが。

>>281
これくらい最適化で同じコードにできなければ、
C++コンパイラとして終わっているだろう。

いやいや最適化関係なく、どっちも1回比較する必要あるから。

>>284
最適化関係なく、同一のasmコードに落ち着くということか？
そりゃ本当か？
適当なこと言うなよ。

なんか前フリみたいだな

とりあえずこのようなところでは
ソフトウェアの動作時間に大差ないと思われるので
大丈夫です。

すみません。
ありがとうございました。

>>285
いかに最適化しようと、最低限必要な比較は省略できないってことだろう。

これってどのコンパイラでもNULLなんですか。
char *p=NULL; クラスではこうかけないのですが。

char *p;
if(p==NULL)cout<<"p=NULL\n";

>>289
未初期化の非 static なポインタ変数の値は不定。

クラスのメンバ関数でメモリ確保する場合、
コンストラクタがその関数を呼ぶときに未確保を特定できますか。
初期化する関数　syokika()は単独でも使い、コンストラクタでも使います。

>>291
まずポインタについての初期化と代入を区別して考えること。
そのうえで、ヌルで初期化しろ。

ひととおり動作を確認したら std::auto_ptr か std::vector に置き換えておけ。

わかりました

ウニオンのかっくいい使い方ってないの？

union { not cook, e; } usage;
error: expected unqualified-id before '!' token

union
{
void (*pfunc)(int);
func_obj* pfuncobj;
};

　　　█▄　　　　　　███▄
　　　　　　　███▀　　　　　█████████
　　　　　　███▀　██　　███▀　▄███▀
　　　　　██▀　▄███▀███▄▄▄███
　　　▄███▄▄██▀　█▀　　▀████
　　　▀▀▀▀███▄　　　　　　▄██▀█▄▄
　　　　　　██▀　███　　　██▀　　▀███▄▄
　　　　▄████▀▀██　▄█▀▄▄　　　　▀█████▄▄
　　　　▀█▀▀　　█▄▄█▀　　　████▄　　▀███▀▀▀
　　▄　　　███　▀███　　　　　　▀▀▀
　　███　　███　　▀▀
　　　███　　▀　　　　　　　　▀████▄
　　　　▀　　　　　　　　　　　　　　▀

std::mapのイテレータは必ずソート済みでおけ？

>>298
firstだけな

>>299
の補足
keyでソート

>>298
てか、そのくらいググれカス。

　　　　　　　　█▄　　　　　　███▄
　　　　　　　███▀　　　　　█████████
　　　　　　███▀　██　　███▀　▄███▀
　　　　　██▀　▄███▀███▄▄▄███
　　　▄███▄▄██▀　█▀　　▀████
　　　▀▀▀▀███▄　　　　　　▄██▀█▄▄
　　　　　　██▀　███　　　██▀　　▀███▄▄
　　　　▄████▀▀██　▄█▀▄▄　　　　▀█████▄▄
　　　　▀█▀▀　　█▄▄█▀　　　████▄　　▀███▀▀▀
　　▄　　　███　▀███　　　　　　▀▀▀
　　███　　███　　▀▀
　　　███　　▀　　　　　　　　▀████▄
　　　　▀　　　　　　　　　　　　　　▀

ファイル操作、ディレクトリ探索などは、
他の最適化が無視できるほど時間食うな
プロファイラ使わないとこれ判らん
ファイルをopenしてcloseするだけ、
ディレクトリの探索開始命令だけで時間くう
小さいファイルなどは、ロード時間よりopenが遅い

質問です。
Cのbserarchとstrncmpをクラス内で使いたいのですが…
その際必要となる、比較関数の関数ポインタを引数に渡す必要があると思いますが、
これをクラスのメソッドにしたいのです。
しかし、関数ポインタは静的でなければならないらしく、メンバを引数に指定出来ません。
何か指定する方法はないでしょうか？

>>304
staticをつけると文字通り性的になるよ。
ただし、クラスのメンバにアクセス出来ないはずだから、ほぼ無意味。
それくらいなら自分で実装するか、STLにした方が良いと思う。

っていうかstrncmpは、文字列限定だし
比較関数いらないじゃんｗ

気付かずレスしてる俺もアホだが、
どこぞに誤爆した俺もアホだな。

bsearchは再帰使えば、簡単に実装出来るから
得意ならメソッド内に自前で書いちゃって良いと思う。
苦手なら変なバグ作る前に・・・諦めれ

>>304
やるならこんなかね。

struct A {
  int func(const void* key, const void* obj);
};

struct B {
  const void* pKey;
  A*  pA;
};

int stub(const void* key, const void* obj){
  const B* p = reinterpret_cast<const B*>(key);
  return p->pA->func(p->pKey, obj);
}

〜〜〜〜

A  a;
B  b = { key, &a };
bsearch(&b, base, nmemb, size, &stub);

>>304
メンバ関数でも static 付けてやれば静的になるんで渡せるはずだよ。

ほとんど0な65536個のchar型配列の値を調べるとき
0でないものをひとつひとつ調べるより、
memcmpで一気に32バイトくらいを調べた方が断然速い。
16バイトや4バイト=int型も速くなるけど、いまの設定では32バイトが一番だった。
一度に調べる個数が増え過ぎたら今度は、全部0で無いときの探索が遅くなる。

>>305
引き数に渡したオブジェクトならプライベートメンバだろうがなんだろうがアクセスできるよ
ちなみにネストクラスとローカルクラスも同様

309だけど。プロファイラ無ければ、一生やらないコードと思う。
インテルの Parallel Amplifierはすごく使える。
行単位で時間計測してくれて専用コードの埋め込みの必要なし。
経験版あるので使ってみてくれよ

経験版　→　体験版　だった
インテルのサイト
http://www.intel.co.jp/jp/software/products/intel-parallel-studio-home/amplifier.htm

>>304
bindしてboost vaultのc_functionに通せば普通の関数ポインタになるよ
でも個人的にはそんなイミフな方法より>>305がおすすめ

>>312
スレチだと思うけど…purifyplusよりいいところある？

そっちを使ったこと無いから判らん。
VC2008のプロファイラよりは使える
行単位の計測がいいね。
あとマルチプロセッサー対応。
マルチプロセッサーの為のツールらしいがシングルでもOK

>>308
staticつけたら静的になるのは分かるが、同一クラスで一つの
データメンバを共有する事になるので、場合によっては使えない
ケースも出てくる

インスタンス毎に別々のデータメンバを持ちたい時とかな

>>315
引き数がインスタンスへのポインタなら問題ないと思うが。

比較関数に別々のデータを持ちたいケースなんてあるのか？

ttp://codepad.org/DnbQC2T2

こういう可視性なんかの細かいルールとか知らない人割と居そうだね

<algorithm>のbinary_searchだとだめな理由があるの？

そこはequal_rangeとかだろ

すみません。質問です。
クラスAは、グローバルのバッファのアドレスを保持しているのですが
代入やvectorのpush_backがされた時には、バッファから必要な部分を抜き出して
実体を保持したいです。
これはオペレータ=を適切に作ればいいのですか。
push_backで呼び出されますか。

自己解決しました

A &operatorとA operator(リターンが参照)
return *this;の有る無しでは何が違うんですか?
違いは出ないのですが

class A {
public:
int n;
A(){ n=0; }
A(int k){ n=k; }
A &operator=(const A &x){ n=x.n; return *this; }
};


int main(){
A a(10), b;
b=a;
cout<<b.n;
}

2回代入した場合に違いでました
リターンと参照無しだとcに代入できませんでした

class A {
public:
int n;
A(){ n=0; }
A(int k){ n=k; }
A &operator=(const A &x){ n=x.n; return *this;}
};



int main(){
A a(10), b, c;
c=b=a;
cout<<c.n;
}

>>315
インスタンスは引数で渡されるから、まったく問題ない。

>>319
そんなふうに考えていた時期が俺にもありましたとは。
std::binary_search() の戻り値が bool ひとつだと知るまではね。

かわりに std::lower_bound() + 自前で一回比較すれば bsearch() と同様の
結果が得られる。

320 の std::equal_range() なら自前で比較を書かなくて良いのがうれしいけど、
効率は少し落ちることになりそうだね。

これだとメモリリークします。p[n]はA型です。
オペレータ=はnewでメモリ確保してコピーします。
前のデータが破棄されず、次々に生成されるからと思いますが
STL stringなどでは動作すると思いますがどうやったら前のデータけせますか


A x;
for(n) x=p[n];

自己解決しました

自己解決はやすぎだろw
ほんとにできたのか不安になるレベルだ

map<int,string>を使って値でキーを検索したいんですがイテレータで最初から最後まで回すより高速な方法ってありますか？
連想配列のように使えるならmap以外の方法でも構いません。
色々と間違ってる気がしますがお願いします。

>>330
map::find()

>>330
ない。
map<int,string>とmulti_map<string,int>を相補的に使うというのはどうか。

あー、「ない」というのはmap<int,string>だけならイテレータぶん回すしかない、という意味。

あ、ごめん"値"で"キー"を検索するのか
std:::mapはキーを効率的に検索できるように設計されているので
値は二の次なんでイテレータを回すしかないな

>>332-334
分かりました、mapとmulti_map二つ使ってみます。
ありがとうございました。

stringがユニークならmap2個かな

逆写像って奴だな

boost::bimapがそんな感じのものらしい

pimplイディオムについてです

実装クラスを派生させた実装クラスがある場合
ハンドルクラスはそれぞれ作るものでしょうか？
それとも最終派生クラスについてのみ
ハンドルクラスを用意するものでしょうか？

別に作っても作らなくてもどっちでもいいよ

じゃあ作りません＞＜

>>339
その状況なら、実装を隠す方法として pimpl よりも、最初から
抽象インターフェース＋継承を使ったほうがいいかもしれない。

インターフェース継承って外部クラスに仕様制限を要求されてるようで嫌い

>>343
ん？何を言いたいの？

>>343
純粋仮想関数を否定したいのか？

>>343
> 外部クラスに仕様制限
の意味がわからん。
そもそも外部クラスって何を意味したいのかわからん。

ひとつのクラスに課せられる責任はなるべく小さくするべき
でも、ポリモフィズムの為のインターフェース継承はそこに不必要な責任を要求するおそれがある

そうだな。さっきの言い方はまったく変だな。訂正しよう
ポリモーフィズムの為のインターフェース継承は、クラス利用者が利用されるクラスに対して、不必要な仕様を要求する可能性がある
だから嫌い。だね。仕様を制限するのはまったく逆じゃないか

デザインが根本的に間違ってるんじゃないの？
デザパタ本でも読め

ってかJavaやC#に比べてC++はインタフェースを利用する文化が根付いていないから
色々な団体が作成している各ライブラリ間で互換性がなさ過ぎ

>>349
それは仕方が無い
C++には多重継承があってついついそちらを利用してしまうんで
インターフェースは避けて通る傾向が強い

>>349
色々な団体が作成しているって段階でそりゃ目に見えているだろう。

struct creature { virtual void eat() = 0; };

class cat : public creature {･･･};

↑これはいい
↓これは残念

struct drawable { virtual void draw() = 0; };

class cat : public creature, public drawable {･･･};

正解はdrawableを継承し、メンバにcreatureへのスマートポインタをもったクラスを作り仲介させること

すると開発の際にはクラス間の独立性が高まり、再利用時には不可解なメンバに遭遇し書き直すはめにあうなどといったことが無くなり精神衛生上たいへんよろしい

ただし、速度を優先したいなどの理由があるなら、本来必要無いはずのインタフェースを継承させ持たせてもよい

>>352
それは多重継承の欠点を強調しているに過ぎないだろ

>>352
なぜ「正解」で「独立性が高まる」んだ？
「不可解」とは、何から何を導けないことを言うんだ？

>>352
最近そういうこと勉強したからって、
ここで披露すんなよ
ほんとにチラシの裏にでも書く内容だろそんなこと
ばかはしねw

>>352
何を言いたいのかわからないなぁ。
おかしいなぁ、
相当高度な事を言っているのか
それとも。。。

怒りに任せて否定するだけでは一社会人としていかんよ君達
インターフェースの直接継承の方がアダプタパターンより優れていることを論理的に証明出来なければ、こなまま私の勝ちと言うことになるが宜しいか？

>>357
おしいぞ
> こなまま
肝心なところでかんじゃうタイプ？
追い詰めるときはきっちりやらにゃ

>>357
デザパタを覚えたからと言って、多重継承をすぐ否定するなよ
お前Javaやってんじゃないのか？

JavaやC#は多重継承がないからインターフェースを継承するしかないねえ

>>359
多重継承全てを否定しているわけではなくて、特定少数のクライアントの為だけに提供されたインターフェースを直接継承してできることはアダプタで代用できて、なおかつこちらのはうが害が少ないのだからインターフェースのみの継承は避けるべきだと言っているのです

ごめ、頭悪すぎてわかんねー
もっと具体的に、できれば >>352 を例に説明頼むわ

おいおいw
>こなまま私の勝ちと言うことになるが宜しいか？
この時点でまともな会話できる奴じゃないって気づけよw
話続けても無駄だろ

確かに。
ちょっとファビョり始めたあたり、
関わり合いにならない方が良いか。

それがJavaやC#だったとしても、自分はdrawable（場合によってはcreatureも）をinterfaceにした上で、
catはcreatureとdrawableを継承・実装する作りにするけどなあ。

C++だとinterfaceがないからクラスの多重継承になるだけの話。

委譲は仮想関数が１つや２つならいいかもしれないけど、
delegationのコードを書き捲らなければならなくなること
が多いからなー。現実のcreatureは食べるだけじゃなくて
動いたりウンコしたりSEXしたり．．．なんだし。

〜ableにならないcreatureをinterfaceにするのかぁ。
人クラスのクリーチャーインターフェースのしっぽを引っ張るメソッドを呼んだらどうなるのかな

例えば実数のペアを持つリストクラスとベクタクラスを作ったとする（あくまで例えだから、標準ライブラリつかえよって突っ込みは今はなしにしてくれ）
あるプロジェクトでそのリストあるいはベクタの参照からポリモーフィズム的にポリラインを描画する命令が必要になったから、コードを書くとする
はたしてそのコードをメンバーに持たせるか、外に追い出すか、どちらが賢いのか？
メンバーに持たせたとして、ほかのプロジェクトでそのリストを再利用したときにDrawメンバーを呼び出す気になるか？
メンバーに持たせるのは賢くないしも、呼び出すのもゴメンだ（むしろそんなメンバーを公開するな）と考えた人が多数派だろう
インターフェース継承はその賢くない選択を派生クラスに強制する
一方でアダプタは派生（する予定だった）クラスには一切の変更・追加を要求しない
ヘッダにもソースにもノータッチで、ファイルを追加するだけで求める動作と同じことがより安全にスマートにできる
これでなぜインターフェースを直接継承するのか？
直接継承する明らかな利点はあるのか？

そのクラスにIDrawableをつける必要ないからつけないよ

賢くないしも
なんかこのよく分からない口調のレス前も見たことある

2chでタイプミス指摘して勝ち誇ってる男の人って…

なんのtypoなの？

こなままの方か。
typoよりもその後の言い回しの方がすごいよね

>>366
しっぽを引っ張るメソッドを設けたことが失敗ですよね。
強いて言えば、何もしないとかしっぽがない例外を投げるとかでしょ。

しかし、それがcreatureがインタフェースではなくクラスだったら
もっとよい方法があると言うのなら、ぜひ教えてください。

デザパタスレでも前に暴れていた馬鹿がいたなあ
ちょっとからかってやったら本気でファビョって
一週間ほど粘着された
同一人物とちゃうんか？

>>373
インターフェースにする場合、しっぽを引っ張るとフーッっていうクリーチャーがいる以上、そのメソッドは必要です。

クリーチャーがインターフェースじゃなくてクラスだったら？
そりゃ、継承してしっぽがあるクリーチャークラスを作るでしょうね

なんとdrawableってしっぽを引っ張れるってことだったのか。。。
俺はてっきり描画可能（=形あるもの）ってことだと思った。

つ、つられないよっ

基本設計がおかしい。継承の使用を前提にするとこういう感じにするんじゃないの。
・順序付けられた座標の集合クラス。集合操作に関するメンバのみを持つ。
・ポリラインインターフェイスクラス。描画や結合・分離、変形といった操作をする共通インターフェイスを提供する。
・ポリラインクラス。gdiとかdirectxとか印刷とか描画先にあわせて実装。
ま、論点がポリラインクラスの設計方針にずれるだけだけど。

インターフェース継承よりもアダプタを使ったほうが適していることがある
↓
インターフェース継承は嫌い（良くない）

というつながりが謎。

適している例を挙げられないくらいだから全部ダメかと

　　　　 /: : : : : __: :/: : ::/: : :／/: : :/l::|: : :i: :l: : :ヽ: : :丶: : 丶ヾ　　　　＿＿＿
　　 　 /;,, : : : //::/: : 7l,;:≠-::/: : / .l::|: : :l: :|;,,;!: : :!l: : :i: : : :|: : ::､　 ／　　　　 ヽ
　　　 /ヽヽ: ://: :!:,X~::|: /;,,;,/: :／　 ﾘ!: ::/ﾉ　 l｀ヽl !: : |: : : :l: :l: ﾘ /　そ　そ　お　＼
　　　/: : ヽヾ/: : l/::l |／|||llllヾ,､　　/ |: :/ , -==､　l＼:::|: : : :|i: |　/ 　 う　う　 前　　|
.　　 /: : : //ヾ ; :|!: ｲ､||ll|||||::||　　　 ﾉノ　 ｲ|||||||ヾ､ |: ::|!: : ｲ: ::|/　 　な　思　が
　　 /: : ://: : :ヽｿ::ヽl |{ i||ll"ﾝ　　　 ´　　　i| l|||l"l　｀|: /|: : /'!/l 　 　 ん　う
　∠: : : ~: : : : : : : :丶ゝ-―-　　　　　 , 　ｰ=z_ｿ　　 |/ ﾊﾒ;, :: ::|.　　　だ　ん
　　 i|::ﾊ: : : : : : : : : : : ､ﾍﾍﾍﾍ　　　　 ､　　ﾍﾍﾍﾍﾍ /: : : : : ＼,|.　　　ろ　な
　　 |!l　|: : : : : : : : :､: ::＼　　　　､-―-,　　　　　　/ : : :丶;,,;,:ミヽ　　 う　 ら
　　　　　丶: :ﾊ､lヽ: :ヽ: : ::＼__　　｀~　"　　　　　 /: : ﾄ; lヽ）　　　ゝ
　　　　　　 ﾚ　｀|　｀､l｀､＞=ﾆ´　　　　　　　 ,　　_´ : :}　｀　　　／
　　　　　　　　 ,,､r"^~´"''''"t-｀r､ _　　-､　´ヽノ　＼ﾉ　　　／　　　　お ・
　　　　　　　,;'~　　_r-- ､__　　　　　~f､_>'､_　　　　　　　　 |　　で　　前 ・
　　　　　　f~　　,;"　　　　　~"t___　　　　ﾐ､ ^'t　 　 　 　 　|　　は　　ん ・
　　　　　 ,"　　,~　　　　　　　　　ヾ~'-､__　ﾐ_ξ丶　　　　　|　　な　　中 ・
　　　　　;'　　,ｲ　.. 　　　　　　　　　ヽ_　　 ヾ､0ヽ丶　　　　l　　　　　　　　　/
　　　　 （　;":: |:　:: ..　　　　　　　　　 .｀,　　 ヾ　丶 !　　　　＼＿＿＿＿／
　　　　　;;;; :: 入:: :: :: 　 　　　l｀ｰ-､　　 ）l　　 ヾ　丶
　　　　　"~､ｿ:: :い:: :　　　　　＼_　　ノ　,　　　 ヾ　丶

C++の仕様に文句を言う奴はJavaかC#でも使ってろってこった

>>381
これなに？

>>381
お前を待っていた！wwww

>>378
> ポリライン
ワイヤーフレームじゃね？

違います

LineToを何度も呼び出すよりPolyLineで一気に書いたほうが早いよ？

って書いてあったのでやってみたらマジ速くて
チャールズ・ペゾルド先生らぶ♥って感じ。

メモリプールしたらめっちゃはやなってワロタｗｗｗ

「ifとelse」を用いれば「三項演算子」でできる処理は全て記述できますよね。
しかし逆は必ずしもできません。

では「三項演算子」でできる処理ならとにかく「三項演算子」で書けば
可読性はともかくパフォーマンス的には必ず望ましいと考えてよろしいのでしょうか？

よろしくお願い申し上げます。

細かいことは知らんけど、んなこと気にしてる暇があったらもっと影響のでかい部分の高速化を考えたほうがいい

>>389
実測あるのみ

まったくだ。
そんなことも自分で考えられないやつが高速化とか言うのは１００％間違っているから気にすることはない。
つーか、スレ違いだろ。

>>389
三項演算子じゃなきゃ記述できないこともあるぞ
enumの定義とか

>>279と同一人物だろ

> > 速度的には後者？後者は比較をしてないと思ってんのかな。
> 思っていましたが、しているのですか？

こんなんだぞ

>>390-392
そういうものですか。
ありがとうございます。

>>393
なるほど。
　ttp://codepad.org/5RMC4FxC
こんな感じでしょうか。

>>395

enumの定義が条件によって変わるなんて気持ち悪いから
考えなくてよい。

いや、気持ち悪くないよ
天ぷらメタプロで普通に使うし

それはテンプレートの内容によって振る舞いを変えたいからでしょう？
>>389の質問に沿ってないんでは。

>>396-398
ありがとうございます。
TMPのようなコンパイル時処理においては
「三項演算子」でしか無理なものもあるということ
理解致しました。

そもそも3項演算子でしか書けないのって全部文法上の問題っしょ。
どっからパフォーマンスに繋がるのか。

条件演算子と呼べ。

条件演算子以外の3項演算子を書け

0 < x < 10

なんで俗称のほうを守るための反証が要るんだ？

俗称？なにをいってるんだ

俗称じゃなくて is - a 関係だぞ。

カモノハシが卵生哺乳類としか呼んでもらえなかったらかわいそうだとか、そういう

横から失礼します。

std::numeric_limits<double>::infinity()
の標準C++で規定されている仕様を知ることができる資料を
無償で閲覧できる方法はありませんでしょうか？
例えば
std::numeric_limits<double>::infinity()*0.0
の演算結果などです。

>>408
テンプレ見れ・・・と思ったらテンプレ無いのか。

↓ここからどうぞ。

[JTC1/SC22/WG21 - C++]
　http://www.open-std.org/jtc1/sc22/wg21/
　　ここから規格の最新（2003より新しい）ドラフトがダウンロードできる。

http://www.jisc.go.jp/app/JPS/JPSO0020.html
ダウンロードはできないけど、ここから「X3014」で探せば現行のJIS規格が読める

>>407
カモノハシじゃなくて
カワウソだったら合格

意味がわからん。

>>409-410
ありがとうございました。
ひとまずcurrent draftというものをDLしました。

C++0xのドラフトを今薦めて大丈夫か？
浮動小数点のあたりってC99との摺り合わせで影響受けてないのかな

カワウソとしか呼んでもらえなくてかわうそうだとか、そういう

マサバでもヨシノボリでも魚と呼んですましていいこともあるだろうと。

何でカワウソｗ
カモノハシの例は確かにそう思う。
けど卵生哺乳類と言えばカモノハシなので別にいいじゃんと思うんだ。

単に魚といえばマサバかヨシノボリか分からないだろう？

ハリモグラは無視ですか。そうですか。

カモノハシだからおｋ

>>411
はカモノハシが卵生の哺乳類ということを知らなかったんだろう。

c++のコンテナ(vectorとかlist)に
char *p = new char[10];とかのpって積み込めない？
固定長配列なら積み込めるのか？
(vector<char>使えってのはなしでお願いします）

>>421
「積み込む」の意味がわからん。

内容をコピーしたいなら assign() すればいいし、
そうじゃなければ最初から vec・・・配列 new なんか使わなければいいのに。

vector<int> vec(100);

memcpy(&vec[0], p , 100);

なら出来るが、&vec[0]に他所で確保したアドレスだけを渡すのは出来なかった記憶。

>>422
string(p,N); だと、string型が生成されて、Nバイトのコピーが発生するが
コピーなしで出来ないかと言うことでは。

とりあえず、stringやvectorで作ってみて、そこがボトルネックになっていたら、ポインタ渡しなどに書き換えるのが吉
はじめから技巧をすると失敗する　複雑化する。
とりあえずコピー作ってもいいから簡単に済ますべき。

>>421
なんで vector<char> 使うのは無しなの？

>>423
C++ で memcpy() なんか使うんじゃありません。
案の定バグってるし。

レス早。thxです。

やりたかったのはこんなこと
vec.push_back( p );とか。
vec[0]で、pを取り出しても、配列の長さはどこかに保存してないとダメだよね？->この方法は使えない
って考えは正しい？

vector<string> vec;


vec.push_back( string(p,strlen(p)) );

だな。

vec.push_back( (string)p );　や　vec.push_back( p );
でもおけかもしれないがサイズは指定した方が良い。
\0があっても格納可能。

>>429 それ、 strlen() いらない。

thxです。
バイナリデータ載せるんで、strlenとか使えないっすわ・・・
ためしに、
vector< char [100] > v;
とかやっても、コンパイルエラーでました。固定長配列も、コンテナの要素には出来ない？

>>432
だから、なんで vector<char> ではダメなのかと。

ちなみに struct char100 { char data[100] }; なら vector<char100> できるよ。

バカに付き合うとくだらない苦労だけが発生する典型だな。

>>433
ありがと。

Cで、単に今までPOD(でいいのか？）の配列を操作してたものを
C++で書き換えてるんだけど、
単にmemcpyできてたのを、vectorに変えると速度がきになるかなーと。
ほとんどバイナリデータを扱う処理だから、
vectorで書いちゃったあと、速度出ませんでした。ってなるのが怖かった

>>434
バカでさーせん

仮のstringクラスつくればいい。

{ char * , unsigned int }のクラス。これならコピーは無いから速い。

>>435 >>425

残るのは虚しさのみ。

開き直った馬鹿ほど相手に困る物は無い

実際仕事してて、そんなの無理でしょ。
一度作ってパフォーマンスが悪かったから全部書き換える。
とか、そんな時間あるわけないだろ・・・
つーか、vector使わなかっただけでバカ扱いか。ひどいな

vector のパフォーマンスが問題になったからって「全部」書き換えるなんてことになるわけがない。
計測もしてないのに変に速度を気にして話を面倒にするのは馬鹿と言われてもしかたがない。

>>440
初めから >>421 では vector 等に組み込めないかとういう話じゃないの？

構造体に char [10] を入れてpushとかそういう考えは沸かないのか？

馬鹿に多くを求めても。

質問です。
こちらは、staticのバッファ持っていて　write( char*p, int n); 　
こちらはバッファを書き出したいのですが　　write( );　
この二つだけからアクセス可能なバッファは作れないですか?

>>445
たぶんスレ違いだね。
↓こっちへどうぞ。
http://pc12.2ch.net/test/read.cgi/tech/1187922645/

n=0 or -1なら書き出すという方法が一番いいですか

write とバッファをクラス化して、write だけ public、バッファは private にすれば？
バッファが不定のままになるのをどう対処するかはまた別の問題だが

設計から見直すべきだと思う。

日本語を勉強しなおすべきだと思う。

すみません。このようなクラスAとBがあったとき、Aのメンバ関数がBのxにアクセスする方法無いですか。
B b; のとき、 b[n].fnc();がクラスBのxを使いたいです。


class B {
public:
vector<int> x;
A operator [] ( unsigned int n ) ;
};:

元がどのBクラスのオブジェクトなのか特定する方法がないと駄目ですよね

B b,c;のとき、b[0]もc[0]もクラスAになってしまい、ここからbやcが特定できないので。

良い方法無いですか。

>>450

>>451
先ずはAの定義を晒せ。つーか、AにBの参照でも持たせておけばいいんじゃね

ややこしいのでそのままかけないですが、

Bの*thisポインタをAのメンバに入れたら出来そうですね。

thx!

#include "DxLib.h"

int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,LPSTR lpCmdLine, int nCmdShow ){
ChangeWindowMode( TRUE ) ; //ウィンドウモードにする。
if( DxLib_Init() == -1 ) return -1; // ＤＸライブラリ初期化処理 エラーが起きたら終了


int i,a=0,time;
int White;
White = GetColor( 255 , 255 , 255 ) ; // 白色の値を取得

time = GetNowCount() ; // 現在経過時間を得る
DrawFormatString(0, 0, White , "立ち上がってから%d分%d秒", time / 1000 / 60,■■■);//文字列表示

for(i=0;i<100000;i++) //10万回a++;を実行
a++;

time = GetNowCount() - time; //現在の経過時間から先ほどの経過時間を引く
DrawFormatString(0,100, White , "計算時間%dミリ秒" , time);//文字列表示


WaitKey() ; // キーの入力待ち(『WaitKey』を使用)
DxLib_End() ; // ＤＸライブラリ使用の終了処理
return 0 ; // ソフトの終了
}

秒をどうやって表示させればいいか、悩んでます・・・
■■■の部分です

time / 1000 % 60

うおおお！！天才あらわる！
あざーーす(゜∀゜)

こんなんで天才だなんて言ったら>457が照れちまうぜ。

照れる前に呆れるわ

基本からやっぱり学びます

こういうの何っていうんだっけ
cyclic group？

http://codepad.org/MPCQaLmD

名前空間でnewの切り替えをしようと思ったけどできなかった
こういうことはもとからできないものなん？

>>421
std::vectorの要素にarray<char, 10>とかboost::shared_array使うのはどう？

>>463 そうだよ。エラーメッセージでも言われてるね。

a

おお規制解除されてる！！ギザウレシス！つーか運営市ね！

std::vectorに入れて使うよう、あるクラスを作りましたが、
代入演算子を持たない為、push_back()でこけてしまいます。(VC8EEでC2582)
多分そのクラスが参照をメンバに持っている為だと思いますが、どうすればvectorに入れられるでしょうか？
↓こんな感じです。
class A
{
B& b;
A( B& b_ ) : b(b_){}
};
int main()
{
B b;
std::vector< A > v;
v.push_back( A(b) ); // C2582
return 0;
}

コピーコンストラクタな

>>468
早速コピーコンストラクタを作ってみましたが
同じでした。

"c:\program files\microsoft visual studio 9.0\vc\include\xutility(3133) : error C2582: 'operator '=' 関数を 'houz::`anonymous-namespace'::A' で使用できません。"
ってことだけど、operator=は作れそうに無いし・・
これは無理ってことですかね？

>>467
そういやそれは無理だな
メンバにBへのリファレンスを持っているからこれは初期化でしか
値を結合できない
operator=は初期化子が使えないから無理かも
無理矢理やると次のようになるかも

class B {
public:
void show() const { std::cout << "class B" << std::endl; }
};
class A
{
B& b;
public:
A(B& b_) : b(b_) {}
A(const A& a_) : b(a_.b) {}
A& operator=(const A& a_) {
std::memcpy(&b, &a_.b, sizeof(b));
return *this;
}
void execB() const {
b.show();
}
};
int main()
{
B b;
std::vector<A> v;
v.push_back(A(b)); // C2582
v[0].execB();
}

リファレンスメンバを含むクラスで代入をサポートしたければ、自分で代入演算子を定義しなければならない
Effective C++ 第2版 p.237 第45項「C++がどんな関数を黙って書き、呼び出しているか、知っておこう」

>>471
ちょっとずれてるぞお前
今話題にしてるのはリファレンス変数への代入は無理だという事だ
だから標準では無理なので無理矢理memcpyを使ったわけ

>>467
> 代入演算子を持たない為、push_back()でこけてしまいます。(VC8EEでC2582)
> 多分そのクラスが参照をメンバに持っている為だと思いますが、どうすればvectorに入れられるでしょうか？

↑ここまでわかっててわざわざ質問する意味がわからん。

>>472
わかってるかもしれないが、未定義動作な。

それでいいんなら最初からポインタにしとけ、と。

>>472
かつらの人に「ずれてる」とかかわいそうだろ。

じゃなくて、>>470へのレスじゃないよ＾＾
>>467へのレス。ゆっくりしていたら話がちぐはぐになった。
レス番つけなくてすまん。

>>474
仕方がない
無理を通せば鼻から悪魔、だ

>>472-474
>>470の方法でコンパイルは通るようになりました。
ただ、const参照も使っていたせいでconst_castとmemcpyの
ちょっとデンジャーな実装になってしまいました。
未定義動作は困るので、ポインタ配列で作り直そうと思います。
ご対応ありがとうございました。

>>473
対応策があるかないかわからなかったので質問させて頂きました。

>>477
クラスの定義を変更しないと無理なのに、どこを変えてもいいのか >467 を読んだだけの
こっちにはわからんのだよ。こんどから気をつけてな。

どうやらこれでもいいみたいです。
やる意義はないとは思いますが。

class A
{
B* pb;
B& b;
operator=(B& b_)
{
pb=&b_;
}
A() : pb(0), b(*pb){}
}

>>478
すみません。以後気をつけます。

>>479
だめだよ
bが変更されてない
バグる

そもそも参照なんかをデータメンバーにするのが悪いんだよ
利点まったくないぜ？

>>481
参照をデータメンバーにする事にケチつけるレベルなんだねｗ

じゃあポインタではなく参照を使うことにメリットがある場合教えて

binder1st を ostream::operator<< に使いたいときとか？

ポインタと違ってNULLが存在し得ないというだけでも用途はあるだろ。

そんなもんクラスの中でNULLにならないようにちゃんと管理しろよ……
データメンバーだぞ？

少なくともconst referenceがテンポラリを保持できる時点でポインタより優れている。
ポインタはこれができないからな。

const の reference はたしかによく使ってるなぁ…

>>486
newしたポインタは必ずdeleteするようにちゃんと管理しろよ
戻り値のエラーコードはちゃんと全部チェックしろよ
4byte以上の型のためにメモリを確保するときはちゃんとアライメント管理しろよ

基本は参照
参照先を途中で変えたいときはナマポ
参照先の寿命がクライアント依存ならスマポ
これで完全無欠

本を読んでメモリプールを作ってみたんですが、これをstd::listのpushなどで使わせるにはどうすればいいんでしょうか？

アロケータを作ってlistのテンプレート引数に入れる

もしくは operator new を利用者定義する

>>492さん
ありがとうございますo(^-^)o

>>493
適当な事言うな死ね

適当って言葉の使い方がＤＱＮぽいね

>>489
参照の代わりにポインタを使う、という用途(話の流れから当然だよな)なら
newする必要なんか無いし、
別途存在する実体から得たアドレスで初期化するだけなんだが。

>>496
お前例え話苦手だろ、アスペにありがちな症状だぜ。 俺もだけど。

人を無闇にアスペ認定するところもアスペの特徴です

templateで、渡された引数が、
map型か(__gnu_cxx::hash_map、std::map類)、
それ以外か(std::vector, std::queue, int, struct Hoge)、
2通りに分ける方法ありませんか？

std::Iterator_traits::iterator_categotyで分岐すればいいんじゃね？

×std::Iterator_traits::iteraotr_categoty
○std::iterator_traits::iterator_category

http://boost.cppll.jp/HEAD/more/generic_programming.html

ここら辺を参考に

tenpureto<taipuname T> struct izu_mappu{ enum{ varyu = false }; };
tenpureto<taipunemu K, taipumenu T> struct izu_mappu<std::map<K, T> >{ enum{ varyu = true }; };

はわわ、タイプミスしちゃいました〜／(>ﾛ<)＼
でもテンプレートの特殊化は引数に渡されたクラスのテンプレート引数を特定しなくてもできるよ！o(^-^)o
よかったね〜＼(^∀^)／

(^o^)

(＾o^) 自殺したい

>>506
(^o^)何で自殺しないの？

>>500
>>502
ありがとうございます。見てみます。

自殺死体と逝ってる香具師は自殺竹刀の法則

逝ってる香具師…

ファイル出力のやり方なんですが
タイムステップごとに新しいファイルに出力、たとえば
file1.dat、file2.dat・・・filei.dat
みたいにするにはどうしたらいいですか？
ofstream　out(filei.dat)　のiだけを変える方法がわかりません

知らんがな（´・ω・`）

"file?.dat"は文字列じゃないの？

>>511
たとえば file名を string にして i も string に変えて

string filename("file");
filename + boost::lexical_cast<string>(i) +".dat";
ofstream out(filename.c_str());

boost 使ったけど、int->string は他にもいろいろ方法あるよ。

#include <fstream>
#include <sstream>

int main(void)
{
using namespace std;

for(int i = 0; i < 10; ++i)
{
stringstream SS;

SS << "file" << i << ".dat";

ofstream OFS(SS.str().c_str());

OFS << "hello!";
}

return 0;
}

すまん疲れててミスした

filename += boost::lexical_cast<string>(i) +".dat";

ただ初め二行は

string filename("file" + boost::lexical_cast<string>(i) + ".dat");

で良い。

lexical_castを使うのなら面倒だが

ostringstreamにiを流し込んでメンバ関数str()な

×使うのなら
○嫌なら

文字列の加工にsprintf()を使う癖がある元Cプログラマな俺は
C++的にはあまりよろしくないんでしょうか？
オーバーフロー的な問題なら、snprintf()でいいかなーって思うんですが・・・

悪いこと言わんから boost::format にしておきなさい。

>>519
癖に止めてくれるなら問題ないよ。
例えばメンバ関数内の実装で君が責任を持って処理できるとかなら。
実装に触れなくても大丈夫なようにちゃんとカプセル化してくれるなら。

他人にsnprintf()を要求し始めたらだめだけどさ。

>>519
いいことを教えてあげよう
世の中にはnを無視して単にsprintfに委譲するだけのクソのようなsnprintfが実在する

1Gぐらいのバッファ使えば、しばらくもつでしょ

>>522
クソすぎてﾜﾛﾀが、それはsnprintfを使わない理由としては弱いだろ。
大半のsnprintfの実装はまともなんだから。


まぁboost::format使っとけ。

boost::format って exe でかくならない？

VCならsprintf_sとか

373まで読んだ

質問です。
ofstreamで、テキストファイルに大量のデータを書き出しているんですが、
途中で落ちてしまいます。どうやらデータがすくないとおちずに済むようです。
都合上1行に長々とデータを書き出して行きたいのですが、
1行に書き出せる文字数の制限や、streamで扱えるファイルの大きさなどに
制限はあるのでしょうか?

適宜フラッシュする

>>528
処理系のバグ

入出力は、OS依存のバイナリ書き出し使えや。
windowsならcreatefileWなど。
C言語のラッパーは信用ならん。

バッファは、128Kくらいあればパフォーマンスは落ちないだろ。
こんな感じでよいだろう。

write(string s ){
static string buf;
int n=buf.size();
int r=s.size();
buf.resize(n+r);
memcpy(&buf[n], &s[0], r);
if(n+r>(1<<17)) {書き出し　buf.resize(0); }
}

何そのきもいstring。

これでいいか

write(string s ){
static char *buf = new char [1<<17];
static int bufsize=0;
int r=s.size();
if(r+bufsize>(1<<17)) { bufとsの書き出し　bufsize=0;　return; }
memcpy(&buf[bufsize], &s[0], r);
buf+=r; }

バグだらけだな。なんでそんなクソコードかくん？

こっちのほうがいいか

write(char *p, int size ){
static char *buf = new char [1<<17];
static int bufsize=0;
if(size+bufsize>(1<<17)) { bufとsの書き出し　bufsize=0;　return; }
memcpy(&buf[bufsize], p, size);
buf+=size; }

コンパイルして確かめてないからな。そのまま書き込み欄へ直書き。
なぜ書くかと言えば、一行ずつ書き込むと入出力に時間食うからだ。
128KBほど蓄えておけば快適。
あと最後にバッファが残ると書き出されないので注意。
クラスのデストラクタなどと組み合わせると、自動で書き出し、closeできるのでやってみてくれよ

アフォすぐる。

こんな酷いコード見たの久々だ

これはまたひでーな。
とりあえず、buf+=sizeとかしてどうするつもりなんだ。
人類の平和のためにお前は2度とコードを書くな。

話は変わるが、stringなど可変長の変数は、
newで確保するのが良い場合もあるな。
ソートなど。
vector<string>のソートはメモリ大移動するけど
vector<string*>はindexだけの入れ替えで済む。

std::swapって特殊化されてないんだ

実測してみるよ

>>541
可変長じゃなくても実体もったらコピーだらけだろｗ

>>542 　4倍くらい違うぞ。コンパイラに期待しない方が良い。
#include <string>
#include <vector>
#include <iostream>
#include <windows.h>
#include <algorithm>
using namespace std;
bool comp(const string* &l, const string* &r){return (l->compare(*r))<0;}
void timer(){static char c=2, d;static unsigned int cnt=1;static LARGE_INTEGER cl[2];static double cnst;
if(c==2) { QueryPerformanceFrequency(&cl[0]);cnst=1000.0/cl[0].LowPart; c=0; QueryPerformanceCounter(&cl[0]); return; }
d=(char)(1-c); QueryPerformanceCounter(&cl[d]);
cout<<"timer:"<<cnt<<" = "<<(cl[d].LowPart - cl[c].LowPart)*cnst<<endl;c=d; cnt++; }

unsigned int xorshift(void) {
static unsigned int x=123456789UL,y=362436069UL,z=521288629UL,w=88675123UL;
unsigned int t=x^(x<<11); x=y; y=z; z=w; return w^=(w>>19)^t^(t>>8); }

int main(){
unsigned int n,s,t,x;
vector<string> v;vector<string*> w;
string buf(40*16, '\0');
timer();
for(n=0; n<(1<<17); n++) {
for(s=0;s<16*40;s+=16){
x=xorshift();
for(t=0;t<16;t++) { buf[s+t]=(char)('A'+(x&3));x>>=2; }}
v.push_back(buf); }
timer();sort( v.begin(), v.end() );timer();
for(n=0; n<(1<<17); n++) w.push_back( new string(v[n]) );
vector<string>().swap(v);
timer();sort( w.begin(), w.end() , comp);timer();
cout<<"timer2がvector<string>、timer4がvector<string*>のソート\n";}

この速度さはなぜでしょうか。staticよりグローバルの速いのは一般的ですか。2倍は速いです。

#include <iostream>
#include <windows.h>
using namespace std;
void timer(){static char c=2, d;static unsigned int cnt=1;static LARGE_INTEGER cl[2];static double cnst;
if(c==2) { QueryPerformanceFrequency(&cl[0]);cnst=1000.0/cl[0].LowPart; c=0; QueryPerformanceCounter(&cl[0]); return; }
d=(char)(1-c); QueryPerformanceCounter(&cl[d]);
cout<<"timer:"<<cnt<<" = "<<(cl[d].LowPart - cl[c].LowPart)*cnst<<endl;c=d; cnt++; }

unsigned int xorshift(void) {
static unsigned int t, x=123456789UL,y=362436069UL,z=521288629UL,w=88675123UL;
t=x^(x<<11); x=y; y=z; z=w; return w^=(w>>19)^t^(t>>8); }

unsigned int tt, tx=123456789UL,ty=362436069UL,tz=521288629UL,tw=88675123UL;
unsigned int xorshift2(void) {
tt=tx^(tx<<11); tx=ty; ty=tz; tz=tw; return tw^=(tw>>19)^tt^(tt>>8); }

int main(){
unsigned int n,s=0;
timer(); for(n=0; n<(1<<26); n++) s+=xorshift2();
timer(); for(n=0; n<(1<<26); n++) s+=xorshift();
timer(); for(n=0; n<(1<<26); n++) s+=xorshift2();
timer(); for(n=0; n<(1<<26); n++) s+=xorshift();
timer(); cout<<(s&1)<<endl;}

すみません
コンパイラ次第でした。
bccだけグローバルが速いです
gccはどちらも遅く、vcはどちらも速いです

gccに速度を求めてもしょうがねーだろｗ
てか、そんなクソコード入れるとＰＣ壊れるぞ？

>>546 アセンブリ嫁

あとGCCは最近ベクトル化とかもやりだして、最適化はかなりよくなってる（ICCをしのぐこともある）
参考文献 http://www.linux-kongress.org/2009/slides/compiler_survey_felix_von_leitner.pdf

gccの魅力はそのプラットフォームの多さと標準準拠度の高さだろう。

実際、Comeauの次にVC++と並んだ標準準拠度の高さだと思うのは俺だけではないだろう。

Comeauはexportで燃え尽きてC++0x対応はやる気が無い感があるがな

同じ名前で、複数のメンバ関数を切り替えて使いたい場合はメンバ関数ポインタを使うのが一番スマート？
これよりいいやり方は無いかな？

#include <iostream>

class CHoge
{
typedef void (CHoge::*MemFunc_t)();
MemFunc_t mMemFunc;
public:
void memFuncA() { std::cout << "CHoge::MemFuncA" << std::endl; }
void memFuncB() { std::cout << "CHoge::MemFuncB" << std::endl; }
void setMemFunc(MemFunc_t memFunc) { mMemFunc = memFunc; }
void memFunc() { (this->*mMemFunc)(); }
};

int main(void)
{
CHoge hoge;
hoge.setMemFunc(&CHoge::memFuncA);
hoge.memFunc();
hoge.setMemFunc(&CHoge::memFuncB);
hoge.memFunc();
return 0;
}

っ継承

>>552
設計にもよりますが
普通に考えて

class CHoge_A : public CHoge;
class CHoge_B : public CHoge;

が自然である状況が多いと思いますよ。

is a も has a もへったくれもねー議論だな

継承で書けるならそうしたいんですけど、それだと外から切り替えるのがむずかしかないですか？

>>555
だから「設計にもよるが」と断りを>>552に書かれているだろう。

というより、そもそもの問題を解決するにはまったく別なスマートな方法がある、に３カノッサ。

>>558
そんなもの存在しない、に1カノッサ。

>>559
その場合は問題自体が存在しないということだ。

あらかじめ用意されてる処理のどれかを行うだけならmemFuncの中で引数かメンバ変数をキーにしてifで振り分ければいいんじゃね。

おれもそれが言いたかった
is a とか has a とか言う前に
結局何ができればよいのかという what に立ち返ったとき
選択肢はありすぎるほど色々だろうって

>>561
それ、関数ポインタでやるのと同じ。

>>563
同じことなら、なおのこと関数ポインタなど持ち出す必要はないということだろ。

>>564
たして変わらんがな。

とりあえず、質問者はそもそも何がしたいかを言え。不毛なのはお互い損だろ？

>>561
そしてenum,switch,if-else地獄に突入の予感

おれもそれが言いたかった
以下、略。

メンバ関数ポインタ使っても呼び出し側で hoge.setMemFunc(&... あれ？どんなメンバ関数あったっけ？地獄に突入の予感。

そこは人間がやる部分じゃないからね

だから>>565だと言っとろーが。不毛だからもう、いい。

>>568
つ入力補完

やりたいことはキーボードやジョイパッドからゲーム内仮想キーの変換で
変換テーブルを変えられるようにしたいのと、キーコード（ライブラリヘッダ内の）を隠蔽したいって要求もある
キーボードの入力は
class i_keyboard // ゲームによらず共通
{
public:
virtual bool check_a();
・・・
virtual bool check_shift();
・・・
};
見たいな感じでキーコードと実装が隠蔽されている既存のクラス（これはもう触りたくない）で取得
で、ゲームキーへの変換に
class game_input // Facade、ゲームによって細部がかわるかも（ボタンの数とか）
{
i_keyboard *kb;
public:
bool check_a() { return kb->check_z(); }
bool check_b() { return kb->check_x(); }
bool check_x() { return kb->check_a(); }
bool check_y() { return kb->check_s(); }
bool check_l() { return kb->check_q(); }
bool check_r() { return kb->check_w(); }
・・・
} ;
とやってる
固定キー配置ならこれでいいんだけど、キーコンフィグでゲーム内でのボタンをキーボードの何に対応させるかを変えられるようにしたい
そのためにgame_input::check_XXX()がどのi_keyboard::check_YYY()を呼び出すか、外から切り替えられるようにしたい
一人でどうしようかと悩んだ結果メンバ関数ポインタがましかな？というところに落ち着いたんだけど、ほかにいいアイデアが無いもんかと質問した

>>572
よくもまぁキーいっこごとに関数なんか作ったもんだ。そこが失敗に違いないんだろうけど、
i_keyboard とやらをほんとうに変更したくなくて、キーコンフィグのためにキー識別子のような
ものを用意しなくて済むのなら、関数ポインタでもなんとかなるかもしれない、みたいな。

>552
っ トランポリン関数

ゲームのキー入力みたいな反応シビアな所に仮想関数使うな

仮想関数の呼び出しコストなんて鼻くそみたいなもんだろ

自分のこだわり以外に制限事項がないならこだわりを捨てて再設計したほうが楽そうだな。

典型的なバカなゲーム屋だな

不毛な議論だが、元を手繰っても不毛だと分かる。
まぁ典型的な質問だがな。

べつにないこともないとおもうけどなぁ。俺もマクロが大量に現れるコードのほうが気持ち悪いって感じるわ。ついカプセルしたくなる

すみません。
テンプレートクラスを型を指定して？継承することってできるんですか？

template<typename T> class Hoge
{
virtual T& Combine(T& other) = 0;
};

// そもそもこんなことできるのか
class Foo : public Hoge<Foo>
{
virtual /*どう書けばいいのか*/ Combine(/*ここもどうすれば*/);
};

教えてください。お願いします。

>>581
つCRTP

CRTP調べてみました。

でも、できるものならほかの方法はないのでしょうか。
Hogeはインターフェースとして使いたいので、もっと単純にできる方法はありませんか？

>>581
T に Foo を指定してるんだから、 T& だったところを Foo& にすればいいだけだよ。

>>581
は何がしたいのか分からない。
Combineは何をする関数なんだ?

template<typename T> class Hoge
からすると>>584の通りだと思う

>>584
>>585
返答してくださってありがとうございます。
すんません。質問するためにコードを書きなおして似たようなコードを作ったのですが、分かりづらくしてしまい、申し訳ございません。(-_-;)

>>584

...

virtual Foo& Combine(Foo& other); // 実装は別

...

'Foo' : 抽象クラスをインスタンス化できません。
次のメンバが原因です:
'T& Hoge::Combine(T &)' : は抽象型です

と言われてコンパイルが通りません。

↑誤爆しますた

>>586
エラー通りだな

>>586
少なくとも以下のコードなら手元の g++ 3.4.4 で通る。

template<typename T> class Hoge { virtual T& Combine(T& other) = 0; };
class Foo : public Hoge<Foo> { virtual Foo& Combine(Foo& other); };
int main() { Foo x; }
Foo& Foo::Combine(Foo& other) { return *this; }

コンパイルエラーが再現する完全なソースを出してもらわないことにはなんとも。
あるいはコンパイラを特定するとか。

http://codepad.org/ffxTaX1V

べつにどっちでもいい

これどういった状況で使うの？581さん

申し訳ございません。解決しました。
元のソースでの引数の修飾子が間違っており、コンパイルすることができました。
ご迷惑おかけしました。

# ちなみにコンパイラはVC++です。

>>593
人に相談するときは変にソースやエラーメッセージを省略しないように、今度から気をつけなよ。

急いでいたんだろうがこの文だけ読むと変な文だな。もちけつ。
> 元のソースでの引数の修飾子が間違っており、コンパイルすることができました。

インターフェースに演算子のオーバーロードを組み込んだらそれはインターフェースといえるのだろうか

>>596
インターフェースであるための要件について、演算子のオーバーロードの有無で何が変わるというの？

>>596
むしろ普通にありうる事だと思うんだが。
この演算子を持っていてほしいとか
あり得る話だろ。

インターフェイスと言えなかったら何だって言いたいんだろう、この人

shared_ptr使いたいんだけど、boostとstd::tr1、どっち使ったほうがいいの？

>>600
boostが禁止されているところ以外では
boostがお薦め。

わっかりましたー

boostとtr1って性能違うし？

>>603
そうなの？

boostproをつかってのインストールの仕方がわからん
誰か教えてくれ

C++ boostライブラリのインストールね

boost proってなに？
standardとかliteとかあんの？

普通のBoostじゃダメなの？
それ以前に大抵のライブラリはヘッダだけで足りるだろ。

　ttp://codepad.org/7vBd9o7i
このコードが通りません。
intを取るコンストラクタが2つになることで
ambiguousなオーバーロードとなることが
原因だろうと思い、
　ttp://codepad.org/Hu73nqUr
このようにしてみました。

このようなコンストラクタをテンプレートにするというのは
問題がおこりますか？
よろしくお願い申し上げます。

>>609
べつに。

static_cast が余計なのと explicit は要らんのかというのが気になるぐらい。

>>610
>static_cast が余計
私もそう思ったのですが、
外すと
　ttp://codepad.org/AHK1CSzr
このようにエラーになります。
本来は警告warningだと思うのですが。

> explicit
この場合、C++の教科書的な作法としては
　template <typename S>Myclass(const S& arg)
　Myclass(const T& arg)
の どちら|両方 に付けるべきなのでしょうか？

>>611
じゃぁテンプレートのほうには static_cast 付けといたらいいかもね。
T がなんでもアリなら、場合によっては無駄なコードが出そうだけど。

explicit の有無はクラスデザインしだい。それだけのコードじゃ判別不能。
ただし付け忘れて事故ることのほうが多いんで、ひとつも書いてないと気になる。

>>612
> explicit の有無
わかりました。
ありがとうございます。

やっぱ派生クラス100個あったらswitch文とかで100個 new class CXXX();　とかしないとダメなのかな。
簡単に言うとコンストラクタをオーバーライドしたい。

>>614
分岐の数がそれだけあるならしょうがないと思うよ。
分岐の数よりクラスの数のほうが多いってんなら、何やってんだって話になるし。

そういう場合はnewするだけの関数を複数作ってそれらの関数ポインタのマップなりテーブルを使うほうがいいと思う

ファクトリの出番だ

このコードのsuicideクラスは安全にインスタンスを自殺させるための構造体です。

ttp://codepad.org/GqFZdsol
suicideが返されてから再利用されないようにしたいのですが、これで十分でしょうか？

>>615-617
レスありがとう。コードを書くと↓↓こんな↓↓感じなんだけど、
switch文のとこだけ長大になるのだよねえ。
マクロでもなんでもコードレベルでいいんで無くせないかと。
やっぱ無理かな。

while (1)
{
　　CMode* pMode;

　　switch (next_mode)
　　{
　　case HASEIMODE000:
　　　　pMode = new CMode_Hasei000();
　　　　break;
　　case HASEIMODE001:
　　　　pMode = new CMode_Hasei001();
　　　　break;
　　　・
　　　・
　　　・
　　}
　
　　while (next_mode < 0)
　　{
　　　　next_mode = pMode->Main();
　　}

　　delete pMode;
}

>>619
Boost使えばできそうだな。

例えば、コンストラクタの代わりに、通常の関数で
pMode *allocHasei000() {
　class Hasei000: public Base {
　　...
　};
　return new Hasei000();
}
等をたくさん用意しておく。

そして、HASEIMODExxxとallocHaseixxxの対応を
HASEIMODEが密ならばテーブルで、そうでなければstd::map等で用意しておく。
(実行時の計算量はswitchと変わらなくなるはず)

実際には#defineと ##を使って
#define Elem(n) { HASEI##n, allocHasei##n, }
struct {
　Elem(000),
　Elem(001),
} table;
のようなものを用意する。
(疎ならば、それをmapに登録して保持)

という感じでどうだろう。

あ、structが文法的におかしいな。

まあ、意図は汲んでくれ。

>>619
そのコードだと無限ループじゃね？
つか継承使う必要があるんだろうか

>>620-623
レスどうもです。
例えばミニゲーム集100個のプログラムで、タイトル画面、エラー画面、コンフィグ画面などもあり
入力取得、描画など共通の処理と流れはCModeのMain()でやっているような、派生が凄く活きる
ケースだと思うのだけど。
電源落としたときが終了するとき、というプラットフォームの場合無限ループでよいのです。

仮想関数や消滅部分のスマートさと比較して、結局どこかにずらずらと追加した派生クラスの
newやテーブルなどを書かなければならないクラス生成時のごちゃつき加減の落差。
これをもっとスマートにできないか〜、と思ったのですが、よくよく考えると「因果」というものによって
無理そうな気がしてきました。
(TдT) ｱﾘｶﾞﾄｳございました。

アホすぎ…なんてアホなんだ。

http://codepad.org/6AIfsQCH

これでだめなの？

#define CASES(z,n,text) case HASEIMODE##n:pMode = new CMode_Hasei##n();break;
switch (next_mode) {
BOOST_PP_REPEAT(100,CASES,a)
}

>>624
そういうのはスクリプトとかに自動生成させるといい。
それぞれ異なるクラスである以上、
どこかに選択用コードを書かなきゃならないのは間違いないけど、
なにも人間が書く必要はないでしょ。

誤爆しました

>>619,624
一旦 next_mode を経由して switch する意味がわからん。

pMode->Main() が次の pMode （あるいは pMode を生成する関数）を直接返せば
いいんじゃないか？

int *a;
delete[] a;
は実行時に止まる。
int *a=0;
delete[] a;
は止まらない。
int *a=new int[0];
delete[] a;
も止まらない。
この理由すべてを教えてください。
一番下のやつと上から２番目の奴をを実際のプログラム中で使いたいのですが
使っても安全ですか？
あと、ポインターを使って動的にn次元の配列を作る方法を教えてください。
void *を使ったら配列の添え字がつかえないのでできませんでした。

delete 0は何も起きないことが保証されている。free(0)も然り。
void**

>>632
ちょっとすみませんが意味が分かりません
delete[]の話でdeleteは関係ないんじゃ・・
void**というのも意味が分かりません。

delete及びdelete[]はポインタ先がNULLなら何もしない。
newされた配列の要素数が0であってもそのポインタをdelete[]に渡しても確保した領域を開放してくれる。

n次元の動的配列は任意のa次元目の要素全てがまた同じ要素数の配列を持つなら事前に全次元の大きさを得る事によって
void**ではなくobject*に配列をnewすればできる。ただしoperator []をオーバーロードした糖衣構文を作らなければならない

ありがとうございました。
void**はvoid*型ににvoid*型の &aを代入したのと一緒ですか？
要素数が０のときに領域は何が入ってますか

レスしないつもりだったが回答者が低脳すぎて我慢できん

ポインタ先は NULL じゃねえ、ポインタが NULL の場合だろうが
糖衣構文なんかいらねー、配列へのポインタを使うだけだ
あの程度で糖衣構文とやらが「必要」な奴は先が思いやられる

>>635
前述のとおり、こいつは低脳
void** はでたらめだ、忘れろ

頭の良い人教えてください。
ソースでもいいです。

vector<int>
vector< vector<int> >

次元数も動的だったら...？

サイズ０の配列って詳しい人教えてください。

>>641
長さゼロの配列はそのまま"要素が一つもない配列" として確保されます
もちろんdelete[]も可
詳しくは規格の5.3.4(expr.new)をあたってちょうだい

動的な多次元配列については素直にコンポジットパターンで作ればいいかと

コンパイル時に次元がわかってるならテンプラでおｋ

>>642
ありがとうございます。
素直にコンポジットはクラスを３つも作らないといけないのでオーバーヘッドとかが
気になって使いたくないんです。
型を動的に作れればできるとおもうんですが。そんなことC++ではできませんよね。

■たくさんこのスレを荒らして下さい！■お願いします■迷惑が分からないやつは迷惑を教えればよし■カキコミ放題！■荒らせ！荒らせ！■祭りだ-----！■■■
■■■■■■■■　プライバシーは犯罪！　福島県いわき市・秋山隆浩さん(25)を救え！　　　■■■■■

ヤフオクで車両仕様や走行距離等を偽装した不正出品を指摘した善意の第三者に対して
罵詈雑言を浴びせた上に、暴力団の存在をちらつかせて脅迫するという事件が発生しました。
この事件の首謀者はいまだに検挙されていませんが、福島県いわき市四倉町梅ケ丘在住の秋山通商
秋山隆浩さんが根拠もなく犯人と決め付けられ、卒業文集やアルバムをネット上に晒される被害に遭われています。
秋山隆浩さんの潔白を証明し、いち早く騒ぎの沈静化を図るためにも真犯人の発見にご協力ください。

【プライバシーは犯罪】福島いわき市のDQN秋山通商★71【ボンクラ】　　http://gimpo.2ch.net/test/read.cgi/news2/1252767131/l50
【ボンクラ】三年間の思い出のガイドライン　　http://society6.2ch.net
※※荒らし大歓迎です※※
いつもカキコされてイライラ… コイツは何がしたいのか？
荒らすしかない！

運営に通報しますた

template<typename T>
struct aaa{
　struct in{};
};

template<typename T, typename U>
int operator +(typename aaa<T>::in, U a){ return 0; }　←ここでテンプレート 引数を 'T' に対して減少する方法を教えてくださいませ

aaa<int>::in() + 0;

>>647
日本語でおｋ

Tが判明できないからint operator +(typename aaa<T>::in, U a)がつかえないんでしゅ＞＜

templateのどこら辺りを647が理解してないか感付いた奴は黙して静観スベし

typedefで作った型は途中で別の型に変えたりできませんよね？

コンストラクタ初期化子にthisを渡すのは問題の原因になりうるというのは聞いたことがあるんですが
コンストラクタ初期化子にメンバ変数への参照やポインタを渡すのも問題でしょうか？

class foobar
{
public:
    foobar() : x(0), r(x), p(&x) {}
private:
    int x;
    int &r;
    int *p;
};

初期化する前に参照されるという危険を減らすためだから
初期化が終わるまで参照されないとはっきり分かってるなら別にいいよ

stlのコンテナに対して、値を追加する場合、各コンテナに対して
統一された方法(ジェネリックな)で追加はありませんか？
vectorならpush_back、setならinsertとか、
型ごとに分岐させて追加させるしかないの？

>>654
STLスレ行け、と言いたいところだが…。
Effective STL読めと言っておこう。

>>654
vectorでもinsert使えるでしょ
insertは(bitset以外の)全部のコンテナで使えるはず

>>654
統一するメリットが無い

関数の返り値に&演算子をつけるとどうなるんですか？

int& abc()
みたいな

参照がかえされる

class CHoge
{
int mX;
public:
int &GetX()
{
return mX;
}
{;

CHoge hoge;

hoge.GetX() = 100; // hoge.mXに代入

templateクラスってLIBにするとき、実装をcppに書けないの？

>>660
テンプレート関数の明示的インスタンス生成 - akihiko’s tech note
ttp://d.hatena.ne.jp/aki-yam/20081129/1227982516
これのことを知りたいのかな？

こんな技があるとは

相談させてください。

STLのコンテナ(具体的に言うとlist)の操作に対してUndoを実装したいと考えています。
そこで、STLのUndoに対応したライブラリなどがあるのかお聞きしたいのです。
無ければコマンドパターンなどで自前でやるしかないなと思っています。なにとぞよろしくお願い申し上げます。

そりゃそうだろ
STLコンテナに対する操作はいずれも破壊的セマンティックスなので
原則として元に戻すメソッドは存在しない

自前でやらないと

どなたか>>618見ていただけないでしょうか？
質問文をもう一度書くと
delete thisに相当する処理を行う関数で操作を安全にするためにsuicideクラスを使って
関数を抜けた後にdelete thisのタイミングをずらしているのですが、suicideクラスを返り値として
使っているので、呼び出し側でこのインスタンスの延命やメンバの参照をされないようにしたいと思っています。

そのための実装として上記のsuicideクラスの実装で十分でしょうか？

自作のライブラリなら何かありそうだけどなあ

>>664 >>666

ありがとうございます。自前でやります。

>>665
コードがややこしいうえに、やりたいことが意味不明。

「delete this の後ろにコードを書かない」では何か不満なの？

>>668
そう思ってたんですが、どこかの掲示板で「どうしても心配なら構造体を使って〜」と書いてあったので
使ってみたのですが、心配性過ぎますかね・・・？
関数末尾にthisメンバへのアクセスをするコードが勝手に追加なんて有り得ないとは思うんですが･･･

>>669
「関数末尾にthisメンバへのアクセスをするコードが勝手に追加」されるのが心配だってこと？
・・・かと思ったけど、有り得ないって思ってるのね。わけわからん。以下 >>668

スマートポインタ管理下にあるものをdelete thisするって発想が分からん

>>670
有り得ない・・・とは思いましたが、もしもその関数の中で
struct X{
　　Piyo* p;
　　X(Piyo* p):p(p){}
　　~X(){p->メンバアクセス;}
}x(this);
とかしたら、アウトですよね？まぁ、もっと有り得ない例ではありますけどね・・・
う〜ん、じゃあ普通にdelete thisでやってみようと思います。ありがとうございました。

>>671
自分を参照している最後のスマートポインタを自らの手で破棄したらdelete thisと同じことになりますよね？
Javaのコードに自分への参照をはずさせるようなコードがあったので、それを再現したかったんです。

データ構造が決まっていて、仮想関数が一つ（あるいは少数で互いに独立を保っている）なら継承を使ったポリフモーフィズムより関数ポインタ使ったポリフモーフィズムのほうがよかないですか？
そうすればいちいちnewしなくていいし、処理の切り替えも簡単だと思うんですが

何と何を比べてるのかがわからん。
・クラスおよび派生クラス。
・構造体および関数ポインタおよび複数の関数。
・関数ポインタをメンバに持つ一つのクラスおよび複数の関数。
それぞれ特性は違う。
いずれにせよある状況でどの手法にアドバンテージがあるかは状況によって異なるので自分の思った通りにすればいい。

たとえば迷路を作る場合を考えて

struct maze { virtual void make() = 0; int map[10][10]; };
struct maze_a { void make(); };
struct maze_b { void make(); };
struct maze_c { void make(); };

maze *m = maze_fac.create(n); m->make(); ・・・

とやるぐらいなら

void make_maze_a(int (&map)[10][10]);
void make_maze_b(int (&map)[10][10]);
void make_maze_c(int (&map)[10][10]);

int m[10][10]; (*make_maze_table[n])(m); ・・・

とやったほうがいいんじゃないかな、ということだったんですが
継承をつかって処理を振り分ける方法は多くの書籍やWebページで見かけるんですが
おなじ目的で関数ポインタを扱ってるところってあまり見かけないもので
こういうことはC++ではあまりやらないのかな、と思いまして・・・

言語機能的に不十分な所は別にして

関数は使用者が知っている
継承はobjectは知っている

vectorの要素同士の演算ができるclass作ってくらさい
足し算、引き算、掛け算、割り算など

vec1[n] + vec2[m]

valarrayって知名度低いよね。かわいそう

vector<bool>さん出番やで

>>677
std::transform()使って簡単に作れるじゃん

>>679
禿の新しい本では見捨てられてるしな
たしか巻末に3行くらいしか書かれてなかったような…

代わりにMatrixクラスが紹介されてる
これは禿のサイトでDL可能

>>675
関数ポインタで充分ならそれでいい。

ただもしその例で10x10でない大きさの迷路も混在させて一括で扱いたいときはどうする？
当然どちらの手法でも対応する方法はある。
しかしさらに加えて複数階層を持つ迷路を扱いたいときは･･･さらに･･･

よく設計されたクラスからの派生は既存のコードを変更せずに機能拡張ができるというメリットがある。
でもそもそも拡張はしない、あるいは必要があれば一から書き直す覚悟があるという状況なら
関数ポインタを使うのでももちろんかまわない、そこは自分の判断に従うだけ。

valarrayってSIMD化してくれたりしないのかな

ゲームのキャラクタとか派生クラスで定義してベースのポインタで云々してると
派生クラスが増えすぎてファイルがカオスになってしまうな・・・

たまに10Lのように数値の後ろにLが付いてる
ことがありますが、これなんでしょうか？

long型をあらわす

なるほど。そういう意味でしたか。ありがとう。

日本語を標準入力から読み込みたいのですが一部の文字が文字化けしてしまいます。
たとえば、"日本語"と入れると日本??となります。
きちんと読み取れる場合もあって"教育"と入れると教育と読み取れます。
WindowsでコンパイラはMinGW、入力はUTF-8です。
どのように直せばよいでしょうか。

#include <iostream>
using namespace std;
int main() {
// 日本語を入力すると文字化けする
string japanese;
cout << "input > " << flush;
cin >> japanese;
cout << japanese << endl;
return 0;
}

他人の書いたコードを読んでいてよく分からないので質問します。
if (count & 1)の意味が分かりません。countは0から3の数字が入ります。
0か1が入るのはfalse、trueというのが分かるのですが、2&1、3&1　もtrueということなんですか？
if(count != 0)とは違うのでしょうか。

count とのビット演算だ
1と3の場合に真、それ以外が偽

00・・・0
01・・・1
10・・・2
11・・・3
　最下位ビットが1の場合に真

ようは奇数なら真、偶数なら偽というもの

690です、こんなに早く答えてもらえるとは思っていませんでした。
ありがとうございます。助かりました。

>>689
環境再現してないからわからんけどwstringつかったらだめ？

あるファイルのヘッダ部分にASCIIで書かれた情報を読み込む必要があります。

keyword = value / comment

という形が並んでおり、valueは書式によってdoubleだったりintだったり、
もしくは文字列や複素数だったりします。

File* file = new File::Open("file.xxx");
Header* header = file->GetHeader();
Keyword* keyword->GetKeyword("weight");
double weight = keyword->GetValue();

のような形式で、"weight"を取り出したいと考えています。

=== 質問 ===
Keyword::GetValueの返り値は、doubleだったりintだったりと不定です。
このような場合に、GetValueをどのように実装しておくのが常套手段でしょうか。
valueの型はfloat/double/short/long/bool/std::string/std::complex<double>のみです。
template<typename T> class Keyword;
T <typename T>Keyword::GetValue();
のようにしてしまうのもありなのですが、そうすると
header->GetKeyword("weight")->GetValue()
と書けなくなるので、敬遠しています。

>>689
locale を設定せよ＾＾
そして、本当の意味でUnicodeが使いたいなら
coutではなく、APIを利用せよ。

>>695
boost::variant とか boost::any とか、自作のクラス。

自作のクラスだと、↓こんなのかな。

class Value
{
  bool AsBoolean() const;
  int AsInteger() const;
  std::string AsString() const;
  double AsReal() const;
  std::complex AsComplex() const;
  // ... マジで int と short とか double と float とか区別する必要あるの？
};

header->GetKeyword("weight")->GetValue()->AsReal() って感じ。

>>697
ありがとうございます。
そうすると、値自体はValueのメンバ変数でどう持たせるものですか？
boolもintも持たせておいて、castして全てのメンバ変数に詰めておく？

long/short、double/floatの区別は、
後でデータの統計処理のときに区別する必要があるのと、
ファイルへの再書き込みをするので区別しています。

>>698
値はファイルから読み取ったままの文字列で持っといて、関数呼び出しによって
期待されてる型がわかった時点で読み取り（変換）を試みる。
失敗したら（変換できなかったら）例外投げとけばいいでしょ。

Valueはインターフェイスにして各型ごとにサブクラス定義したら？

>>700
そのインターフェースにはどんな戻り値の関数が宣言されているのかと。

keyword->GetDoubleValue()
keyword->GetStringValue()
keyword->GetBooleanValue()
とかでいいんじゃない

>>697>>702
それって、>>695で挙げられたT <typename T>Keyword::GetValue();を定義するのと同じことのように見える。
こっちもGetValue<int>()とか書けるし。
この案の良し悪しは別として。

値を返すんじゃなく
引数で渡された参照に値を詰めるようにすれば
型名省略できるんじゃね？

#include <iostream>

class Foo
{
union Val
{
short sval;
float fval;

operator short () { std::cout << "short" << std::endl; return sval; }
operator float () { std::cout << "float" << std::endl; return fval; }
};

Val val;

public:
void set(short s) { val.sval = s; }
void set(float f) { val.fval = f; }

Val get() { return val; }
};

int main(void)
{
Foo foo;

short s;
float f;

foo.set((short)100);
s = foo.get();

foo.set((float)200);
f = foo.get();

std::cout << s << std::endl << f << std::endl;

return 0;
}

>>694
wstringにするとcout, cin, getlineなどの関数が使えなくてコンパイルできなくなってしまうみたいです。
>>696
setlocale(LC_CTYPE, "ja_JP.UTF-8");とやってみましたが結果は変わらずでした。

開発はEclipse CDTで行っていてcin入力はEclipseのコンソール（ファイル、コンソールともにutf-8）から行っていたのですがそのせいかもしれません。コマンドプロンプト（cp932）で起動して入力すると>>689のままでもちゃんと日本語が表示されました。

>>697,699,700-706
ありがとうございます。参考になりました。

結局、boost::anyの簡易版を実装し、
std::string m_key;
MyAny m_value;
std::string m_comment;
をメンバ変数に持つclassを作りました。

keyword->GetValue()->AsBool();
などを実装して、取り出すようにしました。
bool/float/dobule/long/std::string/std::complex<double>/std::complex<float>
と型が少ない数に限られているので、
単純にcastできない型同士はAsBoolなどを特殊化して対応。
# 他の型が来たら、std::string("")を詰めるようにKeywordのconstructorで処理。

>>707
Windowsのシステムロケールを英語にしろ

つType Erasure

２Dポリゴンを使った横スクロールゲームを作りたいんだけど、さっきテストしたら
ポリゴンを２５枚くらいしか表示できない・・・。
ポリゴンの頂点と光源の距離から頂点ごとの明暗（RGB三種類）を計算し、
さらに頂点の平均からポリゴン自体の明暗（RGB三種類）を計算・・・
というふうにやっているのですが、無理がありますでしょうか？
最終的にはこれに簡単な奥行き値を与えたり、
ポリゴンにグラデーション（フォンシェーディング？）を与えたいとも思っています。
ちなみにポリゴンの描写はDXライブラリのDRAXTRIANGLEを使っています。

↓ポリゴンの定義
struct PoliPt{
float x;
float y;
double b_r,b_g,b_b;
};

struct Poli{
PoliPt p1;
PoliPt p2;
PoliPt p3;
double b_r,b_g,b_b;
int ori_r,ori_g,ori_b;
int now_r,now_g,now_b;
};

DirectXの質問はDirectXのスレで！

失礼しました

気にしなくていいんだよ＾＾
C++で分からない事があったらまたおいで＾＾

質問です。次のような関数があるとします。
f( char*, char*, int , char*)
一つ目の引数以外は省略可能にしたいのですが
1番目、4番目だけ入力するとかは出来ないんでしょうか。
2、3はデフォルト値を使いたい場合でも、明示的に指定しないと出来ませんか。

できません

f(char *a1, int a4) {
return f(a1, NULL, a4, NULL);
}

そうですか
トンクス
引数は少なめにして対応したいと思います

>>717
省略されやすいところがわかればそういう方法もありますね
ﾄﾝｸｽ

これが分離されないんですが、なぜでしょうか。


char aa[100],bb[100],ch[]="aaaa: bbbbb";
sscanf(ch,"%s: %s",aa,bb);
cout<<aa<<endl;
cout<<bb<<endl;

自己解決はして無いんですが、区切りの位置を探してそこで区切ることにしました。

regexec知ってる？

std::multimapでつくった適当なマップに対して
begin()〜end() までをループさせた場合、得られるイテレータは
かならずキー値昇順でソートされているという保障はあるのでしょうか？

0xで浮動小数型のepsilonをコンパイルタイムに取得する方法はないでしょうか。
template metaprogrammingを使用しているのでマクロでの実現は無理です。

>>723
デフォルトで昇順、比較関数がある場合は
関数の指定する順にソートされていることは保障されてます。

なるほど、ソート済みリストとして使っても問題ないわけですね。
ちなみに、同一のキーに対して複数の値を追加した場合、
hoge.insert(Pair(0, "A"));
hoge.insert(Pair(0, "B"));
hoge.insert(Pair(0, "C"));
それをイテレータで取り出したときには
必ずしも追加した順番で（"A", "B", "C" の順番で）取り出されるとは限らないですよね？

>>726
それは保障されません。

そういう場合はvectorと併用しろ、つうことかな。

fopen()やiostream関連って、
URLに対しても操作を行えますか？
Webサイトからテキストデータ抽出したいんですが

gccに　#pragma comment(lib,"wininet.lib")
と同じ機能のマクロはありますか。

>>729
つ
boost asio

ならファイルとwebが同じに扱えるらしい

Boost.Asioはソケットのレベルだから、729の求めるほど高水準ではないぞ。

wgetをexec()で呼び出しちゃえｗ

exe起動は遅いしメモリ食うよ
実行コードが基本的にメモリに常駐しないし、複数使うと個数分だけメモリ消費する

なんだろうね。wgetはソース公開されてるやつだよね。

string whole( "hello" );
string const& part = whole.substr( 0, 2 );

この const& での受け取りって不正?
string に限った話じゃないんだけど、戻り値の一時オブジェクトの寿命が分からないです。

>>736
参照受け取りなんて初めて知った。
初めて知ったので知らんけど、消える気がするが。

>>736
そいつは特別ルールで参照と同じ寿命になる。大丈夫。

参照で受け取れたんだｗ
俺も初めて知ったｗ

>>738
auto変数の参照渡しは消えるけど。
なんでこっちは駄目なのに出来るんだろう。
関数抜けるとデストラクタが動いたので間違いなし。

>>738
特別扱いとは予想外でした。回答thx.
この特別扱いってのは、関数の戻り値に限らず、一時オブジェクトに対して
const 参照があった場合、その参照が無効になるまで寿命が延びるってことでいいのかな。

> 特別扱い

ヒント：　コピーコンストラクタ

D&E読むべき

boost::shared_ptr はどのような場面で使うべきなのでしょうか？？
どのくらいが使いすぎなのかわからないです。

循環参照しない限り全部SPでもおｋといってもいいと思う

>>744
所有権を共有するときに使う。
所有権を共有するわけでもないときに使うのは無駄。

shared_ptr を作るときに必要な参照カウンタのためのメモリ確保や、
コピーや破棄で必要になる参照カウンタ操作のためのロック・アンロックが
パフォーマンスのボトルネックになるようだと使いすぎ。

循環参照するときはどう書くんですか？
だいたい循環参照のコードを書けない俺は一体ｗ

>>747
つweak_ptr

>>724
std::numeric_limits<double>::epsilon()
じゃだめなの？

>>748
weak_ptrの使い方教えてください。

>>750 http://ja.lmgtfy.com/?q=weak_ptr

vector<int>のように型を引数に持つクラスはどうすればできますか。
<>をオペレータで定義すればいいですか

>>752
templateを使う

msdnライブラリが見やすくなった

サンクス

循環参照って、再帰的な記述がされた変数のこと？
Excel習ってたときに使ったけど、プログラミングじゃ初耳

struct A {
struct A* a;
};

void f() {
struct A a;
a.a = &a;
}

usingディレクティブを使用禁止にする理由ってなんですか？

禁止した人に聞くべきでは？

googleのコーディング規約ってのに書いてあったので・・

Google のアレにはメリット・デメリットが列挙してあったはずなんだけど、何か書いてなかったか？

>>758
ヘッダファイルでの using namespace std ではなくて、
using そのものを全面禁止？

mapのふたつ目の要素でソートしたいんですけど動かないです。


#include<map>
#include <algorithm>

bool cmp(const pair<string, int> &l, const pair<string, int> &r)
{ return l.second > r.second; }

main() {
map<string, int> y;
sort(y.begin(), y.end(), cmp);
}

sortできたら、mapの2分木が故障するから無理ですか。
諦めようと思いました。

>>761
自分が見た限り書いてないです。

>>762
Do not use a using-directive.とだけ書いてあるので、
全面禁止だと思うのですが。

名前空間は使っていいが、usingディレクティブはだめで、
using宣言については書かれていません。
using宣言はOKということでしょうか・・

>>765
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml
ここ見る限り using-directive について "Forbidden -- This pollutes the namespace" とある。
続けて using-declaration について .cc ファイル内または .h ファイル内の関数内なら OK とある。

「googleのコーディング規約」って、違うの見てるのか？

class A{
　class B{
　　class C{
　　　void Get(){
...
のような場合だと、C::Getを実装するのにvoid A::B::C::Get()と長くなってしまうのですが
回避する方法ってないのでしょうか？
名前空間？を使えば回避できるものなのでしょうか？

>>766
あ、ありがとうございます。
ドキュメントの見方がわかっていませんでした・・・
展開すれば解説のってますね・・すみません。

ぶっちゃけ、usingでネームスペース丸ごと展開しちゃうと、
ネームスペースで分けた意味がなくなるよな・・・。
といつも思ってるんだけど、なんでみんなusing使うわけ？

>>767
そのままじゃ無理。
そのクラスのネストが必要なのか、とか見直したほうがいいかもね。

本当は std:: の中が純潔を保っていて、被標準の識別子によって汚染されていないことが大事なんだが

>>769
めんどくさいから

俺グローバル変数使いまくりのクラスライブラリ結構書いたり、
グローバルは使ってないけど、普遍的な変数・クラス名作ってたりしてるんだが、
色々直すの面倒だから、ネームスペースで隔離しておしまいにしてたんだ。
あんまり展開されちゃうと、しらねぇぞ？ってライブラリを過去に大量に作ってる。

こういう人も居るんで、気をつけてねｗ

処女::わたし

>>769
プログラムを読むときに雑音になるから

std::vector<std::complecx<float> > v;
std::find(v.begin(), v.end(), std::complex<float>(0));

より

vector<complex<float> > v;
find(v.begin(), v.end(), complex<float>(0));

の方が自然で読みやすい

ちなみに私は using-directive は関数内で使うことがほとんど

ていうか関数外で使う人なんてそもそもいるの？

>>775
へえー
あんたのような人はうちの会社にはいらんわ

>>775
ちょw

using-directiveはだめで、
using-declarationはなぜOK？
google的に。

>>777-778
vectorもfindも自分で定義してないのにstd::を付ける方が”変”だと思う。
普通、真っ先に思い浮かぶのが標準のものだと思うから。

std::find は
house::key 、 encryption::key や
human::head 、 html::head なんかとは違って
std が理解の助けにならない

mapでイテレータの3番目、4番目、11番目を消したい場合は
11 -> 4 -> 3とすればいいですか。
11を消したことで前方の位置に変化は出ませんか

using namespace std;
は普通に使う

>>779
using directive は後になって意図しない名前の衝突を起こす可能性がある。
using declaration にはその可能性がない。

絶対使うなとは言わないけど
ヘッダに書く奴は最低だと思う

>>782
後ろ消して前の奴の位置が変わるわけないだろ。
どうしてそんなことが心配になったの？

>>784
ああ〜なるほど。
using declarationで統一してれば回避できますね。たぶん。
とりあえず納得。ありがとうございます。

実装やデータ構造の作り方次第では、後ろから順番に接続して、逆さに向けるようなのもあるんで、
後ろ消して前が変わらないとは言い切れない
mapは違うけどな。多分。

後方削除したけど平気みたいでした。

#include<iostream>
#include<map>
#include<vector>
using namespace std;
#define N (1<<18)
typedef unsigned int UIT;

UIT rnd() {
static UIT
t, x=123456789UL,y=362436069UL,z=521288629UL,w=88675123UL;
t=x^(x<<11); x=y; y=z; z=w; return w^=(w>>19)^t^(t>>8); }

int main(){
map<UIT , UIT> x;
map<UIT , UIT>::iterator p;
int n;
cout<< "data作成\n";
for(n=0;n<N;n++) x[rnd()]=rnd();
cout<< "data保存\n";
vector<UIT> y;
for(p=x.begin(); p!=x.end(); p++) y.push_back(p->first);
cout<< "mapの後方削除\n";
p=x.end(); p--;
for(n=0; n<y.size()/2; n++,p--) p=x.erase(p);
cout<< n<<" "<<x.size()<<"\n";
cout<< "比較\n";
for(p=x.begin(),n=0; p!=x.end(); p++,n++)
if(p->first!=y[n]) cout<<n<<"de err\n";
}

でも3　4　11番目を削除するのに後方からやるとか小細工するのが嫌だ。

これは意図どおりだよ

map<K, V> m;
// population
map<K,V>::iterator i3 = m.begin(), i4 = m.begin(), i11 = m.begin();
advance(i3, 2);
advance(i4, 3);
advance(i11, 10);
m.erase(i3);
m.erase(i4);
m.erase(i11);

削除の前後で同一箇所を示すイテレータは変化しないって事か。

イテレータを保存しておくとポインタの4倍要領食うな
これやると、4バイトと16バイトが出てくる。128bitも使う。

int main(){
int *p;
vector<int>::iterator q;
cout<<sizeof(p)<<" "<<sizeof(q);
}

>>793
デバッグ用のチェック機能かなんか使ってるだろ。
release ビルドでも試してみた？

コンパイラ依存みたいね。
vcだと8　bccだと16
ともにリリース版

g++ は 4

VC++ のそれはセキュリティ重視ってことみたい。
http://msdn.microsoft.com/ja-jp/library/aa985965.aspx
#define _SECURE_SCL 0 なら 4 になるんじゃないかな？

>>791
そんなことできたのか。

ノードベースコンテナは要素のeraseしても他のイテレータを無効化しないはず。
順序性も常に保たれる。

class hoge
{
const fuga &operator [] (size_t i)
{
if( i < 10 ) return f[i]; else return fuga();
}
private:
fuga f[10];
};

これって規格上でもセーフなの？

>>799
関数が帰るタイミングでopereetaa []外にfuga()を渡すとopereeetaaaaa []のスタックが破壊されて存在しないconst referenceを返してしまうからだめ。
const referenceで受け取る事のできるテンポラリは破壊されてないスタック内のオブジェクトだけ。

opereetaa
ﾋﾄﾞｲww

wmemcpyとwcscpyって何が違うの？？

>>1
>IDE (VC++など)などの使い方の質問はその開発環境のスレに
>お願いします。

引数の数を数えるところから始めようか

wmemmoveじゃなくてwmemcpyを使う理由って何？

転送先が転送元と重なってないとき

何もほかにコンストラクタ宣言してないのに規定のコンストラクタがないとか言われたんだけど
コンストラクタをオーバーロードする以外に自動生成が行われなくなる事ってあるの？

>>807
メンバにデフォルトコンストラクタで済まないやつがいるとき。

>>808
いちおうメンバクラスは全部デフォルト作ったんですが・・・

じゃぁ基底クラスかな？
いっこずつ外して試してみれば？

あ、解決しますた
const メンバがあるとコンストラクタ定義しないといけないっぽいですねこれ
そのくせコンストラクタ初期化士でconstメンバ初期化しなくても文句は言われないという不思議

>>811
const メンバ持ってるぐらいでデフォルトコンストラクタの自動生成が効かなくなることは
無いはずなんだけど、何か勘違いしてない？

まぁ解決したって言うならいいんだけどさ。

不定のまま変更禁止、という状況ができてしまうほうが話の筋としてはおかしいが

>>813
その点に対する警告かもしれないとは思うが >811 の三行目なわけで

コピーコストって何バイトぐらいから考える？
大体、どれくらいのバイト数を持ってたら単純なメンバ変数に実装する方法じゃなくて、
pimplとか考えればいいのかな
ライブラリ作ってるから、そのクラスが実際にどれくらいコピーされるかどうかは分からない。
std::stringみたいなもので、今のアプリで基盤になるクラスを書いてる。

>>815
pimpl とか使うのはコピーコストを問題にするよりは実装を隠蔽するという目的が先にたつ。
ライブラリ作ってるなら、デフォルトでこっちと考えても問題ない環境が多いと思う。
隠蔽によるオーバーヘッドがボトルネックとして現れるまでヘッダに private メンバ変数を
晒すようなことはおすすめしない。

structって地味にclassより楽じゃない？
public継承するときに
struct fuga {};
struct hoge : fuga {};
みたいに略すとpublicになってくれるのがうれしい

ちゃうねん！pimplの話は今はちゃうねん！w
大体みんなどれくらいのサイズでコストを意識してるか知りたかったねん！

>>815
コピーコストが気になるところでは利用者側でポインタや参照使えばいいんだから、
クラス作成者側の話として意識する意味がわからん。

おまえらすげぇな・・・
そのレベルの処理コストちゃんと考えてやってるんだな。
そりゃ、線形探索はヤバイから、バイナリサーチするとか
そういうオーダーに多大に影響するレベルになるとやるけど、
そんなコピーコストとか細かいレベルの事はやらんわ。

std::vector使うときって
どれが望ましいですか？
std::vector<string>
std::vector<string&>
std::vector<string*>

みんなの話の筋とは
全然関係ないんだけど、面白かった。

　typename は何故必要か
　　ttp://ray.sakura.ne.jp/template/typename.html

そういう理由でこの有名な仕様になっていたのか！。

メンバがint一個しかなくても必要ならpimplにするし、
vector３個あってもpimplにしない(唯のstructにする)こともある。

>>821
二番目は無理。
一番目と三番目は使い道が違う。

継承したクラスはしてないクラスとくらべると遅くなりますか？

仮想継承以外は静的に解決されるから
基底クラスで何もしなければ影響はない。

基底で何もしない意味あるんですか？

型レベルで何かする時に意味がある

何かしてるじゃん
この場合は実行時に何かすると遅くなる、って言う意味だろ

4つの兄弟のような機能が、まんべんなく混ざってるクラスを整理する為、
4つの仮想クラスに分割して実装したら、約15倍ぐらい遅くなったことがあったなあ
まあインライン展開されないなど、作りが悪かったんだが。

もうちょっと分かり安く書いてくださいませんか？
インラインにしても遅いんですか？
私のやりたいのはiteratorを作っていてstlのiterator構造体を継承したら
遅くなるので自分で実装しようか検討中です。

引数をメンバ変数に代入すると同時に、その値を引数にして
また別の関数を呼ぶとき、以下のどちらの書き方にするとか、ガイドラインありますか？
結構迷うんですけど。

CHoge::Func(int arg) {
　m_arg = arg;
　::SomethingToDo(m_arg); // argはあくまでもメンバ変数を初期化するためのパラメータであり、それ以上の利用をしない感じ
}

CHoge::Func(int arg) {
　m_arg = arg;
　::SomethingToDo(arg); // Funcが受けたargをそのまま次に渡すイメージ
}

virtual class X;;
class A : X;
class B : X;
class C : X;

func()
{
A a; B b; C c;
std::vector< X* > v;
v.push_back(&a); v.push_back(&b); v.push_back(&c);
for_each( v.begin() -> v.end() ){ i->func(); }
}

擬似コードで書くけど、べた書きだったのを、
を純粋仮想クラスで↑みたいにしたら、
全然インライン展開されなくて、遅くなったって話。
それだけ。

>>832
前者はm_argとSomethingToDoの間に依存関係が発生するから
パイプライン止まるんじゃねーの知らねーけど

>>832>>834
しかし後者はm_argとFuncをメンバに持つ意味があるのかを問われかねない。

C++で可変長の整数の作り方等が乗っている洋書を教えてください。

洋書の話は洋書スレで！

別に洋書しか載ってなさそうな内容なのでいってみただけで、
和書でもあればよろしい。

http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=18

http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?arnumber=1019854

いつか見たんですけど、

union func
{
　　void (*Func)();
　　ULONG_PTR Address;
};

裏技とか書いてあったサイトがあったので、、、

これって何がどう裏技なんですか？

シングルトンの何がいけないんですか？

代入したときの型と読み出す時の型が違うと未定義動作かなにかでは？

何でそこでタグ名つけてるんだ？

mainやwinmainの前に関数を実行したいのですが
どのような方法がありますか？
今は、グローバルオブジェクトをmain前に作ってそのコンストラクタで無理矢理（？）実行しています。

mainの前ってどういうことだ…

>>846
それであってるよ。たとえばMFCがその方式。
gccには独自拡張がある。

#pragma startup とかかな

#pragmaじゃ環境依存すぎるか

#pragma once

>>825-831 速度は実測が基本

>>832
コメントで書いてる「感じ」とか「イメージ」が、動作を口で説明しようとした場合と近いほうを選べ。

>>841-842
その union 自体は裏技でもなんでもない。

たぶんこうだろうという心当たりはあるけど、おおかた忘れてしまっていい話。

>>843
ほとんどの場合、グローバル変数と同じ問題を持っている。

さらに C++ では、グローバル変数が本当に必要な場合ならシングルトンなどという
面倒な構造を持ち出さなくても簡単にグローバルな変数・関数を宣言できるので、
意義が薄い。

シングルトンは同じクラスのインスタンスを複数作らせないのが目的
グローバル変数を１個に限定しただけ

複数作れても問題がでないようなクラスなら意味無し。

>>832
その設計ならこう書いとくべきだろ

CHoge::SetArg(int arg){
　m_arg = arg;
}

CHoge::Func(){
　::SomethingToDo(m_arg);
}

CHoge::Func(int arg){
　SetArg(arg);
　Func();
}

>>848
これでよかったのですか、ありがとうございます

>>843
使い処を間違っていて単にグローバル変数の代わりとして使われてしまっているところ。
大抵、将来シングルトンでなくなる可能性を考慮していない。
他のデザパタは滅多に口にしないのにシングルトンだけやたら口にしないヤツは信用しないほうがいい。

シングルトン口にしなかったら他のデザインパターンと扱い同じじゃね？

うは、気のきいたこと言おうとしたら言い間違えたww

関数の返り値にconstつけるとどうなるんですか？

struct Hoge { int data; };

const Hoge FooFunc(int data)
{
　　Hoge ret;
　　ret.data = data;
　　return ret;
}

関数から返る値がconst Hoge型になる

値返しに const つけてもほとんど無意味よ＾＾

どういうときにつけるんですか？？

あぁ、Effective　C++によると
FooFunc( x ) = n;
みたいな式を書けなくする効果があるんだったっけか。

operator =がconstメンバだったら意味ないけどね

え、どういうことですか・・・？

代入にconstって何に使うの？

>>865
戻った一時オブジェクトを変更禁止にするときに使う
もちろん、一回別のconstでないオブジェクトに代入したりすれば変更できるようになる
詳しくはEffective C++に書いてある


あと、上のoperator =(T rhs) constのハナシは忘れたほうがいいと思う

　struct X { int x; };

　X f(X i) { return i; }

　int main()
　{
　　X a = {1}, b = {3};

　　f(a) = b; // エラーにならない
　}

ってことね。

>>871

これって
X a = {1}, b = {3};

X __TMP = f(a);
__TMP = b;

a = 1
b = 3
じゃないの？
値は変化すんの？

値はもちろん変化しない。
したがって意図不明の式でありエラーになってくれたほうがよい。
→ 戻り値に const をつける。

なるほど

switch(abc){
case1:classA.func();
case2:classB.func();
case3:classC.func();
}

最近cからc++へ勉強を開始しました。上のソースは、元のcでは関数ポインタになっていた所です。
しかし都合上実行されるfuncがクラスの中に入ってしまいまして
元の関数ポインタに近い形にしようと、classAやclassBのポインタを
ポインタ配列に格納して、そこから各funcを実行させようとしたのですが
どうも調べた範囲では、異なるクラスのポインタ配列は作れないらしく、仕方なくswitch文を使っています。

これをswitchを使わずにスマートに書くにはどのような方法が考えられますか？

classA, classB, classCが継承している一意な基底クラスに重複する機能、インターフェイスを集約する

staticじゃないよね？

struct IFunc
{
　　virtual void func() = 0;
};

>>876
すみません、各クラスのfuncは完全に共通のものではなく
違ったものです。
だから、funcの機能は重複していないと思います

リストにポインタ入れたいんだけど共有ポインタつかうと参照カウンタの分アロケートのコストが増える
共有ポインタより低いコスト、安全、削除の責任をプログラマに要求しない
こんなことってできませんかね？

>>879
#include <iostream>
struct iface { virtual ~iface() {} virtual void mfunc() = 0; };
struct impl1 : public iface { void mfunc() { std::cout << "hello" << std::endl; } };
struct impl2 : public iface { void mfunc() { std::cout << "world" << std::endl; } };
int main(void)
{
iface *p[2];
p[0] = new impl1;
p[1] = new impl2;
p[0]->mfunc();
p[1]->mfunc();
delete p[0];
delete p[1];
return 0;
}

>>879
インターフェイスは同じなんじゃないの？

>>882
返り値と引数は全部同じです

>>881
ちょっと勉強しながら解読しますね
ありがとうございます

>>881
わざわざ仮想デストラクタをつける優しさに泣いた

>>880
直接求められてる答えにはならないけど
boost::ptr_list

嫌な優しさだな

2つのヘッダにBaseとPtrがあります。
Baseはすべてのクラスの基底にしたいのですが、
そのBaseのメンバ関数の中には
Ptrを返すものもあるんですが、循環参照になってコンパイルできません。

だれか循環参照の書き方教えてください・・・

すみません、あげちゃいました・・・

ヘッダじゃなくてヘッダファイルでした。

// Base.h
#pragma once
#include "Ptr.h"
struct Base
{
　　virtual Ptr ToPtr();
};

// Ptr.h
#pragma once
#include "Base.h"
struct Ptr : Object
{
　　/* ... */
};

>>887
ポインタとか参照とか使う。
Base.h
void ToPtr(Ptr& buf);
Base.cpp
void Base::ToPtr(Ptr& buf) {
buf = XXX;
}

>>887
// Base.h
#pragma once
struct Ptr;
struct Base
{
　　virtual Ptr ToPtr();
};

設計の統一のために値コピーがいいんですが、できませんかね？

>>890

定義されていない基本クラスが宣言されています。

できない・・・

定義されてないって Object のことじゃね？
Base だろ？

書き忘れ
>>889は>>890みたいに#include "Ptr.h"を消してstruct Ptr;が必要。

さらに書き忘れ
Base.cppの方で#include "Ptr.h"が必要

できました！
ありがとうございます。

・・・でもPtrを値で返す関数でもエラーが起きませんでした。
Google先生には「Ptrのサイズが分からないため無理」とあったんですが、、、

Ptr ToPtr(); // エラーか？それとも実行時にクラッシュか？？

virtual Ptr ToPtr();

>>896
ちょっと勘違いしてたわ
Baseのメンバ変数にPtrが在るとサイズが分からなくてインスタンス化出来ないけど、
メンバ関数の場合はインスタンス化に関係ないから大丈夫みたいね。

レスありがとうございます。
メンバ変数はPImplで実装するので大丈夫だと思います。

皆は値コピーのコストって何バイトぐらいから考える？

レジスタに入らない大きさから

内部で使う文字コードの種類を変えるにはどうしたらよいですか？

　ttp://codepad.org/6OZuCewZ
このコードで、コンストラクタが走って標準出力に文字が表示されるはずだと思っているのですが
実際は表示されません。
何故でしょうか？

また、このコードはDigital Marsではコンパイルエラーになりますが
VC++, g++, Comeauではコンパイルが通るようです。
どちらが標準C++の挙動としては正しいのでしょうか？

>>903
warning でまくってるけど、コンパイラできるのが正しい。

ClassX xa(ClassA());
ClassX xb(ClassB());
ClassX xd(ClassD());

はすべて関数宣言になっているため、
それでClassXのコンパイラは呼び出されない。
ちなみに、意図どおりに直すと今度は

ClassX xd(ClassD());

がエラーを起こす。

あ、「ClassXのコンパイラ」じゃなくて、「ClassXのコンストラクタ」ね＾＾；

class A{
public:
A(){}
A( const A &rhs ){puts( "cctor" );}
template < class U >
A( U &t ){puts( "template" );}
};

int main(){
A t;
A t2 = t; // template

return 0;
}

これで、template引数を取るコンストラクタじゃなくて、コピーコンストラクタを呼ばせたいんですけど、
どうすりゃいいですか？

>>906
templateの方にexplicitを付ける

>>906
これ、 template 無しでオーバーロード解決できるのになんで template のほうが優先されてんの？
template が考慮されてるのは通常のオーバーロード解決が失敗したあとじゃなかったっけ？

template 版には引数に const ついてない。

>>908
いいえ。オーバーロード解決はtemplateが実体化した後で行われる。

特殊化でいいんじゃね？
と思ったがこれ特殊化できないのね・・・

class A{ 
public: 
A(){} 
A( const A &rhs ){puts( "cctor" );} 
A( A &t ){puts( "template" );} 
}; 

テンプレート引数が解決されて↑こうなるってこと？
じゃあ、const A&とA&どっちが優先されるかの問題になるのか？

>>904-905
ありがとうございました。
おかげさまで
　ttp://codepad.org/mBQsqBcJ
このように解決しました。

ところで、
　ClassX xb(ClassB());
はどんな関数のプロトタイプ宣言だと認識されるのでしょうか？
例えば
　ClassX xb(ClassB);
でしたら
「ClassB型のオブジェクトをコピーで受け取り、ClassX型のオブジェクトを返す関数」
ですよね？

> ClassX xb(ClassB());
ClassB(*)()を引数にとる、解釈されるのでは。

宣言に見えるものはなんでも宣言と解釈する

ポインタじゃなくて参照を引数にするのは記述が楽になる以外になにか利点はあるんですか？

>>913
詳しい説明はEffective STLを読んでもらうとして、
>>915が書いているとおり、C++のルールでは、
関数宣言と解釈できるものは優先的に関数宣言とみなすことになっている。
で、たとえばint f( int n )のような関数宣言があるとして…
関数「宣言」では、パラメータの変数名は省略できるから
int f( int ) って書けるよね？
それとは別に、宣言子（デクレアレータ）は () でくくっても意味が変わらない
というルールがあるので、
関数宣言の()内（パラメータデクレアレーションリスト内）の
宣言子にも()をつけることができ、つまり、
int f( int (n) )とも書ける。
これに対して「パラメータの変数名は省略できる」というルールを適用して、
int f( int() )とも書けてしまうのだ。よって、
ClassX xb(ClassB());
はClassXを返却値とし、ClassB型のオブジェクトを引数とする関数xbの宣言とみなされる。

ちなみに、識別子（スペシファイア）には()をつけられないので
ClassX xb( (ClassB()) );
と書けば、意図どおり、ClassX型のオブジェクトxbの定義となる。

あ、ごめん、急いで書いたらまた間違えたｗ

宣言子→定義子（デクレアレータ）
識別子→指定子（スペシファイア）

でした。ｗ
いずれにせよ、詳細はEffective STLで＾＾

なんで態々カタカナで書くかねえ・・・

char *buff;
buff=(char *)malloc(1024*sizeof(char));

となっている時に
scanf("%s",buff);
と
fgets(buff,1024,stdin);

はどう違うのでしょうか？(苦笑)

ﾃﾞｸﾚｱﾚｰﾀ　→　dekureareitaa
ｽﾍﾟｼﾌｧｲｱ　→　supesifaia
パラメータデクレアレーションリスト　→　parame-ta-dekureare-syonnonmanko

>>920
完っっっっっっっ全にCの話だね

苦笑って
「・・・はどう違うのでしょうか？ククク」って感じ？
うわーむかつくわ。>>920最低やね。

そもそも今時scanfとかfgetsとか使うの？

>>914-915
>>917-918
ありがとうございます。
> ClassX xb(ClassB());
> はClassXを返却値とし、ClassB型のオブジェクトを引数とする
> 関数xbの宣言とみなされる。
しかし
　ttp://codepad.org/gHZsSbtK
これではコンパイルエラーになるようです。
　http://codepad.org/YR7Xa7f8
これならコンパイルが通ります。
（Comeau C++と手元のg++で確認しました。
codepadではwarningが出ていますが
気にしないでください。）
> ClassB(*)()を引数にとる、解釈されるのでは。
そのようです。

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

char* str = new[ 256 ];

std::vector<boost::shared_ptr<char>> strs;

// ここでstrをstrsに代入したい
？？？？


上記の？？？？のところはどのように書けばよいでしょうか？
strs.push_back( str )と書いたらコンパイラに怒られました。
既存の生ポインタをboostのshared_ptrに移すにはどのように書くのでしょうか？

strs.assign( str[0], str[256] );

　ttp://codepad.org/jxflpsyf
この
ClassX xd=d;
のときに呼び出されるコンストラクタは、
テンプレート版なのですね。

　ttp://codepad.org/CLfixUEw
このようにコンストラクタテンプレートが定義されていない場合は
ClassDからClassBへの暗黙の型変換が行われているようで、
その基準が今ひとつわかりません。

引数がきっちり一致しない場合は
暗黙の型変換を用いるより
テンプレートの実体化を行い
それで解決する
と言うことでしょうか？

>>926
なぜ
vector<char>
ではダメなの？

shared_ptr<char>ってｗｗｗ
たかが1バイトにどんだけオーバーヘッドかける気だよ

>>926
あえてやるなら

boost::shared_ptr<char> f(char x) { boost::shared_ptr<char>(new char(x)); }

transform(str, str+256, strs.begin(), f);

こんな感じ？

>>927
>>929
それだと、strを一文字ずつバラして格納することになりますよね？
そうではなくて、確保したstrの先頭ポインタだけをpush_backで追加したいのです。
>>926の記述部は繰り返し呼ばれ、呼ばれる度に文字（の先頭ポインタ）を追加していくことになります。

あと、>>926では例としてnew[ 256 ]と固定値を書きましたが、実際はこの記述部がコールされる度に
変わります。

つまりこう？
vector<char*>

>>933
あ！そうです！
処理を写している本にはそう書いてます。
そのchar*部をスマートポインタ化するのが狙いなんです。

>>931
それをもとに、

strs.push_back( boost::shared_ptr<char>( new char( str ) ) );

としてみましたが、

error C2440: '初期化中' : 'char *' から 'char' に変換できません。

というエラーが出ちゃいました･･･

int f( int() )の場合の()は関数宣言子。
int f( int (*pf)() )をint f( int pf() )と書き、さらにpfを省略した形。

じゃあこうか？
vector<string> strs;
strs.push_back(str);

または

vector<boost::shared_array<char> > strs;
strs.push_back(boost::shared_array<char>(str));

テンプレートはコンパイル時に解決されて特殊化されているので
実行時には

ClassX(const ClassA& ) // テンプレートから
ClassX(const ClassB& )
ClassX(const ClassD& ) // テンプレートから

の三つのコンストラクタが存在することになる。
オーバーロードでは一番適合する関数が呼ばれることになっているので
ClassX xd=d;はClassX(const ClassD& )を呼び出す。

クラスのソース・ヘッダファイルの書き方について質問です。
クラスのメンバに他のヘッダで定義されている構造体とかクラス（例えばFILE）を使う場合は
ヘッダファイルのほうにインクルード文を書いたほうが良いのでしょうか？

>>936
ありがとうございます。

>>938
>実行時
リンク時という文意と解しました。


皆様本当にありがとうございます。

>>939
// YourClass.h
class YourClass {
ClassA func( ClassB );
ClassC *pc;
ClassD d;
};

// YourClass.cpp
ClassA YourClass::func( ClassB ) {
ClassE e;
// その他のコード
}

ClassA,ClassB,ClassCはYourClass.h内で前方宣言。
ClassDはYourClass.h内でインクルード。
ClassEはYourClass.cpp内でインクルード。
これで依存性を最小限にできるはず。

>>937
boost::shared_arrayでできました！

boost::shared_array<char> str( new char[ length ] );

vector<boost::shared_array<char>> strs

strs.push_back( str );


ありがとうございました！( ^∀^)

std::listってstd::vectorみたいなメモリの再配置は起こらないって保障されてる？

>>943
うん。されてる

無名関数の書き方を教えてください♪♪

[]{};

>>944 ありがと

linux windowsで共通して使えるスレッドライブラリありますか。
コードの変更無しで動くやつです。

C++の継承や例外など言語がどの様に実装されているか
ということをかなり詳しく解説した本があったのですが、
名前と著者と出版社をご存知の方いますか？

>>949
Exceptional C++　かな？

>>948
Boost C++は？

ソースコードオンリーで導入が簡単で完成品(更新が頻繁でない)ものはないですか

Hamigaki C++ Libraries

>>952
>更新が頻繁でない
って良い事じゃないんだぞ？