C++相談室 part11

メモリリークなんてなぁプロセスが終了しちまえば一発で解決なんだぁよ
制限がキツイとか常駐ソフトとかでもないかぎりあんま気にすんなぁ

むしろ個別にFreeすると終了処理が長引くので、
Freeしないで終わるようにする定石もあるらしい。
Windowsだとちょっと心配だけど、UNIXなら問題
ないのではないでしょうか？

ま　た　m a l l o c & f r e e で　す　か。

deleteは忘れるなよ。

borland c++ から c++builderへ.rcファイルごと移行したいのですが、どうすれば良い
ですか？

学生時代以来のC/C++プログラミングなので、ちょっと混乱していました(w

たしかにプログラムが終了すれば、OS が面倒みてくれますね。常駐型の
プログラムを書いているので、別の問題とごっちゃになっておりました。

> あるクラスのインスタンスを一つ生成し、それがイベントループを廻し続けるような
> プログラムを書いているのですが、この場合デストラクタが呼ばれることがあるので
> しょうか。

結局のところ、興味があるのはこの点でして、このタイプのプログラムの場合、その
クラスのデストラクタを書いても意味はないかどうかということです。

顔が汚くてもいいから、胸の大きい女性を望むあなた・・・。

>>751
プログラムの終了処理はＯＳが面倒見てくれることばっかじゃなしなぁ。

>>747
まあそういうVB厨プログラマが大勢いるから
NT系サーバの連続運用は難しいとかよく落ちるとか
１日一回リセットとかの話になるわけだな。

>>747 100%pure VB房と認定されますた。
VB房ロゴの使用を許可します。

>>747に同意

ClassX a;
ClassX b;
ClassX c;

a = b;
a = c　←の時点で、aのデストラクタって呼ばれるのでしょうか？

ClassXの内部で動的にメモリを確保しているような場合、上のような
状況で開放する術はありますか？

>>757
デストラクタじゃなくてoperator=が呼ばれる。

>>758
おお！即レスありがとうございます。
ちょっと悩んでいたんで、かなりうれしいです。

しかしEffective C++ にのってる a = a のチェックって誰かしてる奴いるんか？

自己代入のチエックってやっぱりthisとrhsのアドレス比較するんかなあ。

>>760
メンバがスマートポインタなら a = a でもデータ消失はないから大丈夫。
さらに operator = やコピーコンストラクタも定義する必要なし。夢のハッピーライフ。

でも、スマートポインタ使いまくりって奴もあまりいないが。

>>760
Exceptional C++ の項目38に従って必要ならする…
と言いたいところだが、自己代入がボトルネックになる
場面なんて出会ったことないので結局やってないなぁ。

>>762
それじゃあ、デフォルトのoperator=とかコピーコンストラクタが
コピーじゃなくて実装の共有になってしまわんか？それで幸せなら
特に止めるつもりはないが。

>>747
ねぇ、それはネタなの？ 本気なの？ 正しいの？ 間違ってるの？

>>764
UNIXで仕事してたときに終了時に free をずらずらと書いて開放処理をしていたら
先輩にCPUに無駄な仕事してんじゃないと怒られました。

>>760

a = a のチェックは必要なら普通するけど･･･ってのはウソで、
a = a でも問題ないようなコードで済ますことの方が多いか。

a = a でも問題ないようなコードって、たとえばポインタなら自己チェックと
スマートポインタ以外の方法あるの？

freeは未使用マークをつける
プログラム終了時には確保したメモリ領域はOSに返却される

どちらも「解放」という言葉を使ってるのが誤解を生む元になっているのではないだろうか。

＃freeがOSに返却しないのは「多くの処理系では」という条件付らしいが，詳しくは知らん

>>767
T& T::operator=( const T& other )
{
　T temp( other );
　this->Swap( temp );
　return *this;
}

http://www.gotw.ca/gotw/059.htm

やってることは一緒だけど、ディープコピー・開放・ポインタ代入、とか。

クラス内のフィールドに外部から値を取得することはできるが、
設定することはできず、クラス内部の関数からは設定することが
できることってできますか？

ClassA
{
private:
int m;
public:
ClassA(int m);
}

だと、mを取得することができない。Getなどのアクセサをつかわずに、
mをpulicにしても、なおかつ、設定はできないみたいなのはできますか？

C++の仕様ではできない。素直にgetアクセサをつけるべし。
つかpublicなメンバ変数は、レコードのような扱いでないかぎり
あんまりお勧めできない・・・

<Del厨モード>
ちなみにC#ではgetのみのプロパティにて実現可能。
Javaにはないよね（藁
</Del厨モード>

template<class T> struct id{ typedef T type; }; // dummy

template<typename Type, class Owner>
class read_only_field
{
public:
operator const Type& () const { return t; }
private:
friend typename id<Owner>::type;
read_only_field& operator=(const Type& ot) {t=ot; return *this;}
Type t;
};

class A {
public: read_only_field<int, A> m;
...
};

…99.5%くらいネタだけどな。

void f(std::vector<int> (&vr));
void f(std::vector<int> &vr);
void f(std::vector<int> (&));
void f(std::vector<int> &);

全て同じ宣言ですか？

>>774
同じだろう。プロトタイプ宣言の仮引数は型しかチェックされないから。

>>775
ﾚｽｻﾝｸｽ。
やっぱりか(；´Д｀)

ｳﾜｧｰｲ777!!

ｳﾜｰｲ778!!

delete >>777-778;
return -1;

宿題スレに書いたんですが、レスが無いのでこちらにも書かせてください。

コールバックって、メンバー関数をじかに呼べないんですが、

class Aとclass Bがあって
Bは、コールバックされる関数(SetTimerとか)を使っていて、
さらにそのコールバックされる関数の中でBのメンバー関数を呼び出したい。

BにAのインスタンスのポインターを持たせればできますが、
1. Bの実装でAに依存しない(class Aのクラス定義を読み込まない)
2. Aをコールバックされる関数を含んだ中傷クラスのサブクラスとしない

という条件で、うまい方法ってないですか?

現状はtemplateを使って(public,private等は省略)
class base {
　virtual void operaot()() = 0;
};

template<class T>
class callback : public base
{
　typedef void (T::*F)();

　callback(T* obj, F func) : o(obj), f(func) {}
　void operator()() { return o->*f();

　T* o;
　F f;
};

とやって、AはBにcallbackのインスタンスを渡すようにしてますが、今市…

>>780

普通に多重継承で interface (風のもの) 使えば？

そりは、条件2にひっかっかって…
実は、class AはCOMのクラスなので、何か仮想関数持ったクラスを継承する
のは問題が起きるのではないかと思うのですが。
そんな事は無いのでしょうか?

>>780
デリゲートって知ってるか？

デリケートですか？デリケートですか？

艦載陣さんですか？

デリケートゾーンのかゆみに…

はっきり

　ま　ん　こ

と書けやゴルア！

股間の痒みにメディナース

変態ばっかだな

まかいあんこやまらさきむんこは嫌いです

クラス内ローカルクラス宣言てできますか？

class A
{
　class B
　{
　　operator int() { return 1; }
　}
　B getB() { return B(); }
}MyA;

int a = MyA.getB();

みたいな
もちろんint b = B();はコンパイルエラーで

クラスＢ定義のあとに「;」忘れました・・・

Java厨か?
できるよ。

関数内にもできる。
実はつかったことないけど・・・汗

関数内に関数はできないんだよなー。
なんでだろう。

High-Cはできたなあ...

関数オブジェクトならできるだろう。

関数内クラス内に関数を作れば良いのだ！

>>797
だがテンプレート引数として渡せないという罠。（なんとなく理由は想像がつく）

>>780
AからBの関数を呼んで、BはAの(コールバックされる)関数を呼んで、
さらにそこからBの関数を呼ぶ、ということ？
で、AはBの定義やインスタンスを知っていて、しかもCOMのクラスなのね？
だとすると、多分Aはプラグインか何かだと思うけど、継承を避けるなら
780に類する方法しか無いと思う。ただ、Aを含むオブジェクトの中には
callback<A>もいて、それは仮想関数を持ったクラスを継承している。
WinもCOMも知らないから、何とも言えないけど、780で動いているなら、
継承は出来るんじゃあないかなあ。
構造上理由があって、継承を避けたいということならいいんだけど。

Java厨というか、無知なだけです・・・
クラス内クラス宣言が利用に先立ってされなければならない（らしい）という所にひっかかってました

class A
{
　B getB();
　class B;
}; // コンパイルエラー「Bの重複定義」

というやつ・・・

class A
{
　int hoo() { return bar(); }
　int bar() { return 1; }
}

はOKなのに・・・

>>782

A が COM オブジェクトなら、ITimerHandler とかのカスタム
インターフェイス（を定義して）持たせておけばよいのでは?

多重継承とCOMについては、一度 ATL のサンプルソース読んでみて。
インタフェイス継承も実装の継承も多用しているから、大分参考に
なるはず。

>>801

class A
{
　int hoo(){ B b; }
　class B{};
};

これはOK
違いわかる？

Visual C++ 6.0 で以下のようなコードを試しています。

　ofstream out;
　out.open("nowhere\\test.dat");

ところが、open に失敗します。
つまり、ファイルをオープンするとき、書き込み用の場合などは、
ファイルが存在しなくても、自動的に作成してくれるようですが、
ディレクトリも同時に作ってくれたりはしないみたいです。

ディレクトリを作成しつつファイルも作る方法はありますか？
あるいは、単独でディレクトリを作成する標準関数はあるのでしょうか？
（Windows 用の _mkdir などを使うしかないのでしょうか？）

>>804
ファイルとディレクトリはWindowsでは全く別々のものなので、
ディレクトリを作ってからopenして下さい。

STLのコンテナに自作したクラスhogeへのポインタを追加していって、それをソートするのに
namespace std
{
struct less<Particle*>: public binary_function<hoge const *, hoge const*, bool>
{
bool operator()(hoge* const a, hoge* const b)
{
return a->val < b->val;
}
};
};
std::list<hoge*> hogelist;
・・・//hogelistにnewしたhoge*を追加
hogelist.sort(std::less<hoge*>());
のようにしています。
・stdに手を入れていること
・hoge*に特化したstd::less<hoge*>を使っていること
の2点でよくないような気がするのですが、他の方法はありますか？

>>806

STLスレッド part2
http://pc3.2ch.net/test/read.cgi/tech/1026793823/l50

>>805
うーむ、そうですか。
ディレクトリを作りつつ……というプログラムを C++ でやろうとしたら、
OS に依存したコードを書かなければならない、ということですね。
どうもありがとうございました。

>>808
> ディレクトリを作りつつ...
> OS に依存したコードを書かなければならない、

当たり前だと思うけど...、全ての OS に階層ディレクトリがあると思っているのか ?

>>804の言うOSとはWindowsとLinuxの2種類だと思う。

>>810
> >>804の言うOSとはWindowsとLinuxの2種類だと思う。

>>804 だったら、Windows だけだろ ?

> Visual C++ 6.0 で...

>>806
std以外の名前空間で定義すればよい。

namespace hehehe
{
template <typename T>
struct less<T*>: public binary_function<const T*, const T* , bool>
{
bool operator() (const T* a, const T* b) const
{
return a->val < b->val;
}
};
};

>>811
あー，ちゃいます。
804が書いた>>808のレスの中で言ってる「OS」のことです。

若干修正

namespace hehehe
{
template <typename T>
struct less<T> : public binary_function<const T*, const T* , bool>
{
bool operator() (const T* a, const T* b) const
{
return a->val < b->val;
}
};
};

別にlessに手を入れる必要無いじゃん。
直接テンプレート引数にファンクタ渡せば？

>>809
> 全ての OS に階層ディレクトリがあると思っているのか ?

すみません、かなり勉強不足でした。

少なくとも C++ が走るようなものではそうだと思っていました。
ちなみに、どんな OS だと階層ディレクトリがないのですか？
（検索しても Windows/Unix/MacOS 以外については余り情報が得られないので。）

なお、
> ディレクトリを作成しつつファイルも作る方法はありますか？
に関連して、無効なパスを渡された場合、
１・階層ディレクトリのある環境ではディレクトリの作成を試みる
２・そうでないときは、やはりエラーを返す
というような機能を考えてみたのですが、
やはり無理、またはやらない方がよい、ということですか？

>>816
ふるいmvsとか

>816
プリンタや自販機のROMの中にもOS入ってたりする。

>>815
どういう風に書けばいいの？

>809
全てのOSにファイルはあるの?

＞819
list::sortには、Predを引数とする版があるだろ。

>>821
ああなるほど、std::lessではなくて、適当な名前の比較関数オブジェクトを
渡してやればいいのですね。

>>820
組み込みだとディスク自体が無いね

ファンクタライクな物をVC.NETで作ってるんですが、
部分特殊化できないと　LokiのTypeListみたいなのはつくれないんでしょうか？
//_Tはクラス. _R は戻り値の型. _Lは引数の型
template <typename _T,typename _R,typename _L>class FunctorX
{protected:
_R(_T::*mem_f1)(_L);
_R (*g_f1)(_L);
_T* obj_ptr_f1;
_T* func_obj_ptr_n1;
enum Mode{other,mem_ptr,ptr,func_obj}m_mode;
void Ini(){
g_f1= NULL;mem_f1 = NULL;
obj_ptr_f1 = NULL;func_obj_ptr_n1 = NULL;
m_mode = Mode::other;
}
public:
FunctorX(_T& ob,_R (_T::*f1)(_L)){
Ini();mem_f1= f1;
obj_ptr_f1 = ptr;m_mode = Mode::mem_ptr;
}
explicit FunctorX(_R (*f1)(_L)){
Ini();g_f1 = f1;
m_mode = Mode::ptr;
}
explicit FunctorX(_T& ob){
Ini();func_obj_ptr_n1 = &ob;
m_mode = Mode::func_obj;
}
FunctorX(){ Ini()}
~FunctorX(){}

途中まで読んで頭が痛くなってまいりますた

_R call(_T& ob,_L a){
if( obj_ptr_f1 != NULL && mem_f1 != NULL && m_mode == Mode::mem_ptr){
return (ob.*mem_f1)(a);}
throw "Functor error";
}
_R call(_L a){
switch(m_mode){
case Mode::mem_ptr :
if( obj_ptr_f1 != NULL && mem_f1 != NULL )
　　　　　　　　　　　　　　　　　　　　return (*obj_ptr_f1.*mem_f1)(a);
break;
case Mode::ptr :
if( g_f1 != NULL )
return (*g_f1)(a);
break;
case Mode::func_obj :
if( func_obj_ptr_n1 !=NULL )
return (*func_obj_ptr_n1)(a);
break;
default:
break;
}
throw "Functor error";
}
_R operator()(_L a){return call(a);}
};

struct Test
{
template<typename R,typename L> R f(L a){ return a*2;}
Test(){}
~Test(){}
};

int main()
{
Test c5,c5a;
Functor<Test,int,int> t5(c5,&Test::f<int,int>);

cout << t5.call(c5,100);
cout << t5.call(100);

cout << t5.call(c5a,100);//c5 の関数ポインタ経由で c5aを呼び出す???
cout << t5(100);

FunctorX< Functor<Test,int,int> ,int,int> t6(t5);
t6(100);

}

>>824
その規模のコードはcppにしてどこかにアップしろ

コメントされてない（しかもインデントすらされていない）コードなんて
ただのゴミ

>>828
template苦手だからってキレんなよw

>>829
でもそれだけ書かれてもなぁ。

Lokiスレのほうに書きゃいいのに、とはオモウ。

TC++PL3rdや>>3のFinal Draftにある文法に
member-declaration
　:decl-specifier-seqopt member-declarator-listopt ;
　|function-definition ;opt
　|::opt nested-name-specifier templateopt unqualified-id ;
　|using-declaration
　|template-declaration
　;
という部分がありますが上から三番目は何に使われてますか？

ClassA{
private:
int *a;
public:
ClassA(){a = NULL}
ClassA(int i){ a = new int [i] }
}

みたいなクラスがあって、

ClassA ain = new ClassA[100];

で呼ばれるコンストラクタは引数なしのコンストラクタしか無理ですか？

ClassA* ain = new ClassA[100](10);

>>874
それほんとにいける？

無理でせう。

>>874は逝けそうだけど逝けなさそうな微妙なことを書かねばならなくなりました。

なんだこの低能なシーケンスは！

ともっちに手取り足取りC++教えたい

次のプログラムをコンパイルするとエラーが出てしまいます。
Aがシンタックスエラーを起こしていますとか。
どういうことなんでしょう？
本に書いてある通りにやっているのに・・・。
何がいけないのでしょう？

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

class A {
public:
int id;
};



int main()
{
int i;
A c;

c.id = 100;
for( i = 0; i < 7; i++)
printf( "id = %d", c.id);

return 0;
}

初心者が質問するなら、エラーをそのまま貼らないと。それから

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

こんな低脳なコードを乗せている入門本は古すぎるか腐っているので
捨てた方が吉かと。

コンパイラはなに？
bcc32では動いたよ。
拡張子は.cppとかにした？

.cから.cppになおしたらできました。
ありがとうございました。
一体２つはどう違うのでしょう？

C言語っていう腐れ言語しらんの？>>843

ところで、stdlibをインクルードしてる理由は何なのさ？

ループを7回まわしている理由モナー

クラス内関数のテンプレート化で質問です

class A
{
　template<class T>
　　T foo()
　{ なんたらかんたら }
}myA;

int a = myA.foo<int>();

でコンパイル通ってしまうんですが、
これはどう解釈されてるんでしょうか？

「返値の型だけ異なる」オーバーロードってNGでしたよね？

age忘れ...

>>847
コンパイラがbccだからじゃない？

突然ですが純粋仮想関数のデストラクタは必ず実装しなければならない、
とは知りませんでした。首吊ってきます。

最近なかなか寝付けません。どうしたら良いのでしょうか？

くだらなすぎ

>>847
テンプレートはオーバーロードではないからだろ

C++で、2次元（以上の）配列に対して、
辞書式順序でsortできるようにするためには、
bool operatorとsortを使えばよいらしいというのは、
分かったのですが、具体的なコーディングが分かりません。
教えてください。

>>854
何がしたいのか読み取れん。いったい何がわかっているというのだ。

ソートっつー概念はそもそも直線的なものにしか成り立たないんじゃないか？
2次元以上の要素をいったいどう並び替えろと？

もしかして組み込みの配列？

辞書式順序です。
例えば、(1,2),(5,6),(5,4),(2,4)というデータがあったら、
第一番目のデータを見て、(1,2),(2,4),(5,6),(5,4)
と並び替え、
一番目のデータが同じ時は、
(1,2),(2,4),(5,4),(5,6)
のように並び替えたいのです。

数学的に書くと
(i,j)<(k,l)←→i<k　
　　　　　　 　i=kのときは、j<l
としたいということです。

>>858
文字列のソートがどうやっているかわかってるなら、それと同じようにすれば
いい。

>>858
> 辞書式順序です。

頼むから、用語はちゃんと覚えてくれ。あやふやだったらはじめから使うな。

> 一番目のデータが同じ時は、
> (1,2),(2,4),(5,4),(5,6)
> のように並び替えたいのです。

というのは、単に複数キーでソートすると言う。
(ちなみに、辞書式というのは概ね文字コード順にソートすることを指す。)

> 数学的に書くと
> (i,j)<(k,l)←→i<k　
> 　　　　　 　i=kのときは、j<l

と言うのがわかっているなら、qsort() の比較関数をそのように書けば良いだけだよ。

でも、そう言うデータなら二次元配列より構造体の一次元配列の方がわかりやすいと思う。

>>860
> >>858
> > 辞書式順序です。
>
> 頼むから、用語はちゃんと覚えてくれ。あやふやだったらはじめから使うな。

固定長の文字列とみなせば辞書式と言っても間違いではない。

> (ちなみに、辞書式というのは概ね文字コード順にソートすることを指す。)

別に文字コードじゃなくたっていいんだよ、順序さえあれば。

テンプレート型のクラスのコンストラクタを
宣言と実体を別ファイルで書くことは出来なんでしょうか？

ファイル：a.h
template<class T>
struct A
{
A();
};

ファイル：a.cpp
template<class T>
A<T>::A()
{
}

このクラスを別のファイル(main.cpp)で使おうとすると、
外部シンボルが未解決ですと言われます。
何か書き方が間違っているのでしょうか？
一応a.hに実体もまとめて書けばエラーにはならないのですが･･･

過去ログを参照願います。

>>861
> 固定長の文字列とみなせば辞書式と言っても間違いではない。

ハイハイ、人の指摘に手一杯で、>>858 の

> 数学的に書くと
> (i,j)<(k,l)←→i<k　
>　　　　　　 　i=kのときは、j<l

は見てないのね。

> 別に文字コードじゃなくたっていいんだよ、順序さえあれば。

ハイハイ、｢概ね｣と言う言葉も理解できなかったのね。


ったく、話の流れぐらい読めよ。

>>864
何が言いたいのかわからんが「辞書式比較」の定義って、二要素なら
　> 数学的に書くと
　> (i,j)<(k,l)←→i<k　
　>　　　　　　 　i=kのときは、j<l
普通まさしくこれのことだぞ。先頭要素を先に比較して、同じなら残りの要素で比較。
std::lexicographical_compare でも見れ。

(　´_ゝ`)ﾏﾀｰﾘ ｼﾖｳﾖ

>>849
VCやgccでは無理なんですか・・・

>>853
>>847のコードはfooが呼ばれる度に
class A
{
　int foo() {}
　char foo() {}
　：
　：
};
みたいに展開されると思ってたんですが
違うのですか・・・？

>>859 文字列のソートがどうやっているかわかってるなら、それと同じようにすれば
いい。

それはそうですが、それをsortとbool　operatorでできますか、ということです。
一から自分でプログラムしてもいいですが、面倒なので。
あまり自信もないし。


>>860
>頼むから、用語はちゃんと覚えてくれ。あやふやだったらはじめから使うな。

別にあやふやでないです。
辞書式順序というのは、正式な言葉のはず。
ただプログラミングの世界ではないのかも。

> 一番目のデータが同じ時は、
> (1,2),(2,4),(5,4),(5,6)
> のように並び替えたいのです。

>というのは、単に複数キーでソートすると言う。

では複数キーでソートするやり方を教えてください。
できればsortのような組み込みのアルゴリズムを使ってもらえると助かります。

>>867
class A
{
template< class T > T foo(){}
};
は

class A
{
　template<> int foo<int>(){}
　template<> char foo<char>(){}
};

って展開されると思う。

>>868
できるでしょ
bool operrator < で lexicographical_compare つかって sort に突っ込めば？
自分でコーディングする部分なんてほとんど無いよ

探し方があまいのか結局分かりませんでした。
誰かヒントだけでも…

>>871
テンプレートはそういうものだと思ってあきらめましょう。。。

>>871
exportキーワードをまともにサポートしている処理系でないと、
テンプレートの宣言と実体を分けて書くことはできない。

template<class T> ＜ ん？ T はintかよしよし分かった。。。ん？A()はどこ行った？
struct A
{
A();
};

一方その頃 cpp では。。。

ファイル：a.cpp
template<class T> ＜ おーい、俺はどうしたら良いんだよ〜、なんか不安になってきたよ。。
A<T>::A()
{
}

>>860の恥の上塗りには笑った

>>868
コンテナの比較は辞書式だから固定長ならboost::arrayでも使えば？

>>872-874
どうもありがとうございます。
いままでコンストラクタのところでしかエラーが出てなかったんで、
コンストラクタさえどうにかなれば可能だろうと考えていましたが、
今テストしてみた結果、実体作るとやっぱりメンバー関数も無理だと
言うことが分かりました。
確かにa.cppの型を解決する方法が無いですもんね…。
（いままでコンパイラが勝手に解釈してくれてるのとばかり…）
素直にあきらめることにします。

exportをサポートしてる処理系ってComeau以外にある？

そういえば…Comeauのネット上の試用コンパイラ（？）は
template <template <class> class Container> class HogeにSTLのコンテナを渡せなかったなぁ。
（→試してないけど、template <template <class, class> class Container>になら渡せそうだった。）
これって普通？VC,BCC,gcc,+STLPortだと文句言わずにコンパイルしてくれるんだけど。

>>862
もし、テンプレート引数 T に渡す型とかがいくつかに限定されているなら、
それらを a.cpp で明示的にインスタンス化するという手は使えるけど。
template A<int>;
template A<char*>;
とか。

STLのイタレータの継承の一般的な仕方がわかりません.

コンテナのbegin,endの代入も苦しいし,
algorithmライブラリを使えるようにするのも苦しい.
_Rb_tree_iterator<...>とか書かないとうまい事いかない
もんなんでしょーか?
_Rb_...とか書くと移植性0になりそうなので,
幸せになれる方法を教えてください.

>>880
C++標準ライブラリP285〜、§7.5.2「ユーザー定義の反復子」に詳しいです。

class MyIterator
: public std::iterator<std::bidirectional_iterator_tag, type> {
...
};

>>879
その方法>>877書いた直後に思いついたんですけど、
明示的に宣言出来るところがないんですよ。
テンプレート使ってるコードは全部ヘッダに詰め込むのが基本なんですかね？？

>>881
その本持ってますが,そこではコンストラクタで
コンテナを受け取るという事をやっていて,
コンテナのbeginメンバ関数からの代入は扱ってません.

>>883
boost::iterator_adapter

>>882
template A<int>; って書き方は、どこででもできると思うけど。
別にオブジェクトとか関数とかを定義しているわけでもないし。

CかC++かどっちか判断できなかったので
こちらで質問させていただきます。
VBから呼び出し可能なDLLを作成しています。
調べていく上でエクスポートの方法は
__declspecでのエクスポートではなく
Defファイルへの記述でのエクスポートが必要ということが分かりました。
それで質問というのはDefファイルっていうのは
Func @1
というような記述をしますよね？
そこでClass CTestのメンバ関数GetFileNameを記述するには
どう記述したらいいでしょうか？
適当に書いてみても駄目でした。
文法的にどういう風に｢クラスののメンバ関数｣のGetFileName
ということを書いたらいいのかわかりません。
教えていただけませんか？
よろしくお願いします。

>>886
VC++スレってなかったかな・・・

VBからC++のクラスを直には呼べないよ。ActiveX(COM)にするしかない。
呼べるのはCの関数形式のもの。これのやりかたはFAQなので省略。

>887
え、defファイル自体VCの話しだったんですね、
スレ違いですね、失礼しました。

Comにしなきゃだめなんですね、
わかりました、ありがとうございます。
ではVBの話しは別にして、
defファイルでクラスごと、または
クラスのメンバ関数のエクスポートの記述方法だけでも
教えてもらえませんでしょうか？
もう半年くらいわからなくて半分以上放置になってる
悩み事なんです。
これで消えますのでよろしくお願いします。

>>888
普通はDEFファイルを書く必要はないが、
どうしてもDEFでやりたいなら・・・。

DEFファイルではクラスごとエクスポートすることはできない。
メンバごとにエクスポートする必要がある。

例えば、こういうクラスAがあったとすると、

　class A {
　public:
　　A();
　　int a(int, char*);
　};

DEFファイルにはこのように書く。

　EXPORTS
　　??0A@@QAE@XZ @1 NONAME
　　?a@A@@QAEHHPAD@Z @2 NONAME

装飾名はMAPファイルで確認すること。@ordinalとNONAMEは
なくても構わない。

Chain of responsibilityパターンみたいな、階層構造を表現するために
親へのイテレータをsecondに持ったマップのようなモノを使いたいのですが
既存のライブラリにそういうモノって無いでしょうか？

要求としては、
・"文字列"と"親を指すイテレータ"を格納できる
・マップ中のある要素に"格納してある文字列"でアクセスできる
・そしてその要素から親まで順番にたどりつつ
・さらに現在の要素に格納されている文字列を参照できる

イメージとしては
　map<string, iterator> chainmap;
のような感じで、例えば
Ａ ─ Ｂ ┬ Ｃ ─ Ｅ
　　　 　 └ Ｄ ┬ Ｆ
　　　　　 　 　 └ Ｇ
という階層構造にしたとして、
　chainmap["D"].PrintUpToParent();
とかすると
　for (it = *chainmap["D"]; it != chainmap.end(); it = it->second)
　　cout << it->first << endl;
みたいな処理をしたいのです

あう・・・>>890の出力結果を
D
B
A
にしたいという事です・・・

自作のクラスをｆｏｒ文使って配列に入れたいのですが、方法が分かりません。
要するに自作クラスのポインタをスタックに入れる処理がしたいのです。
よろしくお願いします。

class Jisaku { /*definition*/ };

Jisaku* jien[N];
for(int i=0; i<N; i++) {
　jien[i] = new Jisaku();
}

>>892
std::vector< boost::shared_ptr<Jisaku> > jien;
jien.assign( N, new Jisaku );

>>893
最後の()は不要

スタックに、か。忘れてくれ。

>>894
もしかして普段から()省いてますか？

ハイパーカード？

>>894
それってjienいっぱいに同じインスタンスが敷き詰められるんじゃ・・・

class FileWrapper
{
　ofstream* FileHandle;
public:
　FileWrapper(const char* fname) { FileHandle = new ofstream(fname, ios::out | ios::trunc); }
　~FileWrapper()　　　　　 　 　 　 　 { delete FileHandle; }

　FileWrapper& operator <<(ostream& (*pf)(ostream&)) { *FileHandle << pf; }
　template<class T> FileWrapper& operator <<(T arg)　　　　　　　 { *FileHandle << arg; }
};

int main()
{
　// 処理Ａ /////////////////////////////////////////////////////////
　FileWrapper* FileStream = new FileWrapper("testA.txt");
　boost::timer t;
　for (int i = 1; i <= 10000; ++i) {
　　*FileStream << i << ",";
　}
　*FileStream << "\nElapsed time " << t1.elapsed() << " sec." << endl;
　delete FileStream;

　// 処理Ｂ /////////////////////////////////////////////////////////
　ofstream* FileHandle = new ofstream("testB.log", ios::out | ios::trunc);
　timer t2;
　for (int i = 1; i <= 10000; ++i) {
　　*FileHandle << "no " << i << "," << flush;
　}
　*FileHandle << "\nelapsed time " << t2.elapsed() << " sec." << endl;
　delete FileHandle;
}

環境　Win98SE PenIV1.8GHz DDR512MB
コンパイル BCC5.5.1

で、なぜか処理Ａにかかった時間が平均約0.05秒に対し
処理Ｂにかかった時間が平均約0.5秒・・・その差なんと１０倍

直打ちよりテンプレート化したほうが速いって一体どういう事ですか？

処理順で（boost::timerあたりに）何か違いがあるかもと思って
上下入れ替えてみても、結果はかわりませんでした

処理Ｂのコード間違えた・・・
　boost::timer t2;
　for (int i = 1; i <= 10000; ++i) {
　　*FileHandle << i << ",";
　}
　*FileHandle << "\nelapsed time " << t2.elapsed() << " sec." << endl;
です

＞　FileWrapper& operator <<(ostream& (*pf)(ostream&)) { *FileHandle << pf; }
BCCは、こういうコードを通すのか、、、、return *this;を追加。

bcc:
Elapsed time 0.231 sec.
elapsed time 0.22 sec.
vc6:
　Elapsed time 0.1 sec.
elapsed time 0.1 sec.

何でコンパイルするとそのコードが動くの？

ああ、bccですか、失礼

flushこれの違いだけだね

そりゃflushしまくれば遅くなるだろうなあ・・・

心底つまらない事実だったな。

class A
{
　operator bool() { return false; }
};

int main()
{
　if (A()) return -1;
　/* Do something */
　return 0;
}

とあった場合、mainで呼び出されたAは
return 0;以降でデストラクトされると保証されますか？

if文が終わった時点でデストラクトされるっしょ

多倍長整数のよかライブラリ（ソースアリ）ってないっすかね。フリーで‥

>>909
実は、多重起動を抑止するために
以下のような仕組みを考えてみたのですが、
なんとこれがうまく動いてしまっているんです。
環境依存の恐るべきコードですか？

class ImNotOriginal
{
public:
　ImNotOriginal()
　{
　　hMutex = CreateMutex(NULL, TRUE, "このアプリケーションの名前");
　}
　~ImNotOriginal()
　{
　　ReleaseMutex(hMutex);
　}
　operator bool()
　{
　　return (WaitForSingleObject(hMutex, 0) == WAIT_TIMEOUT);
　}
private:
　HANDLE hMutex;
};

int main()
{
　if ( ImNotOriginal() ) return -1;
　/* 何やらかんやら */
}

>>911
そのロジックでは、本当は重複起動を防止できない。

実際に重複起動を防止できてしまうのは、デストラクタが呼ばれないのではなく、
最初に起動したプロセスが CreateMutex() と WaitForSingleObject() で
ミューテックス所有権を 2 つ獲得してしまっている為に、ReleaseMutex() を
2 回呼ばないとミューテックスを解放できないからだ。

WaitForSingleObject() はミューテックスが誰かに所有されているかを確認する
だけでなく、誰も所有していなかったら所有権を獲得してくる。
誰かが所有している場合、その所有しているスレッドが WaitForSingleObject() を
呼んだスレッド自身であった場合は、ロックされずに所有権をもう 1 つ獲得してくる。

ロックされないのは単独スレッドによるデッドロックを防ぐため、所有権をもう 1 つ
獲得してくるのは排他処理の帳尻を合わせるため （処理 A、B で排他が必要な時、
B が終わっていないのに A で排他が終了しただけで B が突入可能になるのはまずい
だろう？）。

ミューテックス所有権の獲得と放棄は必ず 1 対 1 で対応させること、その際
WaitFor*Object() 系 API の取り扱いには十分注意すること。

ミューテックスで重複起動を防止する場合は通常、WaitForSingleObject() を呼ぶ
のではなく、CreateMutex() 直後で GetLastError() の戻り値が ERROR_ALREADY_EXISTS
であるかどうかを調べる。

>>912
詳しい説明ありがとうございました

では質問を変えて、operator bool()の実装を
return (GetLastError() == ERROR_ALREADY_EXISTS)
にした場合、コンストラクタ→operator bool()と呼ばれる保証はありますでしょうか？

つまりプロセス終了時にミューテックスが自動的に解法されることを利用して

class ImNotOriginal
{
public:
　ImNotOriginal()
　{
　　HANDLE hMutex = CreateMutex(NULL, FALSE, "このアプリケーションの名前");
　}
　~ImNotOriginal(){}
　operator bool()
　{
　　return (GetLastError() == ERROR_ALREADY_EXISTS);
　}
};

というコーディングは可能でしょうか？ということです
あ・・・これだとミューテックス生成そのものに失敗してもfalseになっちゃうのかな・・・

我ながら阿呆だ・・・
１度しか呼ばれない事を前提にすれば

class ImNotOriginal
{
public:
　operator bool()
　{
　　HANDLE hMutex = CreateMutex(NULL, FALSE, gc_AppName);
　　DWORD result = GetLastError();
　　return (hMutex == NULL || result == ERROR_ALREADY_EXISTS);
　}
};

これでいいのですね

>>913
if(ImNotOriginal()) はまず ImNotOriginal() が評価され、コンストラクタが
呼ばれる。
次に、if は評価式に bool を要求するので、bool に型キャストされて operator bool()
が呼ばれる。
つまり、望み通りコンストラクタに続けて operator bool() が呼ばれるし、必ずそう動く
ものと見なして良いが、結果そうなるだけで言語レベルで保証しているという訳ではない。

>>915
そこまでひらめいたなら、関数化するべきだ。
クラスである意味は全く無い。

どーでもいーけど CreateMutex() って、lpName が "(ﾟДﾟ)ﾊｧ?" でも "\\" でも
"\r\n" でも "" でも成功するんだよなー。

C++ってjavaとかperlに比べて標準/準標準ライブラリが貧弱すぎると思うんですが
私が知らないだけでしょうか。

libwwwとboostはつかってますがほかになんかいいのないですか？

>>917
loki、common c++ libraryかなぁ…メジャーなのだと(cc++がメジャーかどうかはアレだが)。
欲しい機能に++とかCC付けて検索すると結構APIにヒットしたりするよ。socket++、socketCCとか、
pthreadCCとか。

CやC++は、基本的に「最低限は用意してるから、後は自分で用意しろや」ってスタンスが強いから、
自作するか他人様が作ったライブラリを求めてネットをさまようしかないだろうな。

>>917
ACE, Blitz++, FC++ …などなど。
ライブラリじゃないけどflex/bisonとか。

TRACEってなに？
文字を表示するもの？

>>620
VCのデバッグ窓に文字列を表示・・ジャネーノ？
#二重起動云々はVCスレでやってほしいのう

クラスとその周辺の設計ムズイんだけどー
実用的に汎用にすんのが辛いね。

>>922
激しく汎用化してしまえ。






マジレスするとそういのうは経験が必要だから、とりあえず適当に組むべし。
そのうち慣れるよ。

激しくgenerativeに書け
自分さえも読めない罠にはまって射精するのが漢

UNIXで、socketのselectだけできりゃいいんですけど、BSD系のライセンスで
シンプルなwrapper libraryないですかねえ。MT不要、fork不要、realtime signal なぞぜんぜんいらない。

自分で書けってか。

>>924
コメントぐらい書けってば！

>>926
それじゃ射精できないだろう！

(・∀・) ｵﾅｰﾆ!!

　　　　　∧_∧＿___ ｴｯ
　　　 Σ (*ﾟ−ﾟ)　.／＼
　　／|￣〇〇￣|＼／
　　　 |__しぃ++.__|／
.　　　 ￣￣￣￣

これってどう？

inline string &operator<<(string &Str, char AddStr) { return Str += AddStr; }
inline string &operator<<(string &Str, const char *AddStr) { return Str += AddStr; }
inline string &operator<<(string &Str, string &AddStr) { return Str += AddStr; }

>>929いらん

TC++PL3rdや>>3のFinal Draftにある文法に
member-declaration
　:decl-specifier-seqopt member-declarator-listopt ;
　|function-definition ;opt
　|::opt nested-name-specifier templateopt unqualified-id ;
　|using-declaration
　|template-declaration
　;
という部分がありますが上から三番目は何に使われてますか？

>>930
文法を示されて、一瞬何の事かわからなかった。
すまん、stringは独自クラスではなくてstd::stringなのだが…。k94i
ostreamのように

　str1 << str2 << '(' << str3 << ")";

とかできればいいなと思ったの。
ちなみに上から三番目の第二引数はconst忘れ。

>>931
+=は自分で作れってこと？

ごめん勘違い。

わしの娘であるstringstreamでは不満ということかね？

>>930
住人が同じであるいじょう何度聞いても答えは得られないと思われ
所詮2ちゃんはこの程度かと思いながら他のもっとましなところに行くことをおすすめする

>>935
じつはすでに2chはこの程度かと思っているが、
comp.lang.c++などで聞く気にもなれず自分はこの程度かとも思っている。

>>934
何か大げさだなと思って。

>>937
所詮、平民出のプログラマには、stringのような田舎娘がお似合いということね！

>>938
タカビーな貴族娘に用は無い！

E-mail 設定し直すの忘れたよ・・・938 スマソ。
「Cから見ればstringも充分アレだし」 と書きたかった。

comp.lang.c++も
void main()
で盛り上がってた。

voidﾀﾝは？

ムーテックスってなに？

(´ゞ)←これ

#if abc
#error (・∀・)
#endif

abcと同名のｼﾝﾎﾞﾙは無いはずだけど全ての処理系で通る(falseで)！
大ﾊｹｰﾝ？

つかmankoでもchinkoでも何でもOKっぽよ！？(奇跡)

ぽよ→ぽいよ

>>946
何が。

#ifdef と勘違いしているだけだ


とマジレスしてみるテスト

ポインタ型に対する const 指定の説明なのだが、

例えばポインタ演算 **p の結合規則は右から左なので、(*(*p)) と同じだ。
それと同様に考えればいい。
つまり、char const * p; は char (const (* p)); で、p そのものは変更できるが
*p が指すものは変更できない。
逆に、char * const p; は char (* (const p)); で、p そのものは変更できないが
*p が指すものは変更できる。
そして、char const * const p; は char (const (* (const p))); であり、これは
p そのものも *p が指すものも変更できない。
なお、const char * p; は char const * p; と全く同一である。

でよろしいか？

次スレの予感

>>950
よろしい

>>950
次スレおながい。

>>952
ありがとう。

>>951 >>953
これでいい？

C++相談室 part12
http://pc3.2ch.net/test/read.cgi/tech/1035005882/

次スレの 4・・・あんた速えーよ・・・。

　　まもなくここは　乂千取り合戦場乂　となります。

　 　 　 ＼∧＿ﾍ　　　　　／￣￣￣￣￣￣￣￣￣￣￣￣
　,,､,､,,,　/ ＼〇ノゝ∩ ＜　0x03E8 取り合戦、いくぞｺﾞﾙｧ！！　　　　　　　,,､,､,,,
　　　　/三√ ﾟДﾟ)　/　　 ＼＿＿＿＿＿＿＿＿＿＿＿＿　　,,､,､,,,
　　 　　/三/| ﾟＵﾟ|＼　　　　　　,,､,､,,,　　　　　　　　　　　　　　　　　　　　　　　,,､,､,,,
　,,､,､,,,　Ｕ （:::::::::::）　　,,､,､,,,　　　　　　　　　＼オーーーーーーーッ！！／
　　 　 　//三/|三|＼　　　　　∧＿∧∧＿∧ ∧＿∧∧＿∧∧＿∧∧＿∧
　　　　　　∪　 ∪　　　　　　 （　　　　）　　　 （　　　　 ）　　　（　　　　）　　　 ）
　,,､,､,,,　　　　　　　,,､,､,,,　　∧＿∧∧＿∧∧＿∧ ∧＿∧∧＿∧∧＿∧∧＿∧
　　　　　　,,､,､,,,　　　　　　 （　　　　）　　　 （　　　　）　　　 （　　　　）　　　 （　　　　）

(；ﾟДﾟ)∩　＜ なら俺は01747を取りに逝くぞﾓﾙｧ!

957!!

957+1!

++ 957 ++;

960

957+4!

957+1+1+1+1+1!

BOOST_PP_INC(962);

>>959
コンパイルエラー

long *p = (long *)0x03C0;
p++;
printf("%d", (char *)p + 1);

>>964
注意力が足りなかった

char _[967];
get = sizeof(_);

2*22*22

#include <iostream>

for (int i = 0 ; i < 969 ; ++i) {
std::cout << "(･∀･)ﾏﾝｺ!!" << std::endl;
}

>>969
なに？そのださいプログラムは。

>>970
プログラムというよりただのシークエンスという気がする。
間違いなくコンパイル通らないだろうし。

>>971
ﾏﾗにｵﾏﾝｺｷﾓﾁｲｲ!

throw itteyoshiException(util::make_container<vector, int>() << 969 << 972);

make_containerって何だよ。Java厨の出張?

#include <iostream>

int main(int argc, char** argv)
{
for (int i = 0 ; i < 975 ; ++i) {
std::cout << "(･∀･)ﾃｨﾝﾎﾟ!!" << std::endl;
}

return 0;
}

＿＿＿＿_　
|＼　　　　 ＼　
|　|￣￣￣￣|
|　|　　´∀`　| ヒキコもこもこ引き篭もり〜♪
|　|　 　 鬱　 |
＼|＿＿＿＿| 　
　 人　 Ｙ 　　　
　し （＿） 　　　　

>>976
楽しそうだな

cout<<"CountDown! : "<<1000 - __LINE__<<endl;

http://store.yahoo.co.jp/i879/ys979.html

スマートポインタっていっても下のようにいろいろあるわけだけど、

std::auto_ptr ( Standerd C++ Library )
boost::sheard_ptr ( Boost )
Loki::SmartPtr ( Loki )
YTL::smart_ptr ( Yaneura Game SDK 3rd )

みんなは、どれを一番使ってるよ？
ほかにも、イイのがあったら教えてくれ。

普通はboost::shared_ptr<>, boost::weak_ptr<>, boost::scoped_ptr<> およびその配列版だと思うが。

std::auto_ptrはスマートポインタじゃなかったような気が

>>980

Loki のスマートポインタは、いろいろいじれるから、
趣味や勉強にはいいかも。
個人的には期待大

やねうらお の smart_ptr は、面白いけど、どれだけ使う場面があるかは微妙。


やっぱ Boost か。


　

CComPtrとか書いたらしばかれますか？

fifteen response

YTL::oreno_nikubouwo_sakuratanni_buchikomu_haxahaxa_ptr

the rest: thirteen

早期梅。

今日も梅。

ten

´-`).｡oO(激しく上げちゃった…やばい）

記念ﾊﾟﾋﾟｺV(^o^)V

梅v(^・^)v梅

埋め立て中

記念カキコ

ageちゃったりなんかして

0〜99の数字を1秒間隔で表示。１〜９で改行、表示する
こんな感じです

１　２　３　４　５　６　７　８　９
10　11　12〜〜〜〜〜〜〜〜〜〜〜〜
〜〜〜〜〜〜〜省略〜〜〜〜〜〜〜〜
〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜99

これのプログラムを教えてください
よろしくお願いします

ってもうスレねーーーー

おれ

999ｹﾞｯﾄｽﾞｻﾞｰ

このスレッドは１０００を超えました。
もう書けないので、新しいスレッドを立ててくださいです。。。