C++相談室 part77

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

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

■基本■
[C++ FAQ]
　http://www.parashift.com/c++-faq-lite/
　http://www.bohyoh.com/CandCPP/FAQ/ (日本語)
　　Cとその仕様を比較しながらの解説なので分かりやすい。
　　***** 質問の前に必ずこの二つに目を通してください *****
[C/C++ リファレンス]
　http://www.cppreference.com/ （英語）
　http://www.cppll.jp/cppreference/ （↑の日本語訳だけど最新は反映していない）
[禿 Stroustrup]
　http://public.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?#jps.JPSH0090D:JPSO0020:/JPS/JPSO0090.jsp=&RKKNP_vJISJISNO=X3014
　　ISO規格の日本語訳。JIS X 3014:2003はISO/IEC 14882:2003 (E)に対応。

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

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/
Exceptional C++ Style
　http://www.amazon.com/exec/obidos/ASIN/0201760428/

■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/

■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/

　codepad
　ttp://codepad.org/

長いソースを貼るときはここへ！

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

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

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

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

#include <stdafx.h>
後死ね。

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

ぬるぽ

template <class F>
class widget;

template <class R, class A>
class widget<R(A)>
{
};

int main(void)
{
widget<void(int)> w1;
widget<int(void)> w2; // err

return 0;
}

w1は大丈夫なのに、w2でコンパイルエラーがでる
原因がさっぱりわからない・・・

>>9
template <class F>
class widget;

template <class R, class A>
class widget<R(A)>
{
};

template <class R>
class widget<R()>
{
};

int main(void)
{
widget<void(int)> w1;
widget<int()> w2; // err

return 0;
}

>>10
boost::function(int())でいつも使ってたからint(void)はできないのかも？っと思ってたんだけど、
念のためにboost::functionで試してみたら、boost::function<int(void)>はあっさり通るのね。boost::functionのソース見れば分るかも。

>>9
> template <class R, class A>
> class widget<R(A)>
これは引数をひとつ取る関数に対する特殊化。
引数を取らない関数について適用されないのは当然と言えば当然。


引数を取らないことを表す引数リスト (void) は括弧も含めた特殊な
構文であって、型が void の引数をひとつ指定すれば有効というわけじゃない。
つまりこんなの↓も実は不正。

typedef void A;
int f(A);

>>12
超分かりやすい

>>12
ありがとう

Lokiライブラリって、具体的にどのような環境で動くか
示されていますか？
Boostよりはやっぱ動きにくいんですか？

template < class Type >
class BaseVec2
{
public:
Type x;
Type y;
//メソッドは省略
}

typedef BaseVec2<double> Vec2f;
typedef BaseVec2<int> Vec2i;

int main()

吸いません間違えて途中で送ってしまいました

template < class Type >
class BaseVec2
{
public:
Type x;
Type y;
//メソッドは省略
}

typedef BaseVec2<double> Vec2f;
typedef BaseVec2<int> Vec2i;

void Func( Vec2f& arg_vec )
{
//省略
}
int main()
{
Vec2f vecf;
Vec2i veci;

vecf = veci;//ここと
Func( veci);//ここが問題
}


vecf = veci;
Func( veci );
この2行がうまくいくような( メンバ変数x,yが勝手に代入される )やり方ってありませんか？

コピーコンストラクタとコピー代入演算子をテンプレートで書く。
例えばこんなの。

template<class U>
BaseVec2(const BaseVec2<U>& src) : x(src.x), y(src.y) {}

template<class U>
BaseVec2& operator=(const BaseVec2<U>& rhs) { x = rhs.x; y = rhs.y; return *this; }

>>18
解決しました
ありがとうございます

>>19
一応注意しておくが、テンプレートコンストラクタやテンプレート代入演算子は
（最終的なシグネチャが同一でも）コピーコンストラクタやコピー代入演算子ではないので、
それらを定義しないと依然としてコンパイラが自動生成する。
単にメンバ全部コピー以外の処理を行いたい場合は気をつける必要がある。
struct A {
B b;
template<typename T> A(const T &t);
template<typename T> A &operator=(const T &t);
// 定義しないと自動生成
// A(const A &a): b(a.b) {}
// A &operator=(const A &a) { b = a.b; return *this; }
};

３５へぇー

>>20
これはEffective C++にも書いてあったと思うが。

C++を使うなら必読本ではあるが
読んで無い奴もいるだろうよ

昔図書室から借りて一回読んだだけなので忘れてた俺ガイル

Effective C++って良いって聞く割にたいして内容なくて読んでがっかりした。
これ読むくらいならExceptional C++でも読むほうがましかなー

>>25
そんな実力上がってから『Effective C++』を批判するのは卑怯では？
その理屈だとさらに実力を上げてから『Exceptional C++』を読んでも
そんなん知ってるよって言うことになるのでは？

クラスを作る時に、全てのメンバ変数に対するGetXXX,SetXXXみたいな関数を
自動的に定義してくれるテンプレートみたいのなかったっけ
思い出せなくて、ぐぐってもうまくぐぐれなくて見つからない

>>27
そんなウンコな機能要らない。
貴様はクラスの実装からインターフェースを書き起こすのか？逆だろ？

weak_ptrってどうやって実装してるんだろう

>>29 boost の実装見れ

でも、答えを見たらなんか負けた気になりませんか？

>>31
じゃあ答えは見ずに、聞けば（>>29）いいのか？ｗ

>>31
デザパタってのがあるだろ。
それと同じで、良い実装を読むことは負けじゃない。

>>29
ぶっちゃけるとweak_ptr用とshared_ptr用に二つ参照カウンタ持ってるだけ。

>>34
ぶっちゃけたwww

class Y : public X { 〜 };
void func(X &x) { 〜 };

X x;
Y y;

X &r = x;
func(r);

X &s = y;
func(s);

↑のfunc(s)をエラーにしたい（派生クラスを受け付けたくない）んですけどそういうことは可能でしょうか？

>>36
Y を直接渡したときならまだしも、 X に変換した後ではコンパイラには区別が付かない。
仮想関数がついてれば typeid で調べることはできる。

そもそもそんなことがしたくなること自体、何か継承というものについて誤解があるんじゃ
ないかと思う。

やっぱ変ですかね？

template <class T> class obj_pool
{
public:
T *Alloc();
void Dealloc(T *p);
private:
list<T *> objs;
};

こんな感じでオブジェクトを使いまわそうかと思ったんですが
どの派生型でもDeallocで格納できてしまうので
取り出すときに区別がつかなくなってしまいます

>>36
「基底クラスに対してできる操作は全て派生クラスに対してもできなければならない」
これが public継承の基本 です。
あなたのケースで言えば
「Xに対して適用できる関数func()はYに対してもできなければならない」
ということになります。
逆にこの public継承の基本 が満たされない場合、それは
YはXの特別な場合ではないということになり、
public継承が不適切な場合ということになります。

>>38
最初に Alloc() で作った奴しか Dealloc() できない、とかそういうルールで使えば
いいんじゃないの？
RAII スタイルのラッパーを用意するとか。

クラステンプレートを使ってのプログラミングをしています。

template<class T> void func(T obj) { obj(10, 20); };
void test(int a, int b) { printf("%d + %d = %d\n", a, b, a + b); }

において、

func<void(int, int)>(test);
func<void(*)(int, int)>(test);

では何がちがうんですか？？

>38
それユーザー側が obj_pool を明示的に使うの？
Factory 関数作って deleter を適正に設定した shared_ptr を返すとか。

>>41
それ、クラステンプレートじゃなくて関数テンプレート。
下の二つは、テンプレート引数が違う。

>>43
すいません。例を挙げるために書いたもので。

>下の二つは、テンプレート引数が違う。
ということは・・・？

>>411
同じだったと思う。
型名の(*)は*を省略可能だから()にできて、
さらに()も省略可能なので。

そうだったんですか！
ありがとうございます。

class Foo {
public:　　
　　Foo();
　　~Foo();
private:
　　static std::vector<int> m_vec;
};

static std::vector<int> m_vec;
この正しい初期化の仕方を教えてください。

>>45
http://codepad.org/C77yrjrC

これの結果を見る感じ省略ではないと思うけど・・・

>41
上は関数型で下は関数へのポインタ型。
至る所で関数型は関数へのポインタ型に調整されてしまうので
func<void(int, int)> も引数の型は関数へのポインタ型になっている。
でも T 自体は関数型のままでオブジェクト型ではないから例えば
T obj2 = obj; みたいなことはできない。
関数へのポインタ型の場合は可能。
http://codepad.org/RIyF5kFS

へー勝手にポインタになってしまうのかなるほど

>>47です
お願いします。

static std::vector<int> m_vec(コンストラクタ引数);

static std::vector<int> m_vec;
memset(&m_vec, 0, sizeof(m_vec));

>>53 やめろやめろ

>>47
std::vector<int> Foo::m_vec;
これでデフォルトの初期化を行う定義ができる。
初期化引数が指定したかったら
std::vector<int> Foo::m_vec(...);

>>47 です、上手くいきません
>>55
static なvectorコンテナなのですが・・・・？

static std::vector<int> m_vec(コンストラクタ引数);
をヘッダに書いてるってオチだな

この記述ってセーフですか？
const hoge& func(const hoge& a)
{
return a;
}

void func2()
{
const hoge& a=func(hoge());
a.func3(); ///ここで、上の行のhoge()一時オブジェクトの参照はセーフ？
}

constならおｋ

>>56
「上手くいきません」じゃわからん。
期待する結果と、そのために何をしたのかと、実際の結果を出せ。

>>58
アウト。
最初の文の終わりで一時オブジェクトは死ぬ。

>>61
むむむ、やっぱりそうですか。ありがとうです

>>49
いいサイトってありませんかね？

>>15お願いします。

>>15 http://ja.lmgtfy.com/?q=C%2B%2B+Loki

>>65
死んでしまえばいいのに

>>65
ワロスｗ

LokiダウンロードしてREADME読めばいいのに…
なんでそんなことも出来ないの？

書いてない書いてない

READMEに書いてないなら
仮に誰かが回答したとしても当てずっぽう以外にはあり得ないということ。

さっき知ってショックを受けたんですが
「char」型ってもう使う意味ないんですかね？
C++的にはchar/unsigned char/signed charは別な型だとは

C++2003 3.9.1 Fundamental types
(C99　6.2.5 Types)

なぜ？
"Hello, World!" は char 型の配列だぜ
signed でも unsigned でもなく

charのsigned/unsignedが実装依存だと
たとえばcharに対する右シフトのコードはバグの元になるから
意識してsigned/unsignedを付けるべきかなって思ったわけです

でも、リテラルがchar型だと使わざるを得ないですね
intとshortは省略するとsignedなのになんでcharだけ特殊なんでしょう
やっぱ過去の遺産？

>63
規格をあたるのが一番だと思う。初見だと厳しいとは思うけど。
使用例なら Boost Function とか Boost Function Types 辺りで見つけられるんじゃないかと思う。
後、C++ Templates The Complete Guide の Chapter 22 がちょっとだけ参考になるかもしれない。

>73
C の char 自体が signed / unsigned 実装依存だったわけだし。
C99 Rationale 見ると signed char, unsigned char の導入自体が C89 時点のもので、
"plain" char の signed / unsigned が実装依存なのは従来の慣行に従い(as in prior practice)
って書いてある。

洋書の良書とかってどっから見つけてくるんだ？

>>73
charを純粋に文字型として使えば問題nothing
1バイト整数として使いたいなら

typedef signed char sbyte;
typedef unsigned char byte;

とか？

構造体は以下のように宣言と同時に初期化できますが、

struct TEST stTest = { 0, 1, 2 };

クラスのメンバ構造体をこのような = { ･･･ }のカタチで初期化することはできないのでしょうか？

全部パブリックだったらできる
それかC++0xを待つか

配列用途の参照を含む構造体にうっかりコンストラクタ書いたりしてerrとか
もう泣けてくる程使いにくいよね

>>78
ありがとうございます。

少し違った質問で、

typedef struct
{
　　int X;
　　int Y;
}
stTEST;

class CTest
{
　　･･･
protected:
　　map<string,stTEST> m_mapTest
};

で、これのm_mapTestの要素の初期化を今はコンストラクタ内で

　　stTEST stTest = { 1, 2 };
　　m_mapTest[ "てすと" ] = stTest;

というふうにしてるんですが、これを一文で簡潔に書くことはできないでしょうか？
たとえば、

　　m_mapTest[ "てすと" ] = { 1, 2 };　// これはエラーになってしまいますが

こんな感じです。

>80
stTEST にコンストラクタを作れば
m_mapTest["てすと"]=stTEST(1,2);
とはできる。
これも C++0x で stTEST{1,2} みたいにできるようになるんだっけ？

＞これも C++0x で stTEST{1,2} みたいにできるようになるんだっけ？
おー、まさにやりたいのがそれです。
それをそのままmapに放り込んでやりたいのですよ。
新C言語は他にもスマートポインタが標準化されたりとうれしいことが多いですね。

構造体にコンストラクタを設けるのは個人的な信条から抵抗があるのですが、
有効とあらば考え方を改めたいですし、検討します。

教えてくださって、ありがとうございました！

template <class T, class A1> T make_pod(const A1 &a1) { T t = { a1 }; return t; }
template <class T, class A1, class A2> T make_pod(const A1 &a1, class A2 &a2) { T t = { a1, a2 }; return t; }
・・・

↑のようなコードを十分な引数数に対応できるように（２０もあれば十分すぎると思う）、スクリプトに吐かせて

func(make_pod<hoge>(a1, a2, a3));

とするとか。コンストラクタを作った場合よりコピーコストが増えるのが気になるけどクライアントコード自体は１行になるよ

vectorにクラス型ポインタを格納して、クラス内メンバ変数の値によってソートしたいんですが、例えば下のように

class Character {
protected:
int AGI;
public:
void SetAGI(int agi){ AGI = agi; }
int GetAGI(){ return AGI; }
bool operator<(const Character &a) const { return (AGI < a.AGI); }
};

bool greater(const Character* &a, const Character* &b) { return *a < *b; }

class Player : public Character {};
class Enemy : public Character {};

int main()
{
vector<Character*> Member;
Player* P[3]; Enemy* E[3];
for(int i=0; i<3; i++){ P[i] = new Player; E[i] = new Enemy; Member.push_back(P[i]); Member.push_back(E[i]); }
P[0]->SetAGI(4); （以下、〜P[2]、E[0]〜E[2]まで適当なAGIの値を入れる)

sort(Member.begin(),Member.end(),::greater);

　　　　　　　（delete処理）
}

をVC++2008でコンパイルしようとしても
「　bool (const Character *&,const Character *&)' : 2 番目の引数を 'Character *' から 'const Character *&' に変換できません。　」
とエラーが出ます……ポインタでのソートすることはやはりできないのでしょうか？

>>83
ありがとうございます。
そういうふうにすることもできるんですね。

すみません自己解決しました

std::stringのc_strの戻り値のスコープはどうなっているんですか？
既存の文字列ポインタを返しているんですか？

用語の使い方が変な気がするが、そのstringオブジェクトのスコープと一緒だろ

>>87
知りたいのはスコープじゃなくて、いつまで有効かでしょ？
元のstd:stringの非constなメンバ関数を呼び出すか、std::stringが破壊されるまで有効です。

>>89
あれ？ いつ変動するかがstringの気分だから、その場その場以外では使わないでね的な事が本に書いてあったけど、非constなメンバ関数を呼び出すってのがそれに当たるのか・・？

　std::string a = "hogehoge";
　char *c = a.c_str();
って感じでそのポインタ後で使おうとしちゃダメ、みたいな。

>>90
俺も
>元のstd:stringの非constなメンバ関数を呼び出すか、std::stringが破壊されるまで有効です。
って聞いているが。
聞いているじゃなくて誰かが規格を開いてくれることを期待

母国語が英語なら英語で書いてくれてもいい

保証がなくなる時期が明らかにされないということは、安心して使える時期が存在しないということだろjk
だったら c_str 自体の存在意義がないわけだが

>>87-93
規格にはこう書いてある↓

21.3.6 basic_string string operations [lib.string.ops]
const charT* c_str() const;
1 Returns: A pointer to the initial element of an array of length size() + 1 whose first size() elements
equal the corresponding elements of the string controlled by *this and whose last element is a
null character specified by charT().
2 Requires: The program shall not alter any of the values stored in the array. Nor shall the program treat the
returned value as a valid pointer value after any subsequent call to a non-const member function of the
class basic_string that designates the same object as this.

>>90
std::string a;
aに対して何かしらの操作が行われなければ内部バッファのメモリ領域も変更されないでしょ。
たとえば非constな操作によって別のメモリ領域に移動する場合はあるけど
constな操作(c_str)のようなものなら別のメモリ空間が再割り当てされる心配もない。

>>95
> aに対して何かしらの操作が行われなければ内部バッファのメモリ領域も変更されないでしょ。
それは希望的観測じゃない？
「何かしらの操作が行われなければ内部バッファのメモリ領域も変更されない」
が規格で保証されていれば良いけど。
例えば
#include <iostream>
int main()
{
double * p =new double(10.5);
*p=3.8;
delete p;
std::cout << *p << std::endl;
return 0;
}
これだって、3.8が表示されるかもしれないけどそうでないこともあるじゃない。
要は動くかどうかじゃなくて規格で本当に大丈夫と保証されているかどうか。



まあ
>>94
が結論を書いてくれているが。

>>96
＞delete p;
何かしらの操作がされていると思うのだが。

何かしらの操作だなどう考えても

>>97-98
うむ。
確かに何かしらの操作だな。
あんま良い例だとは言えなかった。

じゃあstd::stringの内部のバッファが連続しているとは限らないとかがよかったかな？

まあ要するに
> 希望的観測やこんな実装が多いってのではなくその挙動が
> 規格で保証されていれば良いけど。
ってのが言いたいだけだ。

結局規約（>>94）には
c_strの戻り値は非constメンバを呼ぶと無効になる
=非constメンバを呼ぶまでは有効
と書いてるでおｋ？

The return value is valid only as long as the string exists, and as long as only constant functions are called for it.

ifstream fin;
string str;
while ( fin.get(str) ) { stringstream line(str); ... }

をstr無しでやる方法はないですか？

ifstream fin;
stringstream line;
while ( fin.get(line) ) { ... }
みたいな感じで

間違えた
ifstream fin;
string str;
while ( std::getline(fin, str) ) { stringstream line(str); ... }

結局非constな物を呼ばなければ大丈夫なのか。
勉強になったわ。

>>99
＞std::stringの内部のバッファが連続しているとは限らない
えっ？そうなのか？
「内部のバッファが連続しているとは限らない」なら普通にc_str()の呼び出しで一回だけ使うことですら危険じゃないだろうか。

仮にstd::stringのc_str()の実装が（（以下、実際の実装がそうなっているという意味ではないぞ））
「内部的に連続していないかもしれない領域を保持しており、c_str()の呼び出しで再度領域の割り当てを行い、連続したバッファを返却する仕様」だとしても、
「返却された値がいつ無効になるのか分からない仕様」だとすると、前述したように「c_str()の呼び出しで戻り値を一回だけ使うことですら危険」だよな。
つまり、何かしらの無効になるタイミングがあるはずでそれが>>89だろ。
>>93でも言われているわけだが。

まぁ>>94が結論を書いてくれているが。

参照カウンタだったり、文字数によってはヒープじゃなくてスタックつかったり、色々と実装がバラエティーに富んでいるから今は連続してる保証はないよ
c_strはconst引数のレガシーコード直渡し専用だな

>>105
> えっ？そうなのか？
そうなんだよ。

もし連続していることが保証されていたら、
string::iteratorは仕様でchar*に固定されていただろうし、
c_str()なんてメンバ関数も無かったかもね（begin()で済んでしまう）。

>>105
規格と現実大分違うから夢から覚めなさいー

>>105
> > ＞std::stringの内部のバッファが連続しているとは限らない
> えっ？そうなのか？
そうなんだよ。
意外に知らない人（というか決めつけている人）が多いんだよね。

>>107氏の解答が分かりやすいよね。ありがとうございます。


あと俺は
C++0xではstd::stringの内部のバッファの連続が保証されるという
夢を見たのだが、今年こそ正夢になるんだっけ？

今度の規格改訂で連続性は保証されるようになったよ。
そういえばstd::vectorも以前は連続性の保証はなかったよね。

以前っていつだ
規格制定後Defect Report Listが出るまでの間のことか？

とりあえず、内部のバッファが連続しているかいないかに関わらず、>>105はその後の段落がメインなので。

結構前だな

69. Must elements of a vector be contiguous?
Section: 23.2.4 [lib.vector] Status: TC Submitter: Andrew Koenig Date: 29 Jul 1998

http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-defects.html#69

>>112
その後の段落は要するに>>93と>>94の内容だから、>>105宛にレスする所はまったく無くて、
だから>>105特有の箇所にだけレスが付いたんだろう。

もうどうでもいいっすよ！！

>>107
char* でも構わないというだけで、char* でなければならない理由にはならない
begin() の他に data() もあるように、string は冗長性が残っているクラスだ

>>116
だから、皆その話をしてるんでしょ。

>>102-103
getline(fin, line) できるローカルな関数でも作れば？

馬鹿だなｗ

began()

WindowsXP visual c++2008でライブラリ****.aを読み込むかlibに変換する方法ありますか。

そんなことが出来るわけがない
ソースがあればWindows用にコンパイルし直せ
なければ諦めろ
あとスレ違い

intが要素のツリーをtemplateで作って，
全要素をprintfするコードを書いたつもりだったのですが，
どうにもエラーが解決できません．
上手くいく方法はないでしょうか？
↓ソース
http://codepad.org/HfJ9VV39
//エラー gcc 3.4.4
piyohoge.cpp: In static member function `static void IterPrint<Tree<x, children> >::invoke()':
piyohoge.cpp:26: error: type/value mismatch at argument 1 in template parameter list for `template<template<class> class f, class xs> struct Iter'
piyohoge.cpp:26: error: expected a class template, got `IterPrint<Tree<x, children> >'
piyohoge.cpp:26: error: invalid type in declaration before ';' token

>123
そりゃ　template<class>

操作ミスった
そりゃ template<class>　要求されてるところに template<int, class>渡したらエラーにもなるだろ

それ以前の問題が多そう。
#include <stdio.h>
struct Nil{};
template <int x, typename L, typename R> struct Tree { static const int value = x; };
template <typename F, typename T> struct Iter;
template <typename F, typename L, typename R> struct Iter<F, Tree<L,R> > {
static void invoke() { F<Tree<L,R>::x>::invoke(); Iter<F, L>::invoke(); Iter<F, R>::invoke(); } };
template <typename F, typename R> struct Iter<F, Tree<Nil, R> > {
static void invoke() { F<Tree<Nil,R>::x>::invoke(); Iter<F, R>::invoke(); } };
template <typename F, typename L> struct Iter<F, Tree<L, Nil> > {
static void invoke() { F<Tree<L,Nil>::x>::invoke(); Iter<F, R>::invoke(); } };
template <typename F> struct Iter<F, Tree<Nil, Nil> > {
static void invoke() { F<Tree<L,Nil>::x>::invoke();} };
template <int x> struct Print { static void invoke() { printf( "[%d]\n", x ); } };
typedef Tree<0, Tree<1, Tree<2, Nil, Nil>, Nil>, Tree<3, Nil, Nil> > test_tree;
int main() { Iter<Print, test_tree>::invoke(); }

貼るコード間違えた。連投失礼。
#include <stdio.h>
struct Nil{};
template <int x, typename L, typename R> struct Tree { static const int value = x; };
template <typename F, typename T> struct Iter;
template <typename F, int x, typename L, typename R> struct Iter<F, Tree<x, L,R> > {
static void invoke() { F::invoke<Tree<x,L,R>::value>(); Iter<F, L>::invoke(); Iter<F, R>::invoke(); } };
template <typename F, int x, typename R> struct Iter<F, Tree<x, Nil, R> > {
static void invoke() { F::invoke<Tree<x,Nil,R>::value>(); Iter<F, R>::invoke(); } };
template <typename F, int x, typename L> struct Iter<F, Tree<x, L, Nil> > {
static void invoke() { F::invoke<Tree<x,L,Nil>::value>(); Iter<F, L>::invoke(); } };
template <typename F, int x> struct Iter<F, Tree<x, Nil, Nil> > {
static void invoke() { F::invoke<Tree<x,Nil,Nil>::value>();} };
struct Print { template <int x> static void invoke() { printf( "[%d]\n", x ); } };
typedef Tree<0, Tree<1, Tree<2, Nil, Nil>, Nil>, Tree<3, Nil, Nil> > test_tree;
int main() { Iter<Print, test_tree>::invoke(); }

#include <stdio.h>
struct Nil{};
template<int x, typename left, typename right> struct Tree{};
template<typename f, typename t> struct Iter;
template<typename f> struct Iter<f, Nil>{ static void invoke(){} };
template<typename f, int x, typename left, typename right> struct Iter<f, Tree<x,left,right> > {
static void invoke(){
f::template invoke<x>();
Iter<f, left>::invoke();
Iter<f, right>::invoke();
}
};
struct PrintIter {
template<int x>
static void invoke() {
printf( "[%d]\n", x );
}
};
typedef Tree<0, Tree<1, Tree<2, Nil, Nil>, Nil>, Tree<3, Nil, Nil> > test_tree;
int main()
{
Iter<PrintIter,test_tree>::invoke();
}

>>125
template<class tr> struct IterPrintで宣言したものを，
template<int x, class children> struct IterPrint<Tree<x,children> >で特殊化しているのですが，
特殊化したIterPrint内でIterPrintをIterに渡すところで，特殊化した版のIterPrintが
渡されてしまっているので上手くいってないんではと想像しています．
これを特殊化しない版のIterPrintを渡せないのかなと．

>>128
ありがとうございます．
なるほど二分木だときれいに書けるのかー．
何も考えずに子をリストで持とうとしていました．

123とは別人だけどf::templateっていう構文は何物ですか？

関数（継承クラスのコンストラクタから親クラスのコンストラクタ呼び出し）の引数に
boost::shared_ptrを設けているのですが、NULLを引数に渡してその関数をコールすると、
コンパイラに

1 番目の引数を 'int' から 'boost::shared_ptr<T>' に変換できません。

と怒られてしまいます。

親クラスにデフォルトコンストラクタなどを用意しておけば、この引数付きコンストラクタを
呼ばないで済むのですが、
できるだけ統一的に扱いたいのと、その他の場面で同様の問題があるかもしれないことから、
NULLを代入する（無効なポインタにする）方法を知りたいです。

ご助言、よろしくお願いします m(_ _)m

static_cast<T*>(NULL)

boost::shared_ptr<int>()

int→T

>>132
>>133
できました！
ありがとうございました！

>130
>128 じゃないけど。型であることを明示する typename の親戚みたいなもん。
. -> :: の左側が依存型である場合に次に来るのが member template であることを明示する。無いと < が比較演算子として解釈される。
ttp://www.comeaucomputing.com/techtalk/templates/#templateprefix

>>136
どうも。クラスがテンプレート関数を持つ場合に必要なわけですね
関数テンプレートはあまり使わないから知らなかったっす

>>128
tree_dataを変えないなこんな感じに
codepadって初めてつかた
ttp://codepad.org/D8QumP07

codepadかなり便利だよ。
C/C++に限らず別の言語もおｋだし、
plain textをうｐするのにも便利。

vc++限定かな？ってコードを試すときにcodepadつかうわ

>>139
g++使えばいいのに。
というかComeau C++使えば
標準準拠度を確かめるには最適。

template < class T > void F( T t );
という関数があって、
TがX(int)というメンバ関数を持ってたら、そのXを呼び出し、
持っていなかったら、別の処理をする。ってことをtemplateで出来ませんか？

templateで受け取った任意の型の配列と同じサイズの領域を構造体スコープに確保する時は
boostのalignment_storageは使わずに適当にchar buffer[sizeof(T[N])];なんてしていいんでしょうか。
不安なのでchar buffer[sizeof(boost::array<T, N>)];ってしてます＞＜

>>141
boostにそれっぽいのがあった気がする。
「boost has_member」あたりでググってみてくれ。

↓の2つのクラス、PogeまでしなくてもMogeで十分ですよね？

スマートポインタを覚えたので使ってみようかと思ってるんですが
とりあえずPogeみたいにフル？につけたら
変数のアクセスへの構文が大変になってしまいました

typedef list<shared_ptr<wstring> > strlist;
class Poge{
auto_ptr<strlist> m_pslist; //m_pslistは常にPogeが所有
//...
};
class Moge{
strlist m_slist;
//...
};

>>144
そのリストの所有権がオブジェクトの間を移動しないならMogeで十分だろ

さんクスコ

#include <hash_map>
ってやると警告がでるんだけど、古いの？
環境はg++ (Ubuntu 4.3.3-5ubuntu4) 4.3.3

でないよ

/usr/include/c++/4.3/backward/backward_warning.h:33:2:
warning: #warning This file includes at least one deprecated or antiquated header which may be removed without further notice at a future date.
Please use a non-deprecated interface with equivalent functionality instead. For a listing of replacement headers and interfaces, consult the file backward_warning.h.
To disable this warning use -Wno-deprecated.
こんなのが出る

C++でstrlenより高速なstrlenを探してます

アセンブラで書かないと�_

C++でstrlenより高速なstrlenより高速なstrlenを探してます

>>150
x86/x86-64で良ければこれとか。
http://labs.cybozu.co.jp/blog/mitsunari/2008/06/fast_strlen_and_memchr_by_sse2_1.html

初心者なんだけど、条件で
「○○ かつ △△ もしくは □□ かつ ◇◇だったら」なんてのを考えたら

if(○○ && △△ || □□ && ◇◇)

ってなるけどコレってもっとスマートに書けないん？

>>154
例えばどういう風に書けたらスマートだと思うん？

「短く・わかりやすく」かな

>>156
いや、そうじゃなくて、具体的にどう記述できたらスマートだと思うん？

「○○ かつ △△ もしくは □□ かつ ◇◇だったら」
を
if(○○ && △△ || □□ && ◇◇)
以上に「短く・わかりやすく」なんて書けないと思うが。

マクロか関数にしとくぐらいしか

>>154
括弧がないとさっぱりわからん。

横幅の短さを優先して複数行に分けたり、とか？
つーかそんな細かい所の見た目の綺麗さを気にしてたら永遠に先に進めないと思うんだが・・・

hogeはいいけど
moge、pogeの由来ってなに？

modification
physical

通りました

>141
SFINAE 使えば一応実装はできるだろうけど(規格的にも現実的にも)移植性のある方法ではないはず。
関数の signature が一致したところその挙動まで一致する事が保証されるわけじゃないから、
個人的には traits を使うべきじゃないかと思っている。

>142
単純に同一サイズ確保したいだけなら sizeof(T[N}) でも sizeof(T)*N でもいいだろうけど、
その型としてアクセスするんだったらアラインメント考える必要があるんで、char 型の時点で駄目ぽ。

>147
今なら tr1/unordered_map 使うんじゃないの？

traitsの定義ってなんなの？
テンプレートいじってていつもこれはtraitsと言っていいもののかな？って迷うわ

それはネイティブ達にとっても永遠の謎だから日本人に分かるわけがない

メンバ関数のvirtual指定をしたばあいの仮想テーブルの実装って規格で決まってるんでしょうか
あるインターフェースを継承したオブジェクトを動的ライブラリ側で生成して主プログラムで扱うばあいに
主プログラムと動的ライブラリをコンパイルしたコンパイラが別物でも安全なんでしょうか？

決まっていません
安全ではありません
単純な単一継承のクラスで、メンバ関数を普通に呼ぶだけの場合は、
“たまたま” 互換性のある構造になっていて、問題ないことが多いですが、保証されてはいません

そうなんですか・・・残念
packしたPOD構造以上のものは渡さないほうがいいみたいですね

std::string ret1(){return *(new std::string("abc"));}
こんな関数があったときに、受け取り側でちゃんとメモリ解放するにはどうやればよいのですか？
string &r(ret1());
cout << r << endl;
r.~basic_string();
どうやってもメモリリークしてしまいます
string* p=NULL;
*p=ret1();
delete(p);

>>171
不可能

>>171
#include <string>
#include <iostream>
std::string *ret1(){return new std::string("abc");}
std::string ret2(){return std::string("abc");}
int main() {
std::string* p=NULL;
p=ret1();
std::cout << *p << std::endl;
delete(p);

std::string s(ret2());
std::cout << s << std::endl;

p=ret1();
std::string s2(*p);
std::cout << s2 << std::endl;
delete(p);
return 0;
}

1) ポインタで返してポインタを使う
2) 実物を返して代入して使う
3) ポインタを返してコピーコンストラクタへ渡して使う

>>172-173
さっきみたいな書き方はしないことにします
ありがとうございました

パラメーターと処理をカプセル化して同じ型の引数としてほかの関数に渡したいんですが
template+functorだと実行時に動的にできない
仮想関数+functorだとnew/deleteのコストがかかるし、参照だと寿命に融通が利かない
クロージャってC++では再現できませんかね？

>>175 boost::function or std::function (C++0x only)

>>176
それだと結局中の人がtemplateもnewも使ってますけど・・・

>>177
確かに template は使ってるが動的に（引数を束縛）できるし、
以下のプログラムで new が使われていないことも確認した。

#include <cstdio>
#include "boost/function.hpp"
#include "boost/bind.hpp"
#include "boost/version.hpp"
void* operator new (std::size_t s) { throw std::bad_alloc(); }
int main()
{
  boost::function<void (char const*)> print(bind(&std::fputs, _1, stdout));
  print("Using boost "BOOST_LIB_VERSION"\n");
}

$ g++ test.cpp && ./a
Using boost 1_39

>>175
C++ 以外の言語にあるクロージャは new/delete 相当のコストがかからないのかい？

ローカル関数がある言語は実質的にクロージャサポートと誰かが言ってた

int f(){
struct impl{static int g(){return 10;}};
return impl::g();
}

>180
何をどこに囲い込んだんだ？

>>178
Oh...関数ポインタの場合はnewしないんですね知らなかった
bindってどうやって実装してるのか謎ですわ

その辺は知らん

学生の者なのですが、経験者の皆様にお伺いします。

C++プログラムのソースコードの文字コードは
結局何にするのがいいんでしょうか？

開発環境にも依るとは思いますが、
一般論でこれがいいとか
これが無難だとかありますでしょうか？

よろしくお願いします。

「EBCDICは勝利」
「Unicode不許可」
「トライグラフで万全」

OSネイティブの文字コードで。

>>185
どうしてそういう意地悪なことを言うのですか

>>186
やっぱそうなりますか。

　コメントの中以外にASCII文字以外が出て来ないなら
　文字コードは何でもいい。
・・・なんてことにはなりますか？

こりわびっくり・・・あすきぃこぉどが出たようです

>>182
boost::function が new を使うかどうかは、関数ポインタの場合じゃなくて、処理と引数を
記憶するために必要な領域の大きさによって決まる。

>>184,187
環境に合わせて選べ、っていう一般論。

アクセス指定子って英語でなんていうの？

Visual StudioならTCHARにしてプロジェクト設定で切り替え
ってのをよく見るな。
マルチバイト版がなんのために必要なのかよく分からない。
速度の問題？

仮想関数を持っているクラス、または仮想関数を持っているクラスを継承したクラスは
ポインタでの操作やキャストが行われない限り仮想関数テーブルを用いたオーバーライドの動的解決はされず
速度には影響しないと考えていいのでしょうか。

実測あるのみ

オーバーライドの動的解決の速度なんか気にする前に、
きっと他のボトルネックが見つかるはずｗ

>>192
Win95/98/Meで動かす場合のため
もはや過去の遺物

int my::lstrcmp(const char *str1, const char *str2) { return lstrcmpA(str1, str2); }
int my::lstrcmp(const wchar_t *str1, const wchar_t *str2) { return lstrcmpW(str1, str2); }

c++だったら↑のようにラップしたほうが使いやすい

>>193
？ポインタでアクセスするかどうかなんて、
オーバーライドの動的解決に関係ないだろ。

C++の文字列比較が遅いです
何かいい方法ないですか？

仮想関数テーブル参照のオーバーヘッドを気にする書き込み結構多いね

携帯電話なんかでもSymbianがフレームワークとして仮想関数使いまくりだし
パレートの法則にあたるようなボトルネックは大抵別にあるだろうし
C++で開発するレベルの機器で気にしてもしょうがないんだろうがなぁ

map<string, int> hoge;
hoge.insert(make_pair("てすと", 10));

map<int, string> hoge;
hoge.insert(make_pair(10, "てすと"));

VS2008で上のがコンパイルできて、下のが出来ない理由って何なんでしょ？

DIRECT法(DIviding RECTngle)のプログラムを組むことになったのですが、
どうにもとっかかりが無くて困っています。
おおよその理論は分かっているのですが、形にすることが全くできません。
ググって見たりはしたものの、それらしきプログラムソースもみつけることができませんでした。
助けてください。
因みに、C++で組みます。

コンパイルできるけど？

>>198
なぜ？
baseクラスをdrivedが継承している時、drivedインスタンスのアドレスがbase*に入っていれば
そのポインタからbase内のdrivedでオーバーライドされた仮想関数を解決する時にオーバーヘッドが発生するのでは？
逆にポインタや参照からではなくインスタンスを直接叩けば仮想関数テーブルの解決なんてしなくても
drivedインスタンスはdrivedインスタンスでしかないしdrivedを継承した更に別のクラスのインスタンスである可能性もない。

>>201
両方を1つずつ試したけど、エラーは起きなかったよ。
エラーになる要因も見あたらないし。

>>204
英語で検索すればmatlabのソースコードが入ったPDFとか引っかかったよ
そのアルゴリズムは今さっきしったけど暇だったから
コンパイルは通らない超適当な疑似コードを書いた

struct center{
int x,y; //2次元の場合。N次元ならどうデータを持つかはパス
int delta; //探索する幅(毎回1/3になる)
};
struct evector{ int x,y;}; //単位ベクトル
vector<evector> make_evector(int dimension); //次元の数だけ単位ベクトルを生成(略)
//中心と単位ベクトルを与えて次の中心点を計算
int update(center& d,vector<evector>& vx){
double min_value;
double eps=0;
double val=f(center);
for(/*2^(単位ベクトル数)分ループ、2次元なら4方向)*/){
if(min_value>f(center+単位ベクトル)){
min_value=f(center);
//この時のベクトル,仮にvxを保存
}
}
//保存したのベクトルの方向へ中心を移動
center.x+=(1/3)*vx.x;
center.y+=(1/3)*vy.y;
eps=f(center)-val;
return eps;
}
main(){/* 略 */while(0.0001>update(center,vec)){}} //1.0*10^(-4)が経験則らしい

>>206
コンパイル通らないのに動的解決、静的解決の話ができると思ってるの？
何のつもり？

うげ、アンカーミス。>>202宛です
そっちの話とは全然関係ないけど、コンパイル通らないコードを乗せたのは
本人がおおよその理論を分かってるからとおっしゃってるからです

>>202 宿題スレいけよ。

for(/*2^(単位ベクトル数)分ループ、2次元なら4方向)*/)
こりゃコンパイル通らないわな。
でも意図は伝わる。

>203
>205
問題解決しました。<string>インクルードしてなかったw
stirngの小さな謎は残ったけど、質問とは関係ないので問題解決ってことで。

つーかエラー読めよ

>>204
仮想関数呼び出しについては確かにその通りだね。
でも、仮想関数テーブルの生成（オーバーライドの動的解決）
はコンストラクト時に発生するからオーバヘッドはどっちにしろ
「ある」。

プログラミング言語C++第3版を読んでいるんですが、P466の
"多重継承を使えば、プログラム内の共通基底クラスに対する
依存を導入せずに兄弟クラスで情報を共有できる。"がわかりません。
これは何を言っているのでしょうか？

仮想関数のコストはカスみたいなもんだから気にしなくていいよ

C++で書かれたプログラムの中で、
「仮想関数のコストがこのプログラムの最大のボトルネックである！」
と結論づけられるほど洗練しきったプログラムを見たことがないぞ！

みなさんもそう思う・・・よな？

>>216
まあ、forの中に書かなければ、仮想関数のコストは無視できるだろう。

仮想関数のポリモーフィックな呼び出しを繰り返すデザインとしてタスクシステムとかがあるが
あれで仮想関数のコストがボトルネックになっているという話は聞いたことがない
こんな些細なコストを改善するよりいくらでもやることがあるだろう

仮想関数のコストに悩むことがなくなったらC++プログラマ卒業だよ。

> 些細なコストを改善するよりいくらでもやることがあるだろう
うむ。
そこまで突き詰めたら、あとは家に帰るか、
次のプロジェクトにさっさととりかかるべきだ。

質問なんですがテンプレのhttp://www.bohyoh.com/CandCPP/FAQ/のprivateメンバのアクセス性で
そのクラスのメンバと"フレンド"からアクセスできる。と言ってるのにその直後
なお、クラスから派生したクラスメンバと"フレンド"からアクセスできるようにするためには、privateでなくprotectedとしなければなりません
一体フレンドはどうすればいいのかよくわかりません

一時オブジェクト大量生産する方が
すごいインパクトあるよ

>>221
フレンドはprivateとprotectedとpublicにアクセスできるから何もしなくてもいい。

「friendはよく分からないうちは使うな。わかるようになったら使わなくなるけどな」ってうちのじいさんが言ってた

>>221
友達の友達は、友達ではない

素早い返答ありがとうございます
とりあえず今はまだ、フレンドを使うようなプログラムではないので皆さんの意見を
参考に頭の隅に入れておきます

friendは俺はテンプレートクラス関係でよく使う。
Effective C++であったみたいなやつ。

クラス間ではほとんど使わないなぁ。
pimplくらいか？

>>226
あと、お前の言い回しはちょっと失礼にあたるかも。
> 素早い返答
> 皆さんの意見を参考に頭の隅に入れて
この2つは危険だから以後気をつけるように。
どう危険かは自分で考えよう。

friendってcppunitで使わない？

>>229
cppunitを使わないから分からんなぁ。
cppunitって便利なのだろうか。

>>228
改めて見ると確かにえろそうな文章ですね・・・
すいませんでした、今後注意します

たびたびすいません
"えろそう"→"偉そう"です
申し訳ないです

friendは出城みたいな感じで使うことがある。

boost::shared_ptrのdeleterとかには良く使うなぁ。

deleterにどう使うん？

こんな感じ？

class A {
public:
　static boost::shared_ptr<A> create() { return boost::shared_ptr<A>(new A, deleter()); };
private:
　~A() {};
　struct deleter { void operator()(A* value) { delete value; }; };
　friend deleter;
};

>>235 それ friend 要らないでしょ。

class Foo
{
    class Bar
    {
    };

    friend Bar;
};

こういう形はときどき使いたくなる

class Foo
{
    class Bar
    {
        friend Foo;
    };
};

逆だった

>236 何ぃ？？と思ったら修正出てるのね。
ttp://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#45

>>239
ありゃ？今 CD1 ってことは C++2003 だとまだダメな（ friend が要る）のか。ごめん。

>>214
ダイアモンド継承時の仮想継承のことじゃないか？
http://www.geocities.jp/ky_webid/cpp/language/033.html

>>241
そう言われてもう一度読み直してみたら理解できました。
ありがとうございました。

ダイヤモンド継承はパンドラの箱って禿も言ってるしなあ

実際Java/C#/その他のいくつかのオブジェクト指向言語は
多重継承捨ててるしな

多重継承を持ってる言語は他にはEiffelとかSmalltalkとか
そんなのしかないな

Java/C#はインターフェースを使えば似たような事が出来るけど

十年一日

多重継承はなければないで困ったことはないけど
これじゃないと実装が困難っていうようなコードなんてあるの？

>>245
ごくたまーにある
D&Eを読んで見ればわかる

それとデモンストレーションにiostreamにも使われている

Smalltalkには多重継承はないな

>>245
ある。
どっかで見た。
でも使ったことない。

VS2010で
struct B { int m; };
class D1 : public B {};
class D2 : public B {};
class DD : public D1, public D2 {};
void main(){
　DD dd;
　dd.B::m = 1;
}
したら dd.D1::B::m が 1 で、dd.D2::B::m が不定値のままだった。
GCC3.4.3ではあいまいだよって言われてコンパイルできなかった。
GCCの動作が正しいんだよね？

vcのがおかしい

s/GCC3.4.3/GCC4.3.4/

なんだよgccが古いからcodepadで確認しちゃったじゃないかよ

>> 250
だよね

>>252
失礼

>>249
それ既知のバグだよ
M$は直す気がないらしい
なぜならATLをそのバグに依存して書いてしまってあるからだと

>>255
MSってクソだな。

コード1　：　ttp://codepad.org/92VnkX7S
このように、MyStringクラスにはoperator+=を使ってoperator+を実装しています。
ただしoperator+はfriend関数として宣言して使いたいと思います(変えられない前提)。

ところが、よくよく考えると
friend MyString operator+(const MyString& lhs,〜
MyString temp = lhs;
って無駄ですよね？ならいっそ
friend MyString operator+(MyString lhs,〜
lhs += rhs;
の方が効率は上がるのでしょうか？

すなわち
コード2　：　ttp://codepad.org/JAkODbn0
の方が効率はいいのでしょうか？
Effective C++ 日本語 3rd edn 11項のp53には
そう思えるような記述が記述があるのですが、
実際どうなんでしょう？

可読性的にはコード1の方が良いとは思うのですが、
もしコード2の方が効率はいいのでしたらそっちにしようかなぁと。


よろしくお願いします。

>>256
いやいや物は考えよう
MSDNのどっかにバグについて書いてあったと思う
失念してしまったが
バグを正式に認めているんだから、それを避けて書けば
いいだけの話だし

>>256
そうでもないよ。
言語拡張切れば普通にエラー出るはず。
ATLと同時に使う場合も単にコンパイル単位分ければいいだけ。

>>258
認めたバグは許されるのか？
そんな楽な仕事俺もやりたいよ！

そんなんいちいち認めていったら、
独自言語が完成するじゃないか。

>>255,258
えー
でも、そ知らぬ顔して優しくMSにバグレポートしてあげました。

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

>>262
理論の話を言いたいんだろｊｋ

実測は最終手段。

実測厨は無視しろ

>>259
言語拡張オフ(/Zaオプションつける)にしてもかわんなかったYO!

>>263
> 実測は最終手段。
はぁ？
どうせ最後には実測が必要なんだから、最初にやりゃいいんだよ。
それとも、想像で入れた高速化を効果の確認もせずにコミットするつもりなのか？

>>263
> の方が効率は上がるのでしょうか？
...
> もしコード2の方が効率はいいのでしたらそっちにしようかなぁと。

理論なんて聞かれてませんが。

せっかくなんで、バグレポURL張っときます。
ttps://connect.microsoft.com/VisualStudioJapan/feedback/details/529603/
今後のMSの動きにご期待ください！

>>263
>>264
それではコード1とコード2、
どちらが効率いいのでしょうか？

どっちもコピーされてるから一緒だろ

俺バグレポしたことあるけど、英語で「善処します＾＾」ってだけ書かれて
特に対策とか今後の具体的な方針とかなしに終わった。

遅くなりましたが、ありがとうございました！
参考に頑張ってみます。

>>247
>Smalltalkには多重継承はないな

最近はTraitsってのがあるんですよ。デフォで採用しているのはSqueakだけですが。
http://scg.unibe.ch/research/traits

自作アロケータを作っているんですがsizeof(type[array_size])とsizeof(type) * array_sizeは同じになる事が保証されていますか？

>>274 うん。

適当な事言わないでください今規格調べたら保証されてないと出ましたよ

あ、そう。それ何の規格？

>>274
保障されてないよ。
たとえば、こんなときとか！(まぁ質問したいことと関係ない気もするけどｗ)
#include<iostream>
int main(){
    int type[10];
    int array_size=1;
    std::cout << sizeof(type[array_size])  << std::endl;
    std::cout << sizeof(type) * array_size << std::endl;
}

>>278
ありがとうございます！
とても参考になる意見でした！

>>275
消えろカス

>>185
かたよってるなあ

>>275
消えろヴォケ

>>275
愛してる

>>206さんの書いてくれたものを参考にしてみましたが、全体的にうまくいきません。
どなたか助けてもらえませんでしょうか？
このような聞き方は良くないと思いますがどうかよろしくお願いします。

参考URL: (ttp://mikilab.doshisha.ac.jp/dia/research/report/2008/1118/002/report20081118002.html)

実際に上手くいかなかったそのソースコードを出せば誰かが診てくれるかもしれない

shared_ptrのソースコードでこんな箇所があるんですが
このコンストラクタの引数の型って何なんでしょうか
参照の参照？ではないですよね
shared_ptr( shared_ptr && r ): px( r.px ), pn() // never throws
{
pn.swap( r.pn );
r.px = 0;
}

右辺値参照でぐぐると幸せ

>>284
まったくと言っていいほどいじれていませんが…
#include <iostream>
#include <vector.h>
struct center{
double x,y; //2次元の場合。N次元ならどうデータを持つか
int delta; //探索する幅(1/3) };
struct evector{ double vx,vy;};//単位ベクトル
struct vector<evector> make_evector(int dimension);//次元の数だけ単位ベクトルを生成
//中心と単位ベクトルを与えて次の中心点を計算
int update(center& delta,vector<evector>& vx){
double min_value;
double eps=0;
double val=f(center);
for(/*2^(単位ベクトル数)分ループ、2次元なら4方向)*/){
if(min_value>f(center+evector)){
min_value=f(center);
//この時のベクトル,仮にvxを保存
}
}
//保存したのベクトルの方向へ中心を移動
center.x+=(1/3)*vx.x;
center.y+=(1/3)*vy.y;
eps=f(center)-val;
return eps;
}
int main(){/* 保留 * /while(0.0001>update(center,vec)){}} //1.0*10^(-4)が経験則

>>286
なるほど、C++xxで導入される機能なわけですか
右辺値参照と左辺値参照の型が異なるってことは
実用的なクラスを書くために
書かないといけないオーバーロードが増えるってことですね

ある程度C++が使える人はいいけど
新規にC++の世界に入る人のことを思うと
なんかこう、ぞわぞわします

右辺値参照面白いな
これだと一時オブジェクトを作らなければならない場合が減るので
今まで無駄なコピーが必要だったクラスの四則演算などが効率化
されそう

>>287
まさか /*保留*/ とか for(/* 〜 */) なんてのが、そのままで動くと思っていたのか
まずC言語を勉強しよう

さすがにそれはないです。
そこの部分も含めてどうすればよいのか教えて下さると助かります。

(´A`;)

お断りします
　　　ハハ
　　 (ﾟωﾟ)
　　／　　＼
((⊂ )　 ﾉ＼つ))
　　 (＿⌒ヽ
　　 丶　ﾍ |
εﾆ三 ﾉノ Ｊ

せめてこっちへ池
http://pc12.2ch.net/test/read.cgi/tech/1263824755

右辺値参照は効率がいいのは分かるが、最初使い方がちょっと分からんかった

わかりました。

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

>>294
使える場合も結構限られてるしな

ライブラリが高速になるのと、ラムダのため以外に使い道がいまいち思い浮かばないな

visual c2008のデバッグで、vectorの添え字範囲外が
おこった場所特定する方法無い?
エラー箇所がわかるんだけど、STLのソースが出てくる。
その前の自作コードの位置=呼び出し先がわかりたい。
エニー箇所ではなく[]を使ったところ。

vectorの操作している直後に、printfで連番打って
出力みながら確認するっていう方法取っていたんだが
ソースに挟み込む、取り除くのが一苦労
間違って余分消したりすると、余計なエラーも発生する可能性あるし。

#ifdef _DEBUG

printfを組み込んだ状態を常にするって事ですか。
デバッグでもprintfが不要になる場合もあるんです。
速度低下して先に進めなくなるので。
[]の呼び出し元だけ特定できればいいのですが。

>>298
at()に変えてコンパイル
例外が出る

>>301
#ifdef _DEBUG

なんで呼び出し履歴を見ないのだろう……
ということで、ツールの使い方はスレ違いにつきVCスレへどうぞ。

printf は素のままじゃなくて
マクロ経由でつかいましょ

サンクス
呼び出し履歴みてみます

久しぶりにカナ変換使っている人を見た

>エニー箇所ではなく[]を使ったところ。

これか。

o = ら
i(oの隣) = に

ほんとだー

>>299
開発中のソースツリーはそのままでこれをコピーしてそれにprintf()を
組み込んでデバッグするとデバッグコードを取り除くかわりに
コピーを削除するだけでいいよ。

pthreadのIDから、スレッド生存を調べられますか?
webで検索したけど見つからないです。

1　ttp://codepad.org/mFAHo8Y3
2　ttp://codepad.org/8o6YwVQM
これでアセンブラコードを出力させてみましたところ、
どちらも違うコードとなりました。
（VC++, g++, bccで最適化有効にして確認。）

そのアセンブラファイルサイズは
g++, bccでは2のコードが1より小さく
VC++では1のコードが2より小さく
なりました。

意味的には同じだと思うのですが、
どうして違うasmに帰着してしまうのでしょうか？

逆にどうして同じになると思ったのか
最適化なんてそれこそコンパイラの癖や気分が最も出やすい所で
別の組織で別々に開発されたコンパイラの最適化の結果が同じになる方がおかしい

最適化といっても実際のところ 「最適」 になるわけではないからな
最適なコードが得られるまで延々と時間をかけるわけにはいかないので
現実的なコンパイル時間内でなるべくより良いコードを生成するっていうくらいだ

むしろ最適化しなくても、同じになるなんて一切仮定できない
C/C++での表現がどんなアセンブラコードに当たるかなんて解釈次第
googleの翻訳とexciteの翻訳で同じ英文が出てこないと言ってるのと一緒

>>311はよくわかってなさそうだから付け加えておくと
小さいコードが速いコードとは限らないからね

>>312
> 別の組織で別々に開発されたコンパイラの最適化の結果が同じになる方がおかしい
そういう意味ではありません。


>>313-314
そうですか。ありがとうございます。

> そういう意味ではありません。
そういう意味じゃん。

ほっとけよ

頭悪そうじゃんコイツ

「頭が悪そう」ではなく、どこがそう思うに足りるほどの矛盾点を抱えているのか説明していただけませんか？

自分でそれがわかってないところ、かな

他人を頭が悪いと言う人は自分の頭は良いと思っているんでしょうね？

少なくともそいつよりはいいと思ってるでしょう

頭の悪い人はしばしば>>320みたいな馬鹿な切り返しをするね。
言うまでもなく、xが「頭が悪い人」なら自称非xは「自称頭が悪くない人」であり、
そこには頭が良い人だけでなく、この世の大多数を占める凡人も含まれる。
だから確率的にいって、この凡人の立場から言ってるのだろうと考えるのが普通だけど、
頭の悪い人がのぼせると、頭が悪い人と良い人の2種類しか想定しない>>320の切り返しが炸裂する。

自分の頭が良いのか悪いのか、わかっていない人がゴロゴロいますね。

という「自分だけは色々わかってるつもりの第三者」も登場したりします。

自虐ですね、あなた。

結局317が正解だったな

「彼は何も知らないのに、何かを知っていると信じており、これに反して私は、何も知りもしないが、知っているとも思っていない」byアリストテレス

だから引数が結局コピーされて+=されて返却されるという
まったく同じ意味のコードが違うコードを生成するという
単純な驚きじゃないですか？

>>327
微妙にズレた引用がお約束で良い感じです。

クソ、何だこの言葉遊びな流れは。
殺伐とするならもっと殺伐としろよ、できないならいつもの流れに戻れ。
クズ共が。

トラウマをプレゼントしようにも何を指摘されてるのか理解する資質にさえ欠けてる感じ

総じて「理屈っぽい奴」は理屈っぽいだけで論点が全く的を射ていない
だから馬鹿

>>312
バカにも分かりやすく解説しますと
> 1　ttp://codepad.org/mFAHo8Y3
> 2　ttp://codepad.org/8o6YwVQM
> 「どちらも」
->比較対象は2つ
これ以外のところからも比較対象は2つであることがわかる。
> g++, bccでは2のコードが1より小さく
> VC++では1のコードが2より小さく
> なりました。

一方バカな>>312は以下の様な恥ずかしいカンチガイをさらけだしてくれた。
> 別の組織で別々に開発されたコンパイラの最適化の結果が同じになる方がおかしい
そんなこと誰も言ってないのに。
いったい誰に反論しているのだろうか？

どう？分かった？無知な>>312さんｗｗｗ

ヘッダとソースのどちらにも#includeって書くことはダメらしいけど、
ヘッダにだけ#includeって書けばいいの？

>>334
そんなことないよ。
宣言は何回あってもいいんだよ。

何回あってもいくない宣言もあるけど、
ふつうはインクルードガードされてるから大丈夫

>>334
Ｃ言語編　第６０章　インクルードガード
ttp://www.geocities.jp/ky_webid/c/060.html
インクルードガード
ttp://www.02.246.ne.jp/~torutk/cxx/file/includeguard.html
とりあえずこの2つを熟読してみ。
それでもし疑問点が何か残るなら、また聞いてごらん。

・・・あ、もしかしてインクルードガードを理解してないわけじゃないなら
宣言と定義
ttp://www-jlc.kek.jp/~fujiik/C++/declare.html
こっちの方がいいかもね。

>>336
ちなみに
>何回あってもいくない宣言
ってなんですか？

enumとか
typedefはいいんだっけ・・？

>>339
宣言じゃないのでは？

externはどうだっけか？

>>333
＞意味的には同じだと思うのですが、
＞どうして違うasmに帰着してしまうのでしょうか？

こんな馬鹿なこと聞いてたから、「意味的に同じコードは（どんなコンパイラでも）同じasmに帰着する」みたいな
どうしようもない絶望的な勘違いをしてるんじゃないかと思っただけ
そうじゃないならいいよ
別のひどい勘違いはしてたみたいだが

いいよ・・・てwww

　 　　　 　　 　＿＿＿_
　　　　　　 ／ ＼　　／＼　ｷﾘｯ
.　　　　　／　（ー） 　（ー）＼　　　　＜「>>342そうじゃないならいいよ」
　　　　／　　 ⌒（__人__）⌒ ＼
　　　　|　　 　　　|r┬-|　　　　|
　　　　 ＼　　　　 `ー’´　　 ／
　　　　ノ　　　　　　　　　　 　＼
　 ／´　　　　　　　　　　　　 　　ヽ
　|　　　　ｌ　　　　　　　　　　　　　　＼
　ヽ　　　 -一””””~~｀`’ー?､　　　-一”””’ー-､.
　　ヽ ＿＿＿＿(⌒)(⌒)⌒)　)　　(⌒＿(⌒)⌒)⌒))

　　　　 　　　 　＿＿＿_
　　　　　　　 ／_ノ 　ヽ､_＼
　ﾐ　ﾐ　ﾐ　　oﾟ(（●）) (（●）)ﾟo　　　　　　ﾐ　ﾐ　ﾐ　　　＜だっておｗｗｗ
/⌒)⌒)⌒. ::::::⌒（__人__）⌒:::＼　　　/⌒)⌒)⌒)
|　/　/　/　　　　　|r┬-|　　　　|　(⌒)/　/ / /／　
|　:::::::::::(⌒)　　　　|　|　 |　　 ／ 　ゝ　　:::::::::::/　
|　　　　　ノ　　 　　|　|　 |　 　＼　　/　　）　　/
ヽ　　　　/　　　　　`ー’´ 　 　 　ヽ /　　　　／
　|　　　　|　　 l||l　从人 l||l 　　　　 l||l 从人 l||l　　バンバン
　ヽ　　　 -一””””~~｀`’ー?､　　　-一”””’ー-､
　　ヽ ＿＿＿＿(⌒)(⌒)⌒)　)　　(⌒＿(⌒)⌒)⌒))

この板でそんなAA貼るなよ

>>335-337
ありがとうございます

ヘッダーで#includeしてもいいんだけど、
他のヘッダーとの間で名前が衝突してしまうってだけの話でおk?
あと、コンパイル速度が遅くなる程度

俺のことを笑うのは勝手だがスレを荒らすなよ
迷惑だろ

ヘッダの中で使う場合はヘッダで
ソースでしか使わない場合はソースで

>>344
貼らずにいられなかったんでしょ、悔しくて。

>>347
thx

>>345
外してるかもしれないけど、
名前の衝突ってのが「複数回定義されているシンボルが・・」や
「再定義されました」みたいなエラーのことをさすなら
宣言と定義をごっちゃにしてるんだと思う

a.h
#pragma once //あるいはよくある#ifndef A_H_ ...
#include main.h //a.hでmain.hをインクルードした

a.cpp
#include "a.h"

main.h
#pragma once
int global_a;

main.cpp
#include "main.h"


ヘッダファイル(main.h)では宣言ではなく定義がなされているので
main.objとa.objの両方でglobal_aの実態が作られてしまうため
インクルードガードがあってもくエラーになる
定義じゃなくて宣言なら問題ない
たとえばextern int global_a;

もっとシンプルにかけばこう
a.cpp
#include "main.h"

main.cpp
#include "main.h"

main.h
#pragma once
int global_a;

using namespaceの挙動を教えてー

>>348
あんまり可笑しいもんで、嗤っちゃっただけだww

いいなぁその説得力ゼロの
僕はとっても冷静ですポーズ。

>>353
お前消えろカス

>>354
お前も消えろカス

>>354
お前に聞きたい。
お前も可笑しいとは思わないか？


だって>>333はバカがカンチガイしないように2つも
安全ネットを張ってあげてたんだぜ？
そして その2つの安全ネットをぶち破るバカが存在したんだぞ？

お前も可笑しいとは思わないか？

>>333って、文章が下手糞なのと、興奮しすぎて脳内設定先走りすぎなのの2点で、
本人にしか効能のわからない典型的な電波レスになってるよね。

その安全ネットをぶち破ってるのが他ならぬ311の最後の2行だろうよ
あんなの書かれたら質問者は根本的な勘違いをしてると思うもんだ

>>357
何？>357のレスは自己再帰的なの？

各CPPでstaticなクラスを宣言した時、基本的にコンストラクタ呼出順は
制御できないと思いますが、

Test::Test() : Value(1)
{
};

このValue(1)もコンストラクタ呼出順に影響するんでしょうか？
ついでにこれの呼び方を教えてほしいです。

>>358
バカなお前はもう一度同じ事言われたいの？

>>360
コンストラクタ呼び出し順ってなに？
Value(1)みたいなのは初期化リストっていって
そこに書いた順序ではなく
クラスのメンバとして宣言した順序で初期化されることが決まってる

>>360
「staticなクラスを宣言」というのが掴みづらいんだけど、全体から推測するに、
cppファイルの関数外の場所で、static Test test;　みたいにインスタンスを生成する時の話がしたいのかな？

その例のValue(1)は、TestクラスのValueというメンバ変数を初期化している。
呼び方は、とりあえず「メンバ変数の初期化」って呼んでおけば誤解は無いはず。
メンバ変数の初期化は、キミが訊きたい（のであろう）コンストラクタ呼出順の話とは関係ないよ。

いったい俺は何番から何番をあぼんすればいいんだ
>>359
>>361
>>357
>>358
>>356
>>355
>>354
>>353

クソみたいな勘違いしてたくせに偉そうな奴も
そいつにいつまでも構うクソみたいな奴も黙れ

>>365
レスする＝その話題が伸びることを支持し、火に薪をくべる
レスしない＝その話題が伸びないことを支持し、火の勢いに一切手を貸さず鎮火を願う

お前は根本的に分裂している

>>365
そいつらにかまうお前は黙らなくていいのか。
あと、そういうことを書くなら安価しろ

>>361
あんたが天才なことはよくわかったから
今後は自分をバカに見せるような質問の書き方はしないようにしようぜ

>>257から始まり>>368まで、
大人気だなｗ

> クソみたいな勘違いしてたくせに偉そうな奴
> そいつにいつまでも構うクソみたいな奴
これって、どうも複数人vs複数人に見えるのは俺だけだろうか？
両陣営ともなんか一人じゃない用な気がする。

ってどうでもいいレスをしてみるテスト

案外>>257はとっくに居なくなってたりしてな。

ディンの村に幼獣スルーカが現れた

バカは黙って天才の言葉に従えばいいんですよｗ

>>370
言いたいこと言って、テスト付けて精神的に逃げるのはタチ悪いぜ。

なんともカオスなスレ

脊髄反射的にAAを貼っちゃうお子様が居ついたことは確かだわな

>>376
稚拙なレスですね。
これから小学校ですか？

try {
　「釣り針」ブロック
}
catch() {
　「私でも釣れた！」ブロック
}
finally {
　「水中に引き込まれて溺れる」ブロック
}

必ず溺れるのか・・・

finallyなんてないよ

struct A{
B *b_;
SetB(B *b);{b_=b;}
};

struct B{
A a;
B(){ a.SetB( this ); }
};

こういう、コンポジションされる側とする側の依存って一般的？
こういうことしたいってなった時点で設計ミスを疑うべき？

あまり良い設計じゃないと思う
片方必要とされる側は必要とする側に関知しないように作れば
そちら側は再利用できるのに

そういうデザインパターンは普通にあるよ
そういううののタメにweak_ptrとかあるわけだし

> そういうデザインパターンは普通にあるよ

GoFのデザパタで？

weak_ptrがどういうものなのかよく解らん。
とりあえず後で調べるから、悪いけど>>383すまん。

上記みたいな設計になっちゃった場合、
A　<->　C　<->　B
こんな感じで間に第三者を挟めばいいのか?
スレチですまん

Javaでの
Double.isNaN(d)
Double.isInfinite(d)
にあたるものはC++では何でしょうか
#infや#indだと検索しにくくて困ってます

処理系依存しか無いよ

こんなんでどう
bool isNaN(double d) { return d != d; }
bool isInfinite(double d) { return d < DBL_MIN || d > DBL_MAX; }
移植性？
(ﾟ�听)ｼﾗﾈ

移植性考えないんだったらtype_traits作ってビットチェックもしてメタ関数も作れよ無責任だな。

stlの numeric_limits とかに定義されてないかな？

>>386
std::numeric_limitsに定義されています。
21.3 numeric_limit メンバー
ttp://docs.sun.com/source/820-2985/general/21_3.htm
numeric_limits - C++ Reference
ttp://www.cplusplus.com/reference/std/limits/numeric_limits/

んー、ざっと見たけど>>386相当のものはないような
has_infinityは型(doubleとか)が∞を表現として持つかのbool値だし
infinity()
quiet_NaN()
は値としての#INFなどの表現を直接得るものだし

結局処理系依存の
#include <float.h>
_isnan( val )
_finite( val )

gcc
#include <math.h>
int isnan(x);
int isinf(x);

これらを使うしかないんじゃ

<math.h>のisnan, isinfあたりは処理系依存じゃなくて
既にC99で規格化されてるものなんで、
C++0xで正式に入ることことも決まってるし使っちゃっておkじゃね

ほかには、boost/math/special_functions/fpclassify.hppにもisnanとかisfiniteがある。
将来的には、C++0xで定義される見込み。C99ではすでに存在するんだけど……。

>>392
> has_infinityは型(doubleとか)が∞を表現として持つかのbool値だし
これがfalseなら
Double.isNaN(d)
Double.isInfinite(d)
もfalseを返せばいいってことでしょ？
そんでtrueなら
> infinity()
> quiet_NaN()
は値として比較すりゃいいじゃん。
例：
bool isInfinite(double d) : d==std::numeric_limits<double>::infinity()ならtrueを返す。そうでないならfalse。
bool isInfinite(double d) : d!=std::numeric_limits<double>::quiet_NaN()ならtrueを返す。そうでないならfalse。

NaNを値で比較しても常にfalseにならないべか

>>396
色々と間違えた

bool isInfinite(double d) : d==std::numeric_limits<double>::infinity()ならtrueを返す。そうでないならfalse。
bool isNaN(double d) : d!=dならtrueを返す。そうでないならfalse。
でおｋね。

慌ててNaNを調べたのがばればれだな

コンポートネントプログラミング

負の無限大は･･･

>>398
しらねぇわけねえだろバカwww

幼稚園児じゃあるまいし
なあ？>>395よw

NaNがなんなのか調べた。

Noudarake and Nounashi

>>401
バブー？

知らない領分を無理して答えるもんじゃあないな

NaNにおける演算結果の意味を考えると
0/0や±∞/±∞、0・±∞などがある。
これらが“数ではない”ものとして扱われるそもそもの理由とは
離散数学における数という概念が「量ではなく任意の長さの単位の倍数」という
古代ギリシャで起こった極めて初歩的な概念を継承している部分にあり、
上述した演算が定義されない事に因む。
更に物理学の要請から解析学が生まれ、解析学は演算対象の任意の有限区間の非加算濃度を要求した。
これは実数体に他ならない。有理数体の稠密性は実数体の超越表現の結果である。
それを浮動小数点数と言った稠密性のある体へ表現を拡大していったときにまだこれらの量を否定する考えが存在するなどと言う事はあってはならない。

あなたとはnamespaceが違うんです

お前らまた荒らしたいの？
え？
なんなの？

VCつかってるんだけど
stdcallやcdeclに比べてfastcallって呼び出しが速くなるの？

エロい人教えてー＞＜

C++で木構造を扱うのに便利な
知識や方法などを教えてください。

>>410
初歩的なものからならリンクリストは必須。
現代的なものだと多相性とかかな。（boost.variant）

>>409
引数がレジスタを介してサブルーチンに渡されるから速い。

>>411
ありがとうございます。

>>409　レジスタ渡しだから引数2つ以下で効果大って聞いた
流れぶった切りですが質問です。
C++で利用できるSVG形式の読み込み〜描画ができるライブラリを探してるんですが、いいのありますか？

ｍｃ++　2010　販売いつごろ？
ベータ ver. ダウンロード期間中だけど
いつ頃まで　ｃ++が正常に作動するのか？

unsigned int型をint型にキャスト(int)uint、またはその反対って問題ないんでしょうか
対象の変数は0未満にならず、上限もint型の範囲内とします。
もし推奨されないなら良い方法を教えてくれませんか。

>>415
範囲内だと保証できるのなら問題ないよ。

>>416
ありがとうございます！

なんで、privateな変数はポインタだらけなの？

気のせいだ
private以外の変数もポインタだらけだ

関数を書くなら例外安全にしないとダメなんでしょうか。

例えば関数テンプレート
template<class T>
T foo(const T& arg){〜〜}
だと、そのテンプレート引数Tにどんな型をクライアントが入れてくるか定まらな
いため、fooを作る側の私としてもどうにも基本保証すらできません。

よろしくお願いします。

>>420
強い保証が提供できないなら、その旨ドキュメント化しておかないと呼び出し元の
想定しない状態を作って問題を起こす可能性がある。

基本保証すら提供しないのはほとんどバグだと思われても仕方が無いレベル。
この場合は例外を発生させないための条件を事前条件としてしまったほうがマシかもしれない。

スマポ使えばTに関係なく基本保証は簡単にできると思うけど

>>421-422
ありがとうございます。

template<typename T>
class MyTemplateClass
{
　　　　T num;
public :
　　　　MyTemplateClass(T n = 0) : num(n) {}
　　　　MyTemplateClass(const MyTemplateClass& other) : num(other.num) {}
　　　　
　　　　~MyTemplateClass(){};
　　　　
　　　　MyTemplateClass& operator=(const MyTemplateClass& rhs){num=rhs.num;return *this;}
　　　　MyTemplateClass& operator=(const T& rhs){num=rhs;return *this;}
};

例えばこんなクラステンプレートだとしますと、
Tのメンバ関数operator=が例外を投げるような代物であった場合、
MyTemplateClass::operator=(const T& rhs)
MyTemplateClass::operator=(const MyTemplateClass& rhs)
は両方ともこのままでは例外非安全ということでしょうか？

ttp://codepad.org/wp2jk2KS
このコードの結果で、
delete前はnum1〜num6まで全て有効であり、
delete後はnum1とnum4だけが有効で、num2, num3, num6は無効（値を利用したら未定義の動作）である。
という理解で宜しいでしょうか？

codepadではこのようになるようですが、
標準C++準拠な他のコンパイラでも成り立ちますか？


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

>>423
NO。
その場合Tが投げる例外をMyTemplateClassがcatchしたとして
一体どうしろと？

>>425
No.というのはつまり両方ともこのままでは
例外非安全ということでしょうか？

いったいどうすればMyTemplateClass::operator=(〜)で
基本保証ができますでしょうか？

クライアントがしても良い事と悪い事を指定すればいいだけ。

ということは、

ドキュメントに
T型の変数が使っているメンバ関数を列挙し、
これらが例外を投げないとすれば
基本保証or強い保証or例外を投げません。

と書けばよいでしょうか？

クラステンプレートの場合、
T型変数が常識的に考えて投げないだろうって
思う場合(operator=とかswapとか)は別にそこまで冗長に書かなくても
いいのでは？
自分で書いた部分でthrowしなければ
強い保証としていいんじゃないかなぁ。

例外云々の前にYes/Noの論理を理解するべき。

>>430
ttp://blog.livedoor.jp/kazu_fujisawa/archives/51578434.html

さて、"Yes"と"No"と「はい」と「いいえ」の違いを説明します。
「昨日、選挙に行かなかったのですか？」
と言う質問に対して、もしあなたが選挙に行っていなかったら答えは、
「はい、行きませんでした」
となります。
もし行っていたら、
「いいえ、行きましたよ」
が正しい答えです。
日本語の場合は文全体を見て、それが事実と合っているか違うかを見るのです。
ところがこれが英語だと、
"Didn't you go to the election, yesterday?"
と聞かれて、もし選挙に行っていなかったら、
"No, I didn't."
となります。
逆に行っていたら、
"Yes, I did!"
が正しい答えです。
日本語とまったく逆になるのです。

＞　　　　MyTemplateClass& operator=(const T& rhs){num=rhs;return *this;}

コードがこれだけなら T の operator= と
MyTemplateClass の operator= の例外安全性は同じ

＞例外非安全

んな言葉はありません

>>429-431
ありがとうございます。

>>432
> ＞　　　　MyTemplateClass& operator=(const T& rhs){num=rhs;return *this;}
> コードがこれだけなら T の operator= と
> MyTemplateClass の operator= の例外安全性は同じ
Tにクライアントが何を入れるか分からない場合、
ドキュメントになんて書けば良いことになりますか？

>>433
Tの詳細がMyTemplateClassにとって不明なんだから例外について
MyTemplateClassのドキュメントに書く必要がある事などないんだよ。

throw()付けて更にドキュメントに例外投げちゃダメだよ〜んって書いておけば許してくれるよ

そもそも、C++では例外非安全なコードなどバグとか未完成品と考えるべきで

>>436
理想論だな。現実を見ろ

じゃあ聞くけど>>423のMyTemplateClassで
お前ならどうやって例外安全を保証するの？
Tの詳細がMyTemplateClassにとって不明な状況だぞ。

>>437
逆に聞くけど、>>423のMyTemplateClassのどこかに
例外安全じゃないところがありますか？
Tに何を与えるのかはクライアントの問題であって
MyTemplateClassには関係ないこと。

>>434-438
みなさんありがとうございます。

MyTemplateClassをちゃんと（強い保証になるように）コーディングできていれば、
「強い保証です」と書いていいわけですね。

それでTがトンデモ仕様であったらそれはまた別問題ということなんですね。

経験の豊富なみなさんにお伺いしたいのですが、

クラスの 全ての メンバ関数に対し、
「強い保証／基本保証 をします」
とドキュメントに記載していますか？

「強い保証」とか「基本保証」って規格かなんかで定義されている言葉なの？

基本保証はリソースをきっちり管理できてる
強い保証は「成功」か「失敗したけど、完全に失敗前の状態にもどる」のどちらかしか起こらない

>>442
> 基本保証はリソースをきっちり管理できてる
それに加えて、オブジェクト自身が何らかの有効な状態を維持している（どの状態かは問わない）
という条件が必要じゃなかったか？
> 強い保証は「成功」か「失敗したけど、完全に失敗前の状態にもどる」のどちらかしか起こらない
それはその通りだと思う。

>>441
されていない。
でも現在のC++の常識。
例えるならgotoを使いまくっているヤツを排除しただろ？
あれと同じ発想だ。（by Effective C++より）

EffectiveC++第3版を今開いた
2版と全然違うことがかいてあるじゃないか
まだ全然読んでないから読まんといけんな

>>440
特に書かなければ、基本保証が前提だろう。

>>445
そうなんですか。
ありがとうございます。

ttp://takagi.in/modules/bwiki/index.php?%CE%E3%B3%B0%B0%C2%C1%B4

ここには
>>442> 基本保証はリソースをきっちり管理できてる
と書かれているな。
Effective C++とどっちを信用すべきなんだ！？

どちらも盲信すべきではない

規格で決まっていないことについて信用も何もないと思うが

お前らは

　便所の落書き vs Scott Meyers先生

どっちが勝つと思うよ？

・・・って程度だろ。

いざ問題が起きたときに、

「私はネットのブログだかなんだかの定義にのっとりました！」
「私はEffective C++のScott Meyers先生の定義にのっとりました！」

どっちが良いかってことか。
・・・でもバカ上司にはどっちも通用しなさそうだwww

ところでE(ry)C++とかの内容ってC++0xでも通用するのかね

auto_ptr使おうぜ！みたいなのは通用しなくなる

>433
世の中にあるドキュメントを参考にすればいいと思うんだ。
http://www.boost.org/doc/libs/1_42_0/libs/smart_ptr/smart_ptr.htm
だと、Common Requirements に前提を記述した上で、Exception Safety に基本的な挙動を、各関数に例外送出時の挙動が記述してある。
http://www.boost.org/doc/libs/1_42_0/libs/circular_buffer/doc/circular_buffer.html
だと、各関数にT のどの操作の例外が外に飛んでくるかと例外安全性を記述。

後は適当に調べてくれ。

>>440
強い例外保証が提供できていればぶっちゃけドキュメント付けは要らないと思う。
基本保証以下の場合は例外発生時の状態についてドキュメントで触れておくべきだと思う。

>>454-455
ありがとうございます。
勉強させていただきます。

どなたか>>424に愛の手をさしのべてくださる方は
いらっしゃいませんか？

よろしくお願いします。

いいんじゃね？
パッと見constや参照の違いにょる挙動の違いを見ているだけだと思うけど、確認したいポイントは？

>>458
delete後はコピーであるnum1とnum4は有効で、
それ以外は無効だろうと思っているのですが、
num2, num3, num6についてはconst参照で束縛すると挙動が変わったりするのか
という点が疑問でした。

追記：

　vc++
　ttp://uploader.sakura.ne.jp/src/up3481.jpg
　dmc
　ttp://uploader.sakura.ne.jp/src/up3480.jpg
　bcc
　ttp://uploader.sakura.ne.jp/src/up3479.jpg

このようにコンパイラによって結果が違うのですが、
num2, num3, num6については全て未定義の動作
（たまたま同じ値が出力されただけで、
　結果が違うとかそういう問題じゃない）
ということでしょうか？

参照先はdeleteしたんだろ？
はっきり言ってconstだろうとなかろうとnum2, num3, num6を評価した時点でプログラムがハングしても文句は言えないからな。

const参照が束縛できるのはあくまでテンポだよ

>>461
文句を言いたい訳じゃねえんじゃね？

const な参照は一時オブジェクトを束縛する [5.5] [10.4.10]

ってヤツと混同してました。

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

>>460
鼻から悪魔

>>418
>なんで、privateな変数はポインタだらけなの？
逆じゃね？ポインタ変数はprivateにして隠蔽するからじゃないか？

num1の生成にheavy_int_classのコピーコンストラクタが走る。
num1がコピーされたインスタンス。

num2の生成にコピーは発生しない。
num2とp->numは同じインスタンス。同じ型。

num3の生成にコピーは発生しない。
num3とcp->numは同じインスタンス。
前者はconst修飾されていて変更不可、
cpはpointeeがconst修飾されているのでcpから得られるメンバは総じて変更不可。

num4はnum1と同じくコピー。
通常、コピーコンストラクタはconst referenceの仮引数であるので挙動に変化なし。

num5はnum3の理由によりコンパイルエラー。
参照は定義時に使われたインスタンスを指すオブジェクト。

num6はcp->numと同じインスタンス。但し変更されない事を宣言時に明示している。
よって型検査の上では正常。


いずれにせよ、参照は単にポインタの糖衣構文に過ぎずプログラマーが参照は図示を明記しなくても良いというだけ。
cons参照が特殊なのは壊れてないスタックにあるインスタンスをコピーコストなしで見られる点。

説明不足だったが、組み込み方やPODに関してはコピーコンストラクタがない。
単純にメモリがコピーされるだけの処理に置き換わる。
最適化によってはコピーが発生せず、変数宣言が消失したり関数がinlineされたりなどする。
この挙動の違いは非PODな型を使う時に最適化を考えて書く時に重要なものになる。

>462
逆じゃないの？ テンポラリオブジェクトを束縛するにはconst参照でなくてはいけないけど、
const参照がテンポラリオブジェクトしか束縛できないというわけじゃないと思うけど。
仮変数とかでバリバリ使ってるし。

>>467 参照にはヌルポインタのような状態がないことも重要だよ。

>>468
それはコンパイラの実装に踏み込んだ余計な知識だろう。
一般的に言えるものじゃないので、そのレベルの最適化を考えるんなら自分の環境で
アセンブリリスト吐かせて確認するべき。

C++ってC言語よりもポインタが排除されている気がする

気がするも何も、まったくもってそのとおりなのです。

>>471
副作用のない部分をよりコストの低い処理へと置き換える、という事は一般的だとは思うけど。

>>474
うんうん。最適化って言うのはそういうものだね。

で？

ポインタが排除されているというより、ポインタにまつわる危険性が
排除されているというべきだろう

C++で多態性(ポリモルフィズム)をするにはポインタを介するしか
ないわけだし

あ、正確には参照でもポリモルフィズムは出来るけど実際には
静的に近い解決がされちゃうし

参照

> ポインタにまつわる危険性

これがネックになる人は PG どころか一般事務もダメだろ
顧客コードだの ID の類が管理できないわけで
自立した成人としての基礎的な能力に問題がある

必要ないところでもポインタを使いまくるオレ様スゲー、ということにしたいのですね。わかりますん。

>>467-471
ご丁寧に解説いただき、理解が進みました。
どうもありがとうございます。

パラメータがポインタの関数に、&で変数のアドレスを渡すとどうなるのですか？
void test(hoge* h)に対して、test(&h);みたいな感じに
そのあとに、GUIのイベントループにさせたりするとして

>>482
どうなるもこうなるも、普通で問題ないと思うのですが、どういう回答をお望みですか？

エスパーしてみる。

>>482はポインタとアドレスを別物だと思っているんじゃないか？

いやある意味別物だけど。

・・・さすがにそういう意味じゃないかな。

スコープ的にどうなのかな〜と
いまいち、そこら辺がわからない

>>485
スコープが分からんとは。
自動変数とかそう言う話っぽいな。

誰か説明してやってくれ

>>486
普通の変数や、newした変数の寿命はわかるのですが
普通の変数のアドレスを外部の関数に渡した場合と、
変数を使った場合がよくわからないんです

自分で調べたい所ですが、イマイチ方法がわからずorz

初心者スレへ

C++ていうか、C言語のポインタが分かってない感じだな。
適当にググってポインタについて勉強すれ。

たしかに、C言語初心者スレへ誘導するのが吉か。

C言語なら俺に聞け（入門編）Part 60
ttp://pc12.2ch.net/test/read.cgi/tech/1264920499/

ここがいいんじゃない？

普通の変数ってなんだよｗ
普通じゃない変数があるのか？

（１）普通の変数のアドレスを外部の関数に渡した場合。
（２）変数を使った場合。

どういう状況を言っているのか全くわからん。
ひどすぎる。

変数を使った場合
って何事w

今までC/C++で変数を使わないでプログラミングしたことねぇよ。

>487
スタックフレーム、駆動レコード、継続あたりの話ね。


「外部の関数」と考えると確かに判りづらいな。
まずは「呼び出し元の関数」と「呼び出し先の関数」というのを想像して、それぞれの
動きを見てみると良いかも。

C++の場合「呼び出し先の関数」が終わらないと「呼び出し元の関数」も終わらないから、
「呼び出し元の関数」にある変数も「呼び出し先の関数」が終わるまでは無くならない。
なので、変数の（スタックに積んである）ポインタを実変数として渡しても問題になることはないんだよね。

>>494
やさしいなぁお前は。見習わなきゃ。

>>494
わざわざ、丁寧な返答ありがとうございました
Qtとかのフレームワークでプログラミングをしたいなと思っていたので、
中身がブラックボックス化されていて頭がゴチャゴチャしていましたorz

えぇ〜と、周りに迷惑なのでこの話はここら辺で止めておきます

>>496
> Qtとかのフレームワークでプログラミングをしたいなと思っていたので、
> 中身がブラックボックス化されていて頭がゴチャゴチャしていましたorz
Qt！？
悪いことは言わん。やめとけ。
いくらブラックボックスとはいえそのレベルじゃ使えないでしょ。
その前に猫のサイト等ででもC言語の勉強をすべきでは？

>>497
えぇ、もちろん使えませんよ
いろいろと忙しくて、1ヶ月くらいしかC++の勉強をしてませんからね
1〜2年程度の長いサイクルで考えてるんで

C++でデータとしての数値のみを持つ構造体
(struct Point { int X; int Y };とか)
をコピーするとき、一番早い方法ってなんですかね？

素直に=でコピーがいいんですか？

実測が基本

41秒で反応する実測厨の気持ち悪さ

その処理に関しては、コンパイラが十分に賢いので=で良い。

それってコピコンは書く必要は無いっていうこと？

うん。コピー代入演算子も書かなくていい

ポインタで文字列の何文字目から何文字文だけわたすってことはできますか？

ポインタ１つでは無理

>>505
STL流儀のbegin(),end()がまさにそれだろ。
iteratorはポインタの抽象だよ。

>>497
CとC++は別物。焼きそばとカップ焼きそばくらい違う。

お寿司とカリフォルニア巻くらい違う。

どれも底辺が喜んで食う物ってのがまたｗ

カテゴリは同じだけどグレードが違うってことでしょ

最近はこのスレ荒れるなぁ。

ちょっとはみんな自重しようぜ。

そこはグレードは同じだけど、カテゴリが違うってしておかないと

C++ソースで、
文字コードUTF-8 + 改行コードLF
で統一しているのですが、
BOMってヤツは付けた方が良いのでしょうか？
よろしくお願いします。

すみません他スレ行ってきます。

コンストラクタに初期化並び？を書くと何か最適化されるの？
abc() : member(0) {}

そこに初期化子を書かないと初期化できないじゃないか。

最適化関連はアセンブラコード見て確認してみ？

>>516
そこにかかずしていつ初期化するのだい？

案外utf-8が扱えなかったりするやつがいることも考えると

C++なら文字コードは全部
"Shift JIS" + "CR+LF"
で統一するのがオススメ。（正確にはCP932か。）
現実的にこれなら扱えないコンパイラやOSはまず無い。
（M$様が圧倒的なシェアを持っている都合上
　対応せざるを得ないんだろうな。）

日本語とか完全無しってのが理想だろうけどさ。

ってのが俺の持論なんだが。
賛成意見・反論など大募集。

hoge() { member = 0; }

コンストラクタの中に書く俺は異常なのか・・・？

>>521
異常というか、C++の初期化子の意味を理解してください。

・・・Effective C++すら読んでないでしょ。

>>521
それ初期化やない、代入や。

俺はメンバの数が圧倒的にふえるとそう書くな

>>521

節子、それ、初期化やない、代入や！

って言おうと思ったら既に言われてしまった。

>>524
お前もかよwこのスレは・・・。
Effective C++ぐらい読めよ。そして従えよ。

つ constメンバ変数

引数なしの場合って書く？

constメンバをstaticじゃなく宣言する意味ってなんかあんのか

引数なしだと組み込み型はそれを明示しないと初期化されないので、初期化したい場合は書く。
どうでもいい場合は書かない。

>>528
何の引数が無い場合？メンバ変数（クラス）ならそいつらのデフォルトコンストラクタで初期化しとけば良いじゃん。

>>529
初期化のタイミングで値が決まるが、クラス内部で変更するつもりがない変数に有効。

class Hoge
{
　　Test a;
public:
　　Hoge() {} // aはデフォルトでおｋ
};

別にこれなら初期化子はいらないよな

>>530
組み込み型のメンバーは、boost::initialized_value<double> jissuu;にするから所期化忘れは無い。

そういや空のコンストラクタはどう最適化されるんだ？
教えてくれ

>>535 知るか。アセンブリ吐かせて見ろ。

アセンブラコード見なさいよ

C++をやっててboostに触ってないってのはモグリですか

>>521
C#やってた人がやらかすな。

>>538
はい。
それとVCしか使えない人もモグリです。

>>538
メモリーリーク？なにそれ？おいしいの？
なんだSTLって使い物になるんじゃん。
MPLすげー。ソースコードが半分になるじゃん。

C++の世界が全く変わるよ。良い意味で。

>>538
さすがにねぇ。。

>>541
> メモリーリーク？なにそれ？おいしいの？
いいすぎだろw
メモリーリークを知っているからこそ
役立つんだろ？

boostいらねよ。
使えるのはメモリー管理だけだろ。
それ以外たいして入らない。
メモリも他のライブラリで代替えすれば完全に入らない。

>>543
いるか要らないかねぇだろ
本題を読めよw

>>543
最初の行が矛盾してるぜ。

欲しいところだけ使いたいのに、全部入れるとでかすぎるって話なら同意。

* typedef struct hogehoge..., (struct fuga*)malloc(sizeof(struct fuga))...
　C++は初めてか？肩の力抜けよ。

* catch(...){ throw; }
　落ち着け

* カスタムアロケータを自作したり等、STLをやっと使いこなせるレベル
　頑張って＾＾；

* shared_ptrやMPL等でboostを導入しまくる
　そうだよね保守性は重要だよね

* boostのソースから必要な部分だけもってきて改変
　本当に分かってやってるのか？という懸念

asmみたけど空のコンストラクタも呼び出されてる。

>>499
試したけど、コンパイラ定義の代入はmovで初期化されているな。

>>516
これはよくわからんかった。

初期化並びに書かなければ
その(コンパイラが自動的に生成した)空のコンストラクタが呼ばれた後に
再度代入が行われて二度手間になる

boostは中身を理解して使うならいいよ
理解せずに使うやつは潜り

そうかー…
SymbianでC++をやってた自分としてはboostは若干異世界なんだよね

initialization listの日本語訳が初期化並びか
JIS X3014でもこんな気持ち悪い訳語使ってんのかな？

>>550
そういう事情があるなら別だよ！
ただ一般論として
boostが通らない環境でない限りは
見といた方がいいんじゃね？

>>547
どんな環境で何をどう試したの？

すごいスレの伸びだな

JISには海外から取り入れる際に翻訳規定がいろいろ定められてる。
文法上の意味と用語の立場からその規定が当てはめられる。
規定を定めた大元は天下りのアレが大きな役割を果たしていたので、
翻訳の仕事をした人を責めるわけにもいかないだろうに。

VS2010b2 win32コンソールアプリ debugで試した。

デバッグモードじゃ最適化されないよ！

そ・・・そうだった・・・

いや、設定したオプションにもよるだろｊｋ

>551
>JIS X3014でもこんな気持ち悪い訳語使ってんのかな？
以前 C++ 関連記事を翻訳しようとした時に、JIS X 3014 の訳語を基準にしようかと
思ったけど、あまりにも現実との乖離が大きいので一般的なプログラマにとって
理解不能とまでは言わないけど脳内再翻訳が必要だと思って諦めた事がある。

preprocessing tokens　　 前処理字句
escape-sequence　　　　　逆斜線表記
function prototype　　　　 関数原型
unqualified name lookup 修飾なし名前の名前検索
initializer-list　　　　　　　 初期化子並び
aggregates　　　　　　　　　集成体

一事が万事こんな感じで一般的な用法から訳しすぎと思われ。

>>560
そうかなぁ。わかりやすいと思うけど。

自分はエスケープシーケンス・関数プロトタイプ・修飾なし（の）名前探索以外はそれでいいと思う。

集成体は良い訳だと思うけどな
エスケープシーケンスはひどいけど

神経とか治具みたいな神翻訳だったら使いやすいんだけど

明治の人は偉大だった

高等遊民ﾀﾋね

>>529
staticじゃインスタンス間で共有されちゃうじゃない

関数の引数にconstで参照を渡す場合って

void F(const Obj& o)であってる？

>>568
うん、それで問題ない。

constはコンパイル時に値に置き換えてほしい

>>570
できるのとできないのがあるだろさすがに。

木曜日発売のテンプレートの本
って糞本でしょうか？

えぴなんちゃらのエセ本と類似品？

えぴなんちゃらのエセ本てｗ
C++標準化委員会のメンバーなのに絶対名前で損してるなぁ

えぴなんちゃらのは糞本なの？

コンストラクでnewに失敗した場合
例外投げるのはダメなんですよね？

どうすればいいんだろう

>>575
ダメじゃない。
思う存分なげなさい。

・・・あるいはinit関数を用意する手も。

try :
mhoge(0)
{
mhoge = new..
}
catch(...)
{
delete mhoge;
}

これでもリークするもんなぁ
どうすればいいんだろう困った

それはスマートポインタ使う以外に方法がないでしょ。

見た感じ問題なさそうな気がするんだけど

コンストラクタの中でnewするんなら自分で片付けろよ

mhoge がポインタで
mhoge = new ...; でnewに失敗
　　メモリ確保、hoge(?)のコンストラクタ、メモリ解放、例外送出

メモリリークする？

やっぱ３行目は無しで

>>577 それ、どういう経路でリークするの？

お久しぶりです。
スマートポインタをまた改造しました。

ttp://cdtest.genin.jp/projects/smart_ptr/index.htm

バグの報告、どんな細かいことでもいいのでお願いします。
誰か実測、テスト用のコードを書いてくれませんか？

class Base { public: virtual int GetClassID(void) = 0; };

class SubA : public Base { public: int GetClassID(void) { static int x; return reinterpret_cast<int>(&x); };
class SubB : public Base { public: int GetClassID(void) { static int x; return reinterpret_cast<int>(&x); };
class SubC : public Base { public: int GetClassID(void) { static int x; return reinterpret_cast<int>(&x); };

全部の派生クラスに同じコード書くのはめんどいんですが
マクロ以外でこれを簡略化することはできますかね？

基底に書けばいいじゃない

>>586
基底に書いたら意味が変わっちゃう

>>585
みたいななんか嫌なid使うのって一般的なのか？

意味が変わる・・・？ 見る限り変わるようには見えないけど。

typeid(), type_infoを使わないのはなんで？

>>589
本気て言ってるのなら勉強し直してくれ

オープンソースのコードに組み込んで確認したりパフォーマンスうpてくれ

>>585みたいなIDってどう使うん？
基底クラスのポインタを使えば
仮想関数自体が自動的に派生クラス別に処理を分けてくれるような仕組みを提供できるのに

>>592
何に対して言っているんだ？

型のIDを調べるなんぞ、OOPLに対して失礼だ。
フォークとナイフがあるのに肉を手づかみしちゃうような行為。

584 名前： ◆GWRSHcLrd6 [] 投稿日：2010/02/08(月) 17:52:41
お久しぶりです。
スマートポインタをまた改造しました。

>>590
RTTIのコスト避けたいとか？

>>589
＞static int x; return reinterpret_cast<int>(&x);
各クラスでsutatic宣言した変数 x のアドレスをIDとしている。
規定でやるとどれも同じ変数 x のアドレスになるので 目的を果たせない。

ということ。

>>592
boostとどっちが優れているんだろうな。

俺もOO的にどうなのかとは思うけど
たとえばこんなんはどうよ
template <typename T> int tid(const T&t){
static T* x;
return reinterpret_cast<int>(&x);
}
class SubA : public Base {};
class SubB : public Base {};

SubA a;
SubB b,c;
cout << tid(a) << endl;
cout << tid(b) << endl;
cout << tid(c) << endl;

>>599
あんなキチガイ連中（褒め言葉）と比べてやるなよ

キチガイのやつはスマポのサイズが2倍
読みづらい

つーか、同じシンタックスのコードを派生クラスに自動定義させる方法、があるか聞きたかった
質問の仕方が悪かったのは自覚してる。反省してる


>>593
ハッシュを使って、クラスに対して任意のデータを動的に関連付けたいときとかに使えないかな？
隠蔽されたクラスを使う側のためのstaticメンバの後付けみたいな用途で

class Base { public: virtual int GetClassID(void) = 0; };
template <class T> class Middle : public Base { public: int GetClassID(void) { static int x; return reinterpret_cast<int>(&x); }};
class SubA : public Middle<SubA> {};
class SubB : public Middle<SubB> {};
class SubC : public Middle<SubC> {};

すばらしい

>>604
それも考えたんですが、継承関係が深い場合には使えないんですよね

スマートポインタのテストってどういうの作ればいいんだ？

派生クラスのポインタに代入できるとか
if(p)で使えるとか
NULLポインタのつもりで0をはじくとか
循環参照を作ってみてリークするか調べるとか
自己代入してみるとか
例外を投げるクラスを入れてみるとか

で、こいつはどうなんだ？

> if(p)で使えるとか

スマートポインタってそんなこともできるのか？

チェックするのめんどい

できるよ。さっきの人のはoperator boolを実装してるから出来るはずさ
試してないけど

operator boolなんてもんがあるのか…。
じゃあそのまんまだなｗ

みなさん、ありがとうございます。
大体のことはできるようになっていると思うのですが…

>>614
More C++ Idioms/安全な bool(Safe bool)
ttp://ja.wikibooks.org/wiki/More_C++_Idioms/%E5%AE%89%E5%85%A8%E3%81%AA_bool(Safe_bool)

>>604
が綺麗な気がするけどなぁ。
そんな変な処理をしたいにもかかわらずマクロを嫌うなら自前のプリプロセッサを使うとか
しかねぇんでね？。
(Qt的な。)

typeidじゃだめなんですか？

クラスの識別をしたい→クラスによって処理を変えたいってことなのだろうか？
仮想関数>visitor>>>>>>>RTTI(typeid) が一般的な解決策かなあ。

コンパイラがコンパイル時に多重継承だのオーバーライドの範囲だのを検出して
仮想関数テーブルを最適化してくれるならvirtul使ってもいい

class Base{〜};
#include "subc.tsv"

サブを数十作るならエクセルでコピペしちまう

new Test[100];

のように配列で確保する場合に
デフォルトのコンストラクタが無い場合の
new[]ってどのように記述するのが一般的なのでしょうか。
new[]のカスタムの定義の方法がよくわかりません。

それとも、コンストラクタはデフォルトのみにして
create_arrayみたいな関数でアロケートするのが
一般的ななのでしょうか。

static_cast<Test*>(::operator new(sizeof(Test[100])));

>>607

http://codepad.org/e9YaTqes

比較になるのか分からんけど

Mobile AMD Sempron 3600+, x86 win32, debug

boost::shared_ptrのベンチマーク
単純な生成ループ: 546
代入ループ: 515
オブジェクトのリセット: 936
オブジェクトの解放: 484

framework::smart_ptrのベンチマーク
単純な生成ループ: 452
代入ループ: 468
オブジェクトのリセット: 889
オブジェクトの解放: 453

smart_ptrの方が速い

boostはスレッドサポートしてるからかな

releaseでやれ

thread-safeじゃないからな

BOOST_DISABLE_THREADSやろうぜ

boostのがよくレビューされている。

同環境, Release, 最適化(Ox)

boost::shared_ptrのベンチマーク
単純な生成ループ: 540
代入ループ: 511
オブジェクトのリセット: 897
オブジェクトの解放: 498

framework::smart_ptrのベンチマーク
単純な生成ループ: 488
代入ループ: 477
オブジェクトのリセット: 882
オブジェクトの解放: 481

同上、BOOST_DISABLE_THREADS

boost::shared_ptrのベンチマーク
単純な生成ループ: 561
代入ループ: 453
オブジェクトのリセット: 858
オブジェクトの解放: 452

framework::smart_ptrのベンチマーク
単純な生成ループ: 453
代入ループ: 436
オブジェクトのリセット: 827
オブジェクトの解放: 437

ついに変態(boost)を超えたな

boostは糞ということがよくわかるベンチマークだな

記念age

>>621
それ危険でしょ

>630
SPが抜けてた

>>632
しかしboostでなければ上司を説得できないなど良くある話。
そもそもthread unsafeなのと比較してもねぇ。

・・・あ、Lokiは早いらしいって噂を聞いた。動けばの話だが。

どんなコードで比較してるかも分らないベンチではね。

>>637
>622

スレッド アンセーフは BOOST_SP_DISABLE_THREADSで
プラマイ0と考えても少し早いな

なぜ？

smart_ptrの方はインテリセンスが良く働いてくれる

やねうらおがクソだってことは分かった

boost::shared_ptrのベンチマーク
単純な生成ループ: 55
代入ループ: 56
オブジェクトのリセット: 70
オブジェクトの解放: 33

framework::smart_ptrのベンチマーク
単純な生成ループ: 32
代入ループ: 32
オブジェクトのリセット: 65
オブジェクトの解放: 32

PGOもしたがBoostが勝つ結果がでない

0xがまともに制定されたらboostの中の人も本気出すはず

boostの時代終わったな

残念ながら終わらない

フフフ……boost::shared_ptrは四天王の中でも最遅……

それはハカイダー四人衆にたとえると何色ですか?

>>584
gcc でコンパイルできん。

> 互換性報告などもお願いします。
互換性もたせるつもりなら gcc ぐらい自分で試しといてくれよ。

純粋仮想デストラクタって何に使うの？

なんか勘違いが見受けられるが、shared_ptrは標準に含まれるスマートポインタとしての
バイナリ互換性や安全性を目的としているんだから
速度がオレオレスマートポインタに負けるのは当たり前でしょ。
十分に検証されたスマートポインタはそう簡単には作れないよ。

こいつバカです

ｗ

> 'void (__thiscall TEST::* )(void)' から 'void (__thiscall TEST::* &)(void)' に変換出来ません
なんでstdcallは参照取れるのにthiscallは参照取れないんだ・・・
設計したやつ出て来て説明しる！

thisポインタの参照が取れたらカプセル化がえらいことになるからじゃねえ？

ごめん、適当に言ってみただけ

>>653
T* から T*& に変換できないと言っているだけのように見えるが、
stdcall とか thiscall とか関係あるの？どんなソース書いたの？

なんかすまんコピペミスった
本当はこんなことしたかった

template<class T>
void hoge(T& in){
in();
}

void huga1(){
fprintf(stderr, "huga1");
}

struct TEST{
void huga2(){
fprintf(stderr, "huga1");
}
};

int main(){
hoge(huga1);
hoge(TEST::huga2);
}

それならstaticをつければいいだけなんじゃ
struct TEST{
static void huga2(){
fprintf(stderr, "huga1");
}
};

おぉなるほど・・・しかしユースケースだと非staticにも対応しないといけないんだ
もう少しヒネって考えてみるよ

非staticなんだったら
オブジェクトを生成して
TEST obj;
hoge(&obj::huga2);
みたいにしないと

operator() の出番じゃないの？

>>660
そんなことできません。

&TEST::huga2 と obj をまとめて渡さないと。

>>660
最初のモチベーションとして&を必ず付けるのが
見た目カッコ悪いってのがあったんだけど
&つけることにするよ

>>661
どちらかというとファンクタ的動作じゃなくて
boost::function的動作をさせたいんだ

>>663
ファンクタ的動作と boost::function 的動作の違いがわからねー。
っていうか boost::function 使えって話じゃないの？

namespace framework{ typedef void *nama_ptr; }
これが一番速い

クラスA内の関数Aがあるとして、別の場所から関数Aが呼び出された場合と、
クラスA内から関数Aが呼び出された場合とで、関数Aの処理を分岐させたい
のですが、何か方法はありますか？

ifステートメントを使う

>>667
条件を教えてください

呼ぶ場所に応じて異なる引数をAに渡す

引数にパラメータを与えたり特殊化でクラスを分岐したりオーバーロードで関数を別に定義したりして
呼び出し側で条件を付与する

教えていただきありがとうございます。
オーバーロードが使えそうなのでこれを使うことにします

http://codepad.org/xhsizSDh

こんなのはどう？
つーか素直にpublicとprivateで関数名を変えた方がいいよね

>>665
ベンチにかけてみ

もう既に暖めてます

うほっ

static_cast<void*>(0); // いい事思いついた俺をdeleteしろ

やねうらおのスマポってどういうの？

delete new Hoge;

誰か俺の持論に賛成意見・反論などしてくれ。

>>679
一理ある。

オプソなら全部英語にする。
クローズドなら対象コンパイラが読めれば何でもいい。
つまり、とくに興味ありせん。

UTF-16でも英語Onlyにはなるな

class Hoge
{
public:
(Hoge)(void)
{
}

/* error
inline (Hoge)(void)
{
}
*/
inline void (Fuga)(void)
{
}
};

なぜ他はコンパイルできるのに、inline(コンストラクタ)だけエラーになるんですか？

既に定義されてるからじゃないのか

struct Hoge { inline (Hoge)(void) { } }

これでもコンパイル通らないです

http://codepad.org/1NaaFTpl
コンパイラは何だ

VC++EE2008です

わかんね
不具合じゃないかね

C++初心者です。ご教示お願います。

環境：VC++2008 EE
OS：WindowsXP SP3

ウィンドウハンドル一覧を列挙する機能をWin32APIのEnumWinodowsで作っています。
普通に関数で作成する分にはできるのですが、学習も踏まえてクラス化したいと思っています。

しかし、コールバック関数をメンバ関数に含ませる方法がいまいちよくわかりません。
ググってもウィンドウプロシージャをクラス化する方法はあるのですが、
それをEnumWinodws関数に応用する方法がよくわかりません。

そのクラスの機能の最終目的は、ウィンドウ一覧の取得、ウィンドウハンドル等の情報を
vectorなどに格納、格納したハンドルを取り出す。等です。

ウィンドウ一覧を取得する部分さえできれば他の箇所は作れます。

簡単なコード、参考ページ等教示ねがいます。

EnumWindowsの第二引数にthisをキャストして渡す。
コールバック関数で元の型に戻す。

仮想基底の初期設定に関するルール
ttp://giftserver.dip.jp/anotherproject/html_l5/myroom/diary/2007/01/09.htm
ここも読んでみたが

俺にゃまだいまいちわからねぇ。
ｗっうぇうぇｗｗｗ

http://codepad.org/pkzx86x7

virtual継承はあまり使わないから詳しいことはわからんが
・virtual継承されてればサブクラスのどこからでも初期化できる
・複数で初期化されてれば一番下のサブクラスでの初期化が優先
ということかな

>>692
それだと多重継承になってないから、
仮想継承の意味ないんじゃね？

>>693
まあそうだけど、今は初期化子の話でしょ？

>>694
でも多重継承じゃないと
初期化の問題は分かんなくない？

>>695
仮想継承じゃないと
Sub2(void) : Base(2)
{
}
ここが通らないよ
確認にはなるでしょ

ありがとう。
ttp://codepad.org/pK2DQc8i
多重継承に直してみたよ！
感謝！

ttp://codepad.org/0dGoaFYn

こんなんでもおｋなんだ。
ふーむ。

そして
ttp://codepad.org/AFW182Ps
別にSub3で明示的に呼ばなくても
勝手にBaseが呼ばれているようようだ。

・・・ああ、これが
>仮想基底のサブオブジェクトを含むオブジェクトの、最派生クラスのコンストラクタは、
>すべての仮想基底クラスの初期設定を指定しなければならない（デフォルト
>コンストラクタがある場合だけは省略してよい）。
ってやつか。
うわぁ！わかりにくいよ！！

よくよく見ると間違えてるなすまん
どこでも初期化できて一番下が優先ということではないみたいね
・一番下のサブクラスでBaseを初期化しないといけない
のほうがただしいね

>>691
分からないのは慣れてないからだと思ふ。
というかこれが理解できなくてC++を書くのは危険かと。
初期化リストっていうのは、そのクラスが持っているメンバと基底クラスのコンストラクタを
自分のコンストラクタが走る前に動かす事を記述するためのもので、
struct test : virtual base{
　inner_member a;
　test(int n) : base(n), a(n){ std::cout << "test ctor" << std::endl; }
};
test instance(111);
baseクラスのコンストラクタが走り、次にaの型であるinner_memberクラスのコンストラクタが走り、
最後に最派生クラスtestのコンストラクタtest::test(int)が走ってtest ctorと出力される。
ちなみにvirtual継承っていうのは継承関係を動的に解決する事を指定するためのもので、
urlの
1は.　通常の継承と同じ様に初期化子を記述してもよいと言っている
2は.
　仮にtestをvirtual 非virtualを問わず継承するクラスが他にあれば
　そのクラスのインスタンスにおいてtestは最派生ではないのでtestで記述された初期化子は無視されると言っている
3は.
　最派生クラスは自分が直接virtual継承を行っていなくても中間のクラスが何かvirtual継承をしていれば
　virtual継承されているそのクラスの初期化子を記述しなければいけないと言っている
通して、特に初期化子の記述がなかった場合はデフォルトコンストラクタが走る。
（これは通常の継承と共通）
そして、3において2から中間クラスのコンストラクタで記述されたvirtual継承したクラスへの初期化子は
無視されるから注意。
というか、これが分からないとC++のエラーもまともに読めないんぢゃない？
簡単なコードを読んで理解を深めるべき。

ちなみに
ttp://codepad.org/AFW182Ps
で、デフォルトコンストラクタをコメントアウトすると

基本クラス 'Base' を初期化するデフォルトコン
ストラクタが見つからない(関数 Sub3::Sub3() )

っていうコンパイルエラーになる。

>>700
分かりやすい丁寧な解説をどうもありがとう！
>　test(int n) : base(n), a(n){ std::cout << "test ctor" << std::endl; }
は分かっていたつもりだったんだが
> 初期設定を指定
っていうところで意味不明になった。

> 初期設定を指定ってつまりは
初期化子リストの意味だったのね。。

>>701
明示的にコンストラクタを1つでも記述した場合、デフォルトコンストラクタは作成されません。

>>690　ありがとうございます

thisを使う方法は思いつきませんでした。
コールバック関数はstaticにして、
EnumWindows関数では第一引数のコールバック関数をWNDENUMPROCにキャスト、
第二引数にはthisをキャストすることでやりたいことを実現できました。

助かりましたです

>>703
ああごめん、俺は単に横から>>691への口出し。
俺は別に知っているから大丈夫だお。

ぐんぐんメモリが増大するんですが。
どのコードがいくつメモリ食ってるが総和を計算してくれるツールありますか。

>>706
operation systemっていうのを使うといいらしいですよ

ヒーププロファイラでできるらしいですが
linuxは動かないんです
こんなのみつけたけど

http://journal.mycom.co.jp/articles/2009/01/27/perftools/004.html
http://valgrind.org/downloads/current.html
http://www-06.ibm.com/software/jp/rational/products/purifyp/

男はだまってタスクマネージャ

タスクマネージャでぐんぐんあがるんで
どこかを特定したいんです

compuwareにお布施するしかないのか…

メモリリーク　検出　でググれば幸せになれるよ

今スタティックライブラリを作っているのですが
例えば
boost.thread.lib
boost.shared_ptr.lib
と機能ごとにするのか
boost.lib
と全部まとめた方がいいのか
どういうふうにするのが一般的なんでしょうか？

俺なら boost.lib ひとつにまとめる
分かれてても指定するのが面倒臭いだけでリンク時間が少し短縮するかどうかわからんくらいのメリットしかないし

ありがとうございます
ひとつにまとめてコンパイルすることにします

>>712
メモリリークはしてないんです

メモリリークを検出する方法応用して
自分でモニタするシステムを作ればいいんじゃないかなということを言いたかった

ちょっとしたクラスでcppにわけるのもめんどくさいから定義をそのままhに書きたいとします
そのときにstaticメンバを使いたい場合は下の方法は両方共安全ですか？
http://codepad.org/ufCFZ8dx

スマートポインタにスレッドセーフな機構を追加したいのですが、
どのような時にはいた制御をおこなえばいいんですか？

削除の時ぐらいですか？
インクリメントとデクリメントの時はどうなんでしょうか？

申し訳ないです。
はいた　→　排他

後、ロック機構はどの様な仕組みが一番高速なんでしょうか。
_Interlocked系とかですかね？(確かこれは組み込みですよね・・・？)

どこまでやるかによるけど最終的には
あなたが実装したスマートポインタが持つ
全てのパブリックメソッドをロックしないとまずいのでは

ロックするには
cpp0xなら標準で
それ以前なら
windowsだけならCriticalSection
UnixLinuxWindowsならPOSIXのpthreadのmutex

あぁ高速かどうかは知らないや
ベンチして報告してくれるとうれしい

ptr_innerの変数をメソッドで隠蔽して、ロック機構をつけるとか？
そうすれば比較的簡単に差し替えられるんじゃないかなぁ

速度が気になるな

でもptr_inner::object, ptr_inner::count は変更しなければロックの必要なし？

速度的には
Interlocked自力 < criticalsection < mutex
みたいだな
mutexが一番遅いみたいだが移植性を考えるとmutex使いたくなるが

ビット立ててInterlock！

自力インターロックの場合ってロックされている場合の待機は
ひたすらループを回すんですかね？

到来した順に待機するシステム作ったり
同一スレッドからのロックなら素通りさせたり
なんてことしてたらどんどん重くなるけど
軽くしたいならスリープじゃね？

参照カウントの増減だけなら InterlockedIncrement/Decrement で直接増減するのが一番速いと思われ
他に何かロックしたいものがあるなら別だが
弱参照とか考え出すと面倒そうだ

custom deleterが欲しい

だからあれだけcustom allocatorを使う事を習慣化しろと言ったのだ

std::list のアロケータって何で指定できるんだっけ

>>732
3番目のデフォルト引数

template <class T, class Allocator = allocator<T> >
class list;

2番目じゃね？

http://cdtest.genin.jp/projects/smart_ptr/index.htm

修正してうｐしました。

>>622さんのをちょいと拝借してテストモジュールを書いてみました。
インターロック実装はまだです。

>>730
custom deleterは関数オブジェクトを渡せるはずです。さらにカスタムなら
ptr_innerを改造するとか。なんか取り違えていたらごめんなさい m(_ _)m

>>731
custom allocatorってどういうのなんですか？
よく知らなくて orz

>>733,734
HowじゃなくてWhyだぜ

Whyか

まず<memory>ヘッダを熟読する事

boost::poolなどを入れて実験すると良い

std::listじゃ使用されなくね？

使用されるだろ。
何考えてるんだ。

ん？
std::construct()
std::destruct()
などは普通に使用してると思うが

連続空間を要請されないだけでひとつひとつallocate/deallocateつ勝てるよ

まじか
ずっと使用されないものだと思ってたわ。
長年の疑問が解けた。

ありがとう

boost::shared_ptrのベンチマーク
計算中...
単純な生成ループ: 287
空ポインタに代入: 344
オブジェクトのリセット: 730
オブジェクトのコピー: 675
オブジェクトの解放: 311

framework::smart_ptrのベンチマーク
計算中...
単純な生成ループ: 246
空ポインタに代入: 241
オブジェクトのリセット: 496
オブジェクトのコピー: 480
オブジェクトの解放: 240

トータルスコア:
boost::shared_ptr: 2347
framework::smart_ptr: 1703

boost::shared_ptrに対する性能
単純な生成ループ: 116.7%
空ポインタに代入: 142.7%
オブジェクトのリセット: 147.2%
オブジェクトのコピー: 140.6%
オブジェクトの解放: 129.6%

全体: 137.8%

俺もboost::poolを標準で提供されているアロケータとすげ替えて
実験してみたが、そう速くはならなかった

標準のアロケータで十分にチューニングされているようだ

fast使えよ

smart_ptr/ptr_detail.hpp(32) : warning C4100: 'p' : 引数は関数の本体部で 1 度も参照されません。

型名だけ書いて変数名省略しようぜ

http://boost.cppll.jp/HEAD/libs/pool/doc/interfaces/pool_alloc.html

>もし、パフォーマンスを真剣に考えているなら、std::list のようなコンテナを
>扱うときは fast_pool_allocator を、std::vector のようなコンテナを扱うときは
>pool_allocator を使うとよい。

うーむなかなか奥が深いな

別にそんなに深くない。
連続領域かそうでないかで場合分けしてるだけ。

http://www.geocities.jp/ky_webid/cpp/library/028.html

ここには、std::listがアロケータをほとんど使わないと書いてあるんだが間違い？

>>743
不要なnullチェックを省いたのか
意外と速くなるもんだな

奥が深い症候群に罹ってます
お薬出しておきますね
つ　タミフル

C++ってどんどん肥大化して初心者に嫌われる言語になっていってるよね

>>749
vectorでは再度アロケートし直すからそれと比べて
listは要素をアロケートし直す動作を隠蔽する必要がないって言ってるんじゃない？
そもそも、「殆ど使わない」は「全く使わない」ではないからある程度使うし、vectorの使用回数が異常なだけ。

テスターが良くできている

>>752
そんな事は単純に言えないのでわ？
複雑な部分はユーザーから見えない部分に隔離して
表面的には簡単に見えるように努力していると思う

ただしストリームの多重継承とかマニピュレータとか
std::stringのメンバ関数の多さとか、問題があるなあ
と思える部分があるのは仕方が無い

初心者に嫌われてるかなぁ・・・。
これこそちょっとC++齧って俺TSUEEEEしてるスクリプトキディが言いそうな事に思えるけど。
肥大化とか仕様が膨大とか言ってるけど
言語の計算機科学的側面から性質やコンパイル時の効率と整合性、
実行速度と記述の方法を照らし合わせて最もベターな方法を取った部分など
基本形が分かっていれば仕様なんて参照しなくても容易に予測できて
理にも適ってるところが多いと思うけど。
あんまり適当な事ばかり言ってスレを荒らさない方が良いよ。
こんな議論もう10年以上前に決着が付いてるんだし。

D&Eを読めって事だな
あれを読むとぐぅの音も出なくなる

>>752
なんか>>756さんがすげぇ書いてくれているけど、
初心者が嫌うというより、バカには使えない言語になっている
だけだと思うんだけど。

>>756
>こんな議論もう10年以上前に決着が付いてるんだし。
C++0xが10年以上前にはまさかこんな仕様になると
思っていたの？

逆に、初心者に大人気！…ってのも笑うしかないくらい意味不明だしなあ

>>749
listでもなんでも指定したアロケータが使われる。
そのためにrebindがあって、list<T>ではallocator<T>が使われるという保証はないけど、
別の型Uに対するallocator<U>という形で、指定したアロケータが使われることに変わりはない。

実際C++をdisってるのって1ファイルがたったの1000しかなくても
「読めない」「長すぎ」「typenameって何だよ気持ち悪い」
「BOOST_PP_〜ってなに？」「ポインタと参照の区別が付かない」
とか言ってる碌に動作を調べもしない馬鹿ばっかりだからな。
本当にD&Eくらい読めと言いたくなる。

そういうことか。
サンクス

まあねぇ。
バカには使えない言語になっているってのは
ある意味いいことでもある。

>>759
0xじゃなくて現行仕様の話をしてるんだよ。

>>762
> 「typenameって何だよ気持ち悪い」
ちょっと同意ww
> 「BOOST_PP_〜ってなに？」
これはともかく
> 「ポインタと参照の区別が付かない」
こんなやつ居るの！？
C++とかいう問題じゃなくて、他の言語も出来ないだろそれじゃ。

C++はライブラリがいまいち

> なんか>>756さんがすげぇ書いてくれているけど、
> 実際C++をdisってるのって

こんな書き方をするのって柄の悪い若者ばかりだよね。
頭の悪いというよりは、頭も悪くて自己防衛と称して他者に考え方を押し付ける人間だと思う。
これじゃ体育会系が根性論振り回してるだけ。

>>767
Boost
Loki
Qt他
じゃ不満？

外部のライブラリはC言語用かC++言語用が多くね？

>>767
それはCも同じじゃないか？
まだSTLがある事を喜べよ
ポトペタが好きならC#かC++Builder使えばいいし

BoostとATL/WTLがあれば私は幸せです

なんか荒れてきたなw

C++が好きだろうが嫌いだろうが関係ない。
スレタイに沿わない話は全て止めろ！

ATLはｳﾝｺ

>>768
中身を見ないで外見だけで判断する老害

Cとか眼中にないから

out of 眼球

水晶体以外はみんなそうさ

QtがLGPLになる前はどうしてたん？

Qtはポトペタか
面白いな

SM PlayerがQtで作られているのを知って驚いた

Qtはmocとか変な拡張しているからなあ

うわぁ・・・
mocについて調べてみたけどプラットフォームを共通化するために
随分と苦労しているような印象を受ける

事実上のMotifの後継規格っぽいな

この辺はC++Builderの方がシンプルか
その代わり他の開発環境では動かないけど

mocすげぇよな。
いったいどうやってんだか。。。

moc使う前のコードは共通化して、moc通したコードが
プラットフォーム事に違う物(かつ最適な物)を吐くようになってるんだろうな

public slots :
だっけ？
最後はこのslotsとかは削除されてコンパイラに渡されるんだよね。

>>780
しかしQxxxというクラスに依存してQtを使っていれば
どうせ環境依存・・・じゃなくてQt依存になるわけだからいいのでは？

>>735
お！なかなかいいスコアーが出てますな。

＊shared_ptrはスレッドセーフの時
トータルスコア:
boost::shared_ptr: 527
framework::smart_ptr: 515

boost::shared_ptrに対する性能
単純な生成ループ: 101.4%
空ポインタに代入: 105.5%
オブジェクトのリセット: 100.0%
オブジェクトのコピー: 102.7%
オブジェクトの解放: 104.2%

全体: 102.3%

＊shared_ptrは非スレッドセーフ時（BOOST_SP_DISABLE_THREADS時）

トータルスコア:
boost::shared_ptr: 502
framework::smart_ptr: 521

boost::shared_ptrに対する性能
単純な生成ループ: 97.3%
空ポインタに代入: 94.7%
オブジェクトのリセット: 94.1%
オブジェクトのコピー: 97.9%
オブジェクトの解放: 98.6%

全体: 96.4%

mocみたいなのが必要なのは
C++の機能が足りない証拠
C++はもっと機能を増やすべきだ

Qtで使われてるだけで必要とは言えないだろうに

VCLも独自拡張している

>>735
inlineとかthisとか書かなくてもいい部分は省略したほうが読みやすくないかな？

もっともC++Builderの独自拡張のほとんどはDelphiサポートなんだけどな
要するにVCLはそのまま使い、言語の方を変える事によって手抜きしたわけだ

VCLがC++で書いてあったらと何回思ったか分からない

これ以上はスレ違いになるが、__published: なんかはポトペタ環境を
サポートするために必要な予約語だ

メタコンパイラが嫌ならC++/Qtみたいな言語を作ればいいだろうが
恐らく歓迎はされないだろうな

mocが無ければQt使ってたんだけどなあ・・・せっかくLGPLになったのに勿体無い

makeで勝手にやらせようず

>>792
> mocが無ければQt使ってたんだけどなあ・・・せっかくLGPLになったのに勿体無い
だからQxxxというクラスに依存してQtを使っていれば
どうせ環境依存・・・じゃなくてQt依存になるわけだからいいのでは？

環境依存ならmocなし書けるのかな

>>795
いやmocは別に環境依存を解消しているわけじゃ
ないんだぞ？
している面もあるのかもしれんけど、
mocって何の略だか考えて見れば。。。

>>785
何がオーバーヘッドなんだろうなぁ
Free()の呼び出しとか？

>>797
Decでcount==0は冗長じゃないかな？

wxWidgets がアップを始めたようです

>>799
ptr_innerにはメモリプールを使うことも考えたのですが・・・
管理が大変なんですよね

アンカーミスです
すいません
>>797

・演算コストが高い
・考えるのが面倒

どれ？

前者で・・・

計算コストが高いのに使うことを考えたの？それとも実際に評価したの？
評価してなくて早くなる気がしてるのに実装しないなら後者だよね

とか言われそうだけど仕事じゃないんだからゆっくりやればいいよ

コストが高くてもそれが全体に寄与する効果がそれ以上に高ければ
言い換えるならばメモリ管理のそのコストが必要な実装において最小なら
その実装は必要

大量のスマートポインタが参照を保持している場合、メモリプールの
領域管理が大変なコストになりそうで。
どの領域が使用されているのか、そのチェックが大きなオーバーヘッドに
なる気がするんですよね。

コストを減らそうと一度に多くとる・・・ってだけじゃ
コンスタントにメモリを喰うわけですし。

まあ、メモリプールの話は置いといて、
高速化、マルチスレッド化を図りたいと思います。

プールが役に立つのは限定された場合だけだから、マルチスレッド化を先に図るのは適切だと思うよ。

Getメソッドの時はロックの必要はありませんよね？

大体どこにロックの必要があるんだ？
説明してくれ

メモリプールするのは、Googleのやつでいい。　tcmallocとかいうの

Getしてる最中にどっかからSetされたらどうするんだ
マルチスレッドではロックは常にいる

getが処理中間状態を採る可能性がなけりゃ
必要とは言い切れんよ

まあそうだな
アトミック性の保証と言った方がいいか

intやポインタ1個だからって中間状態がないとは言い切れないからな

smart_ptrをスレッドセーフにしたいの？
格納するポインタの動作をスレッドセーフにしたいの？
前者ならget時には要らない

>>812
どこへのセット？
スマポが参照するオブジェクトをスレッド間で共有するのが目的で、スマポそのものを共有する訳ではないから一つのスマポそのものへの同時アクセス保護は不要でしょう。
内部カウンタについてもカウンタは共有されるからアトミック操作は必要だけど、ほかのメンバーは初期化後に変更されないでしょうし。

コンパイルオプションにマルチスレッドを検出したら#errorする#ifdefを書けばいい

ASCII文字列を大文字に変換して比較するときって

tolowerで１文字ずつ変換しつつ比較するしか
ないですよね？

一度にわさっと比較する方法ないですよね？

ないです

>>818
４文字分の変換テーブル

入力が小文字しかないなら'z'を文字列の長さだけ敷き詰めて
ベクタな減算とか'A'へのベクタな加算とかいろいろしてわさっとできる。

文字を大文字にしてしまっていいなら
string word;
//
//gcc(VCならtoupperの型が違うので関数オブジェクトを作る)
transform(word.begin(),word.end(),word.begin(),toupper);
//で変換して
if(word < word2)

>>822
stringなんて作ったらそれだけで遅い
意味ないこと書かないでくれよ

Boehm GCに速度で負けたら使う意味ないがな。
これはGC_mallocで確保した物を自動開放するやつだが
スマートポインタと機能は同じだろ。
歴史が長く使いこなされてるから、これよりパフォーマンス上がらないとこっち使えばいい。

質問者にあわせた無難な例示に見えるが

#define malloc GC_malloc
などと定義すれば、すべての動的確保を自動化できる。
全自動したとき、Boehm GCより速度が上がるなら使う。

動的メモリを多用するソフトで明示的なfree、deleteを外して
組み込んで、ピークメモリと実行速度を比較してくれよ。

EffectiveC++によるとクロスDLL問題なるものがあるらしい
スマートポインタはカスタムデリータが指定できるから大丈夫だそうだが
カスタムデリータを指定せずにスマポを使ったら
メモリが破棄されなかったりする？

std::*streamから零終端文字列に変換してc_func(const char *)に渡す最も効率のいい方法はどんな方法ですか？

バイナリモードだったら動的配列にreadすればいいんですが
テキストモードだとreadが使えないので困ってます

Boehm GCはスレッドセーフだっけ？

つ ttp://www.namikilab.tuat.ac.jp/~sasada/prog/boehmgc.html

>>829
効率のいい方法より、確実に動かすことを考えたら

Boehm GCｒｅａｄｍｅ

The allocator/collector can also be configured for thread-safe operation.
(Full signal safety can also be achieved, but only at the cost of two system
calls per malloc, which is usually unacceptable.)

アロケータ/コレクタは、スレッドセーフな操作用に構成することができます。
完全な信号の安全性も、2つのシステムのコストだけで達成することができます
malloc関数あたりは、通常は許容されませんコール。

>>829
書いてみたけど
テキストモードという前提があるからistream_buf使えないからあんまり効率よく書けないなぁ
#include<istream>
#include<string>
#include<iterator>
std::string to_string(std::istream&input){
    input.unsetf(std::ios::skipws);
    return std::string(std::istream_iterator<char>(input),std::istream_iterator<char>());
}
#include<istream>
#include<string>
std::string to_string(std::istream&input){
    std::string line;
    std::getline(input,line,'\0');
    return line;
}

>>814
レジスタ1つに入るレベルだから中間状態はないだろう

>>828
破壊されない。
newした側でshared_ptrに渡せばnewした側のランタイムのデリータが呼ばれる。

>>826
君は、Boehm GC使ってるの？

頻繁に使わないが、使えるようになっている。
boost使うくらいなら、こっちを使う。
boostの頻繁な更新とスマートポインタの変化をチェックするのは面倒。
あと重いし、スマートポインタだけ分離できない。手を加えればいけると思うけど面倒。

2009-06-11 Hans Boehm
win32_threads.c (MAX_THREADS): Define as 1 if GC_win32_dll_threads
is defined as FALSE (otherwise the size of dll_thread_table is near　200 KiB for 32-bit).

>>838
>>831

>>838
STLとの相性はどう？
>>831
速いのか遅いのかよく分りません

待機のためにsleepを使いたいのですがVCにはsleepがなく、unixにはSleepがないんですよね・・・
#defineしか無いのでしょうか？

>>842
スマポにsleepはいらないと思うよ。
スマポはアトミックオペレーションで実装できると思うよ。

doubleの中に、プラスゼロとマイナスゼロのどちらが代入されているか、
調べる簡単な方法はありますか？
char[100] str;
sprintf(str, "%e", a);
としてdouble aの値を書いておいて、先頭が'-'かどうかを調べるのは思いついたのですが、
通常はどうやるんでしょうか。

a==0.0?plus:a==-0.0?minus:other;

アトミックオペレーションはCPU依存じゃないの？

http://ja.wikipedia.org/wiki/%E4%B8%8D%E5%8F%AF%E5%88%86%E6%93%8D%E4%BD%9C
CPU依存するみたいだけど
これが出来ないような環境はマルチスレッド推奨じゃないと思っていいんじゃないかな

あるスレで貼り付けられていたのをコピペしてみる。



コメントは // と /* */ とからなりますが、厳密にはC++言語は次の様なコメントの扱いをします。

1. //でコメント導入を示し、行末までがコメントになります。

　var = 42; // comment

2. /*と*/で囲むと、複数行コメントになります。

　/*comment*/
　aaaコメントでない
　/*comment
　　comment
　　comment
　 */

3. コメントの入れ子については
C++言語では基本的に前から見ていくので、最初に出現したコメントが優先されます。
（//を無条件で優先するというようなことはありません。）

従って
　/* foo // bar */
　foobar */
は最初の/*を見た瞬間から*/が出現しない限り全て無視する（コメント扱いする）こととなります。
よってC++言語では//を見ても何とも思わずコメント扱いを続け、
その後最初に */を見た瞬間にコメント扱いを終了します。
よって foobar までコメントになるのでははなく、
/* foo // bar */だけがコメントとなりfoobar */の部分はコメントでないことにとなります。

4. 文字列リテラルの扱い
C++言語では "" で挟まれた物を文字列として扱います。
"コメントでない"//comment

5. コメントと文字列の入れ子について
C++言語では3.と同様に、最初に出現したものを優先します。

#############C++言語 コメント&文字列の扱いの例#############

// comment /*
foo コメントでない
// comment */

foo /*
comment
// comment */

// comment /*
foo コメントでない
foo */ これはコメントでない

"// foo" コメントでない

// "comment" コメントである
/* "comment" コメントである
　comment
// comment */

foo コメントでない
"/*" コメントでない
foo コメントでない
// comment */

C++言語 コメント&文字列の扱いの例
ttp://codepad.org/PMJ0Om1O

こっちのがずっと見やすいな。

>>843
アトミックオペレーションを保証するためのlock関数みたいのはあるんでしょうか？
インクリメントだけでなく、内部ポインタに入る前に他のスマートポインタからの操作を
ロックしたいのですが。

void AddRef()
{
　　lock();
　　inner->Increment();
　　// 前後にロックしていなかったらIncrementに入った直後に
　　// 無くなっているかもしれない(推論)
　　unlock();
}

勘違いですかね？

これ思い出した

int is_cpp()
{
return 1 //**/ 2
;
}

>>851
スマポの複製をするときは、そのスレッドは最低１個のスマポを掴んでいるから開放されることは無いと思うよ。

smart_ptr<int> p;

int main()
{
　　{ p = new_ptr(new int(0)); }
　　do_work(thread1);
　　do_work(thread2);　
　　return 0;
}

void thread1()
{
　　smart_ptr p2 = p; // p2.Copy(p);
　　if (p) p->Invoke();
}

void thread2()
{
　　p.Free();
}

>>854

ケース1: エラー無し

thread1 --Copy---------Invoke---------------
thread2 -------Free-------------------------
innerの寿命 ------------------------------------
カウント 1----21----------------------------

ケース2: エラー無し(Invoke不可)

thread1 ----Copy---------Invoke(NULL)-------
thread2 Free--------------------------------
innerの寿命 ------------------------------------
カウント 1--0--------------------------------

ケース3: E N D

thread1 ------Copy--Invoke(Invalid Address)-
thread2 ----Free----------------------------
innerの寿命 ------------------------------------
カウント 1------0-?--------------------------

こうなる

>>841
http://qqqppp.net23.net/BoehmGCwin32.zip

バリナリ上げとく。
全てのメモリ管理を置き換えるわけではなく
STLだけ標準にも出来る。
GC_mallocを使ったときだけ、ガベージコレクション発動する。

/*/ ってどうなるんだっけ？

昔これを書いてる奴がいて、よっぽど M か
トンチ好きなんだなと思った記憶がある。

C++書いてるのにトークン分け規則が頭に入ってないなんて格好良過ぎる

>>854
せっかく複数のスマポ間でオブジェクトの共有をできるようにしてるのに、スマポ本体をスレッド間で共有する必要はなくないか。
スレッドごとにスマポを作った上で一つのオブジェクトをスマポで共有すればいいんでしょう。

>>859

もうここまでくるとスレッドセーフに設計する必要ない気がする
エラーになるケースが思いつかん

みんなの意見をオラにくれ

>>860
共有するならスレッドセーフにしないと共有されてるカウンタのInc/Decができないから必要だわ。

bufという中身に「0,あいうえお,1,2,」
という文字列を配列に格納したい場合の質問です

int a,b,c;
char d[10];
sscanf_s(buf,"%d,%s,%d,%d,",%a, %d, sizeof(d), &b, &c);

と書いているんですがｄにうまく「あいうえお」と収納できません。
どこが間違っていますか？
ｄに「あいうえお,1,2,」と収納されてしまいます

すいません
sscanf_s(buf,"%d,%s,%d,%d,",%a, d, sizeof(d), &b, &c);
の間違いでした。
この状態だと動きませんので教えてください。

普通に作る場合、スマポだからとかは関係なしに
共有リソースをアクセスするときには排他処理を入れると思う

C++というよりVC++で使えるリジュームダウンロードを行える関数はありますでしょうか？

>>863
まだ間違ってね？

スマートポインタの使い方についてなのですが、
ポインタaをshared_ptrなどに格納した後このshared_ptrには触れず、
処理は生のポインタaを介して行う…というのは行うべきではありませんか？

もし生ポインタがdeleteされたら二重にdeleteされるかもしれないので
インタフェースの関係で仕方ない場合はあるが
基本的にはやるべきじゃない
何のためにshared_ptrを使ってるのかって話になる

GCのほうが参照が無くなったら直ちに解放しない分速いのか。
スマートポインタは直ちに回収するんだろ。
GCは1秒や5秒ごとでもいいはず。

>868
ありがとうございました。
クラスのメンバをスマートポインタ型などで宣言するのに抵抗があるもので…

>>870
> クラスのメンバをスマートポインタ型などで宣言するのに抵抗があるもので…
(　ﾟдﾟ)
(つд⊂)ｺﾞｼｺﾞｼ
(；ﾟдﾟ)
(つд⊂)ｺﾞｼｺﾞｼ
(ﾟДﾟ≡ﾟдﾟ)ｴｯ!?

基礎中の基礎だぞ？

俺はコピコンを乱用するようなコンテナくらいでしかスマポは使わないわ
クラスメンバのポインタとか裸んぼさん

Boehm GCの特徴

マーク・アンド・スイープ - Wikipedia

この方式は、参照カウントにおける問題を回避し、
不要なオブジェクトを確実に破棄できる。
また、参照カウントを使わない分、
ガベージコレクタが動作していない間の処理は高速である。

反面、ガベージコレクタ自体は、参照カウント方式より処理時間がかかるため、
参照カウントによるごみ集めと併用されることがある。
いくつかのシステムでは、参照カウントによるごみ集めを常に行い、
マークアンドスイープは、次のような適当なタイミングを見計らって時々行う。

メモリが不足してきたとき
システムが何もしていないとき
プログラムから明示的な指令があったとき

>>871
その書き方だとしちゃいけないみたいに読めるぞｗ

「とりあえずスマポ」
これは初心者にありがち

回収がいつになるか決まらず、デストラクタが遅れることがあるらしい。
これは不便。デストラクタをもつクラスにはつかえんな。




Python - Wikipedia
マーク・アンド・スイープ方式のみに頼っている言語では、
オブジェクトがいつ回収されるか保証されないので、
ファイルのクローズなどをデストラクタに任せることができない。
CPythonは参照カウント方式を併用することで、循環参照が発生しない限り、
オブジェクトはスコープアウトした時点で必ずデストラクトされることを保証している。
JythonおよびIronPythonではマーク・アンド・スイープ方式を採用しているため
スコープアウトした時点で必ずデストラクトされることが前提のコードだと
JythonやIronPythonでは正しく動かない。

>スコープアウトした時点で必ずデストラクトされることが前提のコードだと
>JythonやIronPythonでは正しく動かない。
自分のプログラムに関係ないところで悩まされるのは嫌だなあ・・

回収に時間差があっても取り残さず消されるだけでも使えるけど。
参照消滅と同時だと、頻繁に回収が起こりパフォーマンスが落ちるし。

消滅が頻繁に起こってそれが問題になるならメモリプール使えばいい

>>877
クラスは自動変数か明示的な動的確保して
クラス内でガベージコレクション使って動的確保したら、デストラクタは動作する。
なのでたいした問題ではない。

>>861
>共有するならスレッドセーフにしないと共有されてるカウンタのInc/Decができないから必要だわ。

なぜ？

>>877
いつデストラクトされるか分らないなんて、確かに困るよな。
大量のバッチ処理時なんかに、ファイルのオブジェクトがいつまでも残ってクローズされて共有違反になるとか非常に困る。

bufという中身に「0,あいうえお,1,2,」
という文字列を配列に格納したい場合の質問です

int a,b,c;
char d[10];
sscanf_s(buf,"%d,%s,%d,%d,", %a, d, sizeof(d), &b, &c);

と書いているんですがｄにうまく「あいうえお」と収納できません。
どこが間違っていますか？
ｄに「あいうえお,1,2,」と収納されてしまいます

%a

>>883
%a というのは正しいのですか？

>>884 そこも違ってたようです
でもこれだけが原因の様じゃないようです

>>881
確かに必要な気がしなくなってきた

sscanf_s(buf,"%d,%10c,%d,%d,", %a, d, &b, &c);

>>888
その方法だと「0,あいうえおかきくけこ,1,2,」とかだと対応しないですよね
外部ファイルを読み込むのが想定なので・・・

そもそもchar[10]と例ではなってるので５文字以上ははいらないか
1〜4文字だった場合は失敗するのでそういう方法以外でお願いします

for (p = buf, *p; ++p) if (*p == ',') *p = ' ';
sscanf_s(buf,"%d %s %d %d ", %a, d, &b, &c);

sscanf_s(buf, "%d,%[^,],%d,%d", &a, d, sizeof(d), &b, &c);

891のソースはコンパイル通らなかったので
多分「,」ではなくスペースで区切って処理をしろって事ですよね

892のソースはそのまま動きましたありがとうございます

smart_ptrのベンチマーク
代入
boost: 120
framework: 55

速すぎクソワロタｗｗ

>>890
sscanf()、そして C 言語はそういうもの。文字列のサイズをきっちり管理したいのであれば別の方法をとるべき。