【C++】template 統合スレ -- Part6

【C++】template 統合 ..

331:328
05/02/18 21:23:27
>>329
URLﾘﾝｸ(boost.cppll.jp)
の２番目を。

332:デフォルトの名無しさん
05/02/18 23:38:55
>>330
C++ ってそういうもんだよ。人によって用途も違えば、実行環境のリッチさも
天と地ほど違うので。

333:デフォルトの名無しさん
05/02/22 15:00:52
新規にクラスを作るならば、COM のように侵入型の参照ポインタにして、
intrusive_ptr で管理するとか

334:デフォルトの名無しさん
05/02/22 17:27:12
STLかboostあたりに、ある条件を満たすものをoutput_iteratorにコピー
するような関数はないでしょうか?
boost::mplにcopy_ifというそれらしい名前のがあるんですが、
使い方がさっぱりわからない……

335:デフォルトの名無しさん
05/02/22 17:40:29
なぜか　std　に　copy_if　ないんだよね・・・
boost::filter_iterator　と　std::copy　でなんとか汁

336:デフォルトの名無しさん
05/02/22 17:43:19
std::remove_copy_if(first, last, std::not1(pred));

337:336
05/02/22 17:43:58
ごめん。
std::remove_copy_if(first, last, out, std::not1(pred);
だ。

338:デフォルトの名無しさん
05/02/22 18:06:02
今回は元のコンテナを変更したくないのでremove_copy_ifは使えなさそうです。
結局自分で書きました。
自分でforループを書くと頭悪くなったように感じるので、
これくらいstdに入れておいてほしいものです……。

template <class InputIterator, class UnaryFunction, class OutputIterator>
void copy_if(InputIterator begin, InputIterator end,
　　　　　　　　　　　　　OutputIterator result,
　　　　　　　　　　　　　UnaryFunction pred) {
　　　　for ( ; begin != end; ++begin)
　　　　　　　　if (pred(*begin)) {
　　　　　　　　　　　　*result = *begin;
　　　　　　　　　　　　++result;
　　　　　　　　}
}

g++のヘッダを見るとconcept checkとやらを入れたほうがいいらしいのですが、
何を使えばいいのかよくわからんです。boostに道具があるんでしょうか。

remove_copy_ifも説明がよくわからんのですよね。
削除するのに大きさが変わらないってどういうこと?

339:デフォルトの名無しさん
05/02/22 18:06:58
>>338
remove_copy_ifは入力シーケンスを変更しないよ。

340:デフォルトの名無しさん
05/02/22 18:17:58
>>338
return result;

341:一つ賢くなった!
05/02/22 18:32:43
>>339
おお、本当だ。コードを見るとほぼそっくりではないですか。
今までremove_copy_ifは元のを破壊的に変更しつつ、削除したものを
コピーするのだと思っておりました。
名前がミスリーディングだと思うのです……。

>>340
忘れてました。というか気にしてなかったのですが、返すべきですね。

342:デフォルトの名無しさん
05/02/22 19:24:56
struct NURUPO
{
　template<typename T> operator T*() { return 0; }
};

int ILoveNurupo()
{
　NURUPO mynurupo;
　return (int)mynurupo[0];
}

vc7.1とgcc3.3にガッ

343:デフォルトの名無しさん
05/02/22 21:10:19
なんか違わないか？

344:デフォルトの名無しさん
05/02/23 01:38:28
>>338
STLPortには入ってるよ。

345:デフォルトの名無しさん
05/02/24 14:00:35
テンプレートの特殊化ってどこに書きますか？
以下のように特殊化する型の定義と一緒に書くと、

* primary.h

#include <iostream>

template <class T>
inline void foo(const T&) { std::cout << "primary\n"; }

---
* specialized.h

#include "primary.h"

struct bar {};

template <>
inline void foo(const bar&) { std::cout << "specialized\n"; }

---
* troublesome.h

struct bar;

bar& get_bar();

346:345
05/02/24 14:01:58
* troublesome.cpp

#include "specialized.h"

bar& get_bar() { static bar b; return b; }

void trouble1()
{
　foo(get_bar());　　// #1
}

---
* main.cpp

#include "primary.h"
#include "specialized.h"　　// #2
#include "troublesome.h"

int main()
{
　foo(get_bar());
　return 0;
}

---

#1 と #2 をコメントアウトしたりしなかったりで実行結果が変化します。
具体的には #1 と #2 の両方をコメントアウトした場合 primary が出力されます。

かといって、極端な話 STL のヘッダファイルに書き足すわけにもいけませんし・・・。

347:デフォルトの名無しさん
05/02/25 00:39:40
>>345
URLﾘﾝｸ(www.kuzbass.ru)
14.7.3 -6- および -7- で、
使う場所より前に特殊化は宣言されていないといけない、
というルールは書いてあるが、コンパイラによるチェックは不要ということになっている。
あげくに規格中に「宣言の位置には気をつけろ」と書かれている。

primary.h の foo<T> の中でダミーでいいから sizoef(T) を使って、
不完全型ではインスタンス化できないようにしておけば、
いちおうエラーにすることができると思う。

348:デフォルトの名無しさん
05/02/28 11:44:49
template<class T> class A
{
public:
void hoge() { }
void foo() { }
// 他にいろいろなメンバがある
};

というクラステンプレートがあって、プログラム中でA<T>::hogeだけどこからも使われなかったとき
A<T>::hogeのコードは生成されるのでしょうか?

349:デフォルトの名無しさん
05/02/28 12:01:34
>>348
されない。だから定義しなくても大丈夫。

350:デフォルトの名無しさん
05/02/28 19:22:11
>>348
処理系依存

351:デフォルトの名無しさん
05/02/28 21:47:50
>>350
ほんと？

352:デフォルトの名無しさん
05/02/28 22:10:33
一応標準としてはAの暗黙のインスタンス化ではhogeはインスタンス化されません．(14.7.1/1)
ちなみにAの明示的インスタンス化の際にはhogeのインスタンス化が伴います．(14.7.2/7)

353:デフォルトの名無しさん
05/02/28 22:10:41
>350は狼少年

354:デフォルトの名無しさん
05/03/01 22:32:51
>>348
Modarn C++ Designの1.8に、生成されないことを前提にした技法があったな確か。
シンタックス・チェックだけは、実装によっては行われるんだったっけか。

355:デフォルトの名無しさん
05/03/02 01:29:19
Modern ね

356:デフォルトの名無しさん
05/03/02 12:31:04
スマソ

357:デフォルトの名無しさん
05/03/08 02:55:11
AdobeのASLもここでいいんかな?

358:デフォルトの名無しさん
05/03/08 10:23:35
使われているプログラミング技法を語るならここかな
あるいはBoostスレか

359:デフォルトの名無しさん
05/03/09 18:17:53
以下のコードで complex を set に入れようとしたところ、
「stl_function.h:197: error: no match for 'operator<' in '__x < __y'」
とか言われてしまうのですが (g++ 3.3.3)、原因が分かりません。
何がおかしいのでしょうか。

#include <complex>
#include <set>
using namespace std;

bool operator<(const complex<int> &a, const complex<int> &b)
{
return real(a) < real(b) || (real(a) == real(b) && imag(a) < imag(b));
}

int main()
{
set<complex<int> > s;
s.insert(complex<int>(1, 2));
return 0;
}

360:デフォルトの名無しさん
05/03/09 18:39:00
>>359
<set>の中からそのoperator<()が見えていない。しかしoperator<()を
#includeよりも前に持ってくると今度はcomplexが定義されていない。
しかしstd名前空間内部のものを先行宣言することは許されていない。

自分で関数オブジェクトを定義するしかない。

361:デフォルトの名無しさん
05/03/09 18:40:16
namespace　std　{
　　bool　operator<(const　complex<int>　&a,　const　complex<int>　&b)
　　{
　　　　　　return　real(a)　<　real(b)　||　(real(a)　==　real(b)　&&　imag(a)　<　imag(b));
　　}
}
で通ったけど、これってやっていいことだっけ……？

362:デフォルトの名無しさん
05/03/09 18:56:02
>>360
> <set>の中からそのoperator<()が見えていない。
これは関係ない。どうせグローバルのoperator<は使われない。

363:デフォルトの名無しさん
05/03/09 19:00:21
>>361
結論：ダメ
宣言や定義をstd名前空間に加えてはならない。今回の場合、struct
std::less<>の特殊化も考えられるが、後述の規定によりuser-definedな名前で
特殊化しない限りundefined behaviorとなる。

17.4.3.1 Reserved names -1
It is undefined for a C++ program to add declarations or definitions
to namespace std or namespaces within namespace std unless otherwise
specified. A program may add template specializations for any standard
library template to namespace std. Such a specialization (complete or partial)
of a standard library template results in undefined behavior unless
the declaration depends on a user-defined name of external linkage
and unless unless the specialization meets the standard library requirements
for the original template.

364:デフォルトの名無しさん
05/03/09 19:17:37
>>362
#include <set>
using namespace std;
struct hoge{int x;};
bool operator<(const hoge& a, const hoge& b){return a.x < b.x;}
int main(){
　　 set<hoge> s;
　　 s.insert(hoge());
　　 return 0;
}
これ通らない？

365:デフォルトの名無しさん
05/03/09 21:08:49
>364
それはhogeとoperator<が同じ名前空間（グローバル）で定義されているので通りますよ．
std::complexを引数とする呼び出しからoperator<が見えるためには
operator<がstd名前空間で定義されていないといけないです．
でもそのような定義をstd名前空間に追加することは許されないので(>363)，
自分で関数オブジェクトを書いて(>360)それをsetのテンプレート引数に与えるしかないです．

366:デフォルトの名無しさん
05/03/09 21:12:46
で、結局こう、と。

#include　<complex>
#include　<set>
using　namespace　std;

template　<typename　T>
struct　complex_less:　binary_function<complex<T>,　complex<T>,　bool>　{
　　bool　operator()　(const　complex<T>&　a,　const　complex<T>&　b)　{
　　　　return　real(a)　<　real(b)　||　(real(a)　==　real(b)　&&　imag(a)　<　imag(b));
　　}
};

int　main　()　{
　　set<　complex<int>,　complex_less<int>　>　s;
　　s.insert(complex<int>(1,　2));
　　return　0;
}

367:359
05/03/09 21:25:39
>>360-366
皆さんありがとうございます。よく分かりました。
ちゃんと勉強しないとダメだなぁ～ orz

368:デフォルトの名無しさん
05/03/09 21:55:23
string とか　pair が std 名前空間に operator < を定義しているから
ADL のせいで operator < を std 名前空間の外に探しに行かないという認識であってますか？

369:デフォルトの名無しさん
05/03/09 22:09:23
↑俺には断言できん

↓あってるのか？

370:デフォルトの名無しさん
05/03/09 22:11:50
あってる。

371:369
05/03/09 23:24:46
>>368
あってるぞ。

よし、俺ツーポイントゲット。

372:デフォルトの名無しさん
05/03/10 04:08:30
その為に less がテンプレート引数になってるんではないのか。

…と、こないだ初めて map で less を使った俺が言いました。

373:デフォルトの名無しさん
05/03/11 02:09:30
練習で push_back_if なるものを書いてみたのですが
駄目だしお願いします。

template <typename IIte, typename Container, typename Pred>
void push_back_if(IIte b, IIte e, Container &c, const Pred p)
{
for(;b!=e;b++)
{
if(p(*b)) c.push_back(*b);
}
}

insert_if とか copy_if ってないんですか？
あったら便利だと思うのですが・・・。

374:デフォルトの名無しさん
05/03/11 02:24:34
copy_ifはある。あとはback_inserterを組み合わせて使えばよし。

375:デフォルトの名無しさん
05/03/11 02:27:17
> copy_ifはある。

ウソだった。標準ではない。すまん。

376:デフォルトの名無しさん
05/03/11 02:36:13
>>373
残念ながらcopy_ifは標準にはない。どっかに作っておいたら？
//copy_if
template <typename InputIterator,
　　　　　 typename OutputIterator,
　　　　　 typename Predicate>
inline
OutputIterator
copy_if(InputIterator　 begin,
　　　　 InputIterator　 end,
　　　　 OutputIterator destBegin,
　　　　 Predicate　　　 p)
{
　　 while (begin != end)
　　 {
　　　　 if (p(*begin)) *destBegin = *begin;
　　　　 ++destBegin;
　　　　 ++begin;
　　 }
　　 return destBegin;
}

377:デフォルトの名無しさん
05/03/11 16:52:41
>>373
> for(;b!=e;b++)
++bにしたほうがいい。

378:デフォルトの名無しさん
05/03/11 19:43:05
>377
また荒れるようなことを

379:デフォルトの名無しさん
05/03/11 20:28:43
いやいや荒れるまでもなく当たり前の事ですよ

380:373
05/03/11 21:26:10
>>374-379
レスが遅くなってすいません。参考にします。

381:デフォルトの名無しさん
05/03/13 00:46:27
荒れてもいいから理由を教えろ

382:デフォルトの名無しさん
05/03/13 01:27:48
>>381
後置インクリメントだと、一時オブジェクトが必要になるから。
POD型の場合でもレジスタを余計に必要としたりね。
#それが理由で後置インクリメントを持たないクラスも作ることも多いし。

383:デフォルトの名無しさん
05/03/13 01:32:28
C++より++C

384:デフォルトの名無しさん
05/03/13 01:50:07
> POD型の場合でもレジスタを余計に必要としたりね。

は？

385:デフォルトの名無しさん
05/03/13 03:26:57
今 typeof が使えるコンパイラって g++, icc の他にどんなのがある？
typeofなんてぶっちゃけ template つかってないと殆ど使わんだろうしここでいいよね。

386:デフォルトの名無しさん
05/03/13 09:54:26
RTTIとテンプレートはあまり関係ないだろうと思いつつ、
ほとんどのメジャーなコンパイラは扱えますよ。

387:デフォルトの名無しさん
05/03/13 09:57:05
typeidじゃないよ。

388:デフォルトの名無しさん
05/03/13 12:31:23
メジャーじゃないコンパイラは"ほとんど"に含まれない言葉のトリック

389:デフォルトの名無しさん
05/03/13 13:47:16
そういうもんだいではない

390:デフォルトの名無しさん
05/03/13 17:59:47
#define FOR_EACH(RANGE, ITERATOR) \\
for(boost::range_iterator::< typeof(RANGE) >::type ITERATOR \\
　　　　　　= boost::begin(RANGE); \\
　　　　ITERATOR != boost::end(RANGE); \\
　　　　++ITERATOR)

int a[3] = {1, 2, 3};
FOR_EACH(a, it){
　　cout << *it << endl;
}

391:デフォルトの名無しさん
05/03/13 18:00:22
struct plus
{
　　template<class LHS, class RHS>
　　typeof(l + r) operator()(LHS const &lhs, RHS const &rhs) const{
　　　　return lhs + rhs;
　　}

private:
　　LHS l;
　　RHS r;
};

392:デフォルトの名無しさん
05/03/13 18:15:58
391間違えました．スレ汚してすいません

template<LHS, RHS>
struct plus_result{
　　typedef typeof(l + r) type;
private:
　　LHS l;
　　RHS r;
};

struct plus
{
　　template<class LHS, class RHS>
　　typename plus_result<LHS, RHS>::type operator()(
　　　　LHS const &lhs, RHS const &rhs) const
　　{ return lhs + rhs; }
};

393:デフォルトの名無しさん
05/03/13 18:17:47
typeof って何で標準に入る予定ないの？

394:デフォルトの名無しさん
05/03/13 18:21:14
最初からplus_resultのとこにtypeofを書けばいいような？

395:デフォルトの名無しさん
05/03/13 20:16:10
>>393
そんなこと誰が言ったんだ？

396:デフォルトの名無しさん
05/03/13 22:50:55
条件Aに適合する場合にBを適用するという意味で
apply_if を書いてみたのですが、駄目だしをお願いします。

　　template <typename IIte, typename CheckPred, typename ApplyPred>
　　　　void apply_if(IIte begin, IIte end, CheckPred check, ApplyPred apply)
　　{
　　　　for(;begin!=end;++begin)
　　　　{
　　　　　　if(check(*begin)) apply(*begin);
　　　　}
　　}

397:デフォルトの名無しさん
05/03/13 23:18:26
>>396
じゃ遠慮なく。
・名前の省略するな。（×IIte → ○InputIterator）
・Pred は predicate（述語）の略なので、 bool を返す関数以外には使うな。（×ApplyPred → ○UnaryFunction）
・*begin が繰り返されているのは良くない。
・std::for_each() に倣って UnaryFunction を戻り値としたほうがいいかもしれない。

398:デフォルトの名無しさん
05/03/14 00:29:28
>>397
細かいことを言えば、
InputIterator に　apply はまずい。
InputOutputIterator じゃ長いけど。

399:デフォルトの名無しさん
05/03/14 01:03:01
とりあえず試しに Visual C++ Toolkit 2003 を使ってみたけど、
typeof() は使えない模様。__typeof とかなんかあったりするのかな？

400:デフォルトの名無しさん
05/03/14 01:06:34
>>398
イテレータのコンセプトを表すという意味で InputOutputIterator はありえない。
出力も兼ねると言うことなら、現行の規格では ForwardIterator が候補になるだろう。
しかしここも std::for_each() に倣って InputIterator とするのが正解だろう。

401:デフォルトの名無しさん
05/03/14 01:13:19
なんなんだよ、typeof()って？
初めて聞いたぞ。

type_infoクラスとtypeid演算子ならC++にあるけど、
typeof()は何をするためのもの？

402:デフォルトの名無しさん
05/03/14 01:21:18
>>401
まず最初に言っておくと、typeofは今のところまだ標準には無い。
で、まぁ名前の如く変数の型を得る演算子(?)の事。
Type a;
typeof(a) b = a;
みたいに使える。
この例では a の型が分かってるけど、Expression Template なんかの場合はどえらい事になっちゃうっしょ。
って分かりにくいかなぁ。誰か分かりやすい例キボンヌ。

403:デフォルトの名無しさん
05/03/14 01:27:44
その程度だとtypeid, type_infoとどう使い方が違うのか見えんな。

404:デフォルトの名無しさん
05/03/14 01:29:18
テンプレート宣言の
template<typename　HOGE>
を適宜、
template<typename　HOGE,　typename　PLUS_TYPE>
にすれば回避できるんじゃないの？
曖昧さの解決にもなるし。

というか、C++とtypeof()は相性が最悪な気がする。
多重継承さえ嫌がる人が多いというのに、
typeof()は、無駄にデバッグ作業を増やさせるだけではないか？

405:デフォルトの名無しさん
05/03/14 01:31:35
>>400
ForwardIteratorが正しいね。
しかし、InputIterator で要素の変更を行うのは論外では？
for_each()は変更を伴わない関数。
本質的に違う関数に倣うという理由付けも理解に苦しむ。

406:デフォルトの名無しさん
05/03/14 02:01:52
>>405
std::for_each() で要素の変更は許される方向にあるらしい。
URLﾘﾝｸ(www.open-std.org)

「いまさら禁止されては困る」という本音が多分にあるだろうと思うので、
明示的に許可を後付けされてもすっきりしないよな。
はっきりと Mutating algorithm に移動させて欲しい。

407:デフォルトの名無しさん
05/03/14 08:46:06
>>403
オマエの目は節穴なのでしょうか？

408:402
05/03/14 11:23:16
>>403
うーん、例が悪いでしょうかねぇ。ただ、typeidと決定的に違うのが、
「コンパイルタイムに決まる」、という事。
んだから、「謎の型を宣言、定義可能」って事なんですけどね。
明日から海外飛ぶんで誰かフォローよろ。

409:デフォルトの名無しさん
05/03/14 12:32:23
俺も来週から地方飛ばされるんで
誰か助けてくれ

410:デフォルトの名無しさん
05/03/14 12:37:00
俺はneetなんである意味助けてくれ

411:デフォルトの名無しさん
05/03/14 12:37:50
>>408,409
そのままキャッチされない例外に飛ばされて人生の強制終了。

412:デフォルトの名無しさん
05/03/14 12:43:12
C++よりMLの方がいいよ。

413:デフォルトの名無しさん
05/03/14 12:45:00
メーリングリスト

414:396
05/03/14 23:32:14
>>397,398,400,401,405,406
参考にしたいと思います。ありがとうございます。

415:デフォルトの名無しさん
05/03/15 00:04:29
C++よりMLの方がいいよ。

416:デフォルトの名無しさん
05/03/15 00:16:03
>>412
>>415
利点をあげてくれ、なにがいいのかわからん

417:デフォルトの名無しさん
05/03/15 00:47:28
このスレが不要になるぐらい明快

418:デフォルトの名無しさん
05/03/16 07:47:07
そうか、typeofはgccとintel以外じゃ使えないのか。

クラス階層のメンバを辿るときとか便利なんだよな。
node->get_parent()->get_view() とかで参照をとるとき、一回だけだと
その場に書くけど長いと面倒なので何か別名を割り当てるためだけに
ローカル変数に代入するわけだ。
そういうとき、
#define LET(var,exp) typeof(exp) var = (exp)
とかすると
VeryVeryLongClassName parent_view = node->get_parent()->get_view();
のかわりに
LET(panent_view, node->get_parent()->get_view());
と書ける。非常にラクチン。

boostのlambdaみたいにすればtypeofなしでも同じようなことができるかも。

419:デフォルトの名無しさん
05/03/16 08:08:57
>>418
boost spirit typeof

420:418
05/03/16 09:26:00
どうもboostの定義をみてるとMetrowerksにもtypeofがあるようだ。
んで、typeofのテンプレートによる実装もあるみたいだね。

URLﾘﾝｸ(aspn.activestate.com)
boostのsandboxにtypeofの実装があるらしい

URLﾘﾝｸ(aspn.activestate.com)
Code Projectの記事。typeofのVC7用実装。
これによるとboost::mplにも

BOOST_MPL_AUX_REGISTER_TYPE(123, abc);
abc aa1;
BOOST_MPL_AUX_TYPEOF(_, aa1) *aa2 = &aa1;

というtypeofがあるらしいがundocumentedだのuglyだの不便だのと切って捨てている。

>>419
? よくわからんちん。

421:デフォルトの名無しさん
05/03/16 15:39:09
>>420
URLﾘﾝｸ(boost.cppll.jp)

typeofはレビュー待ちの状態だと以前読んだ希ガス

422:デフォルトの名無しさん
05/03/16 16:23:33
>>420
Metrowerks CodeWarriorでの話。
__typeof__()演算子があって、これは常に使える。typeof()演算子を使うには
#pragma gcc_extensions onとする必要がある。こうすると、以下のGNU Cの言語
拡張機能を利用します。
・auto変数の構造体、または配列を、定数以外の値で初期化することを許可します。
・sizeof( void ) == 1
・sizeof( function-type ) == 1
・評価式の内部のGCCステートメントと宣言を、制限付きでサポートします。
・#undefがその前にないマクロの再定義。
・GCCのtypeofキーワード。

423:デフォルトの名無しさん
05/03/17 09:40:37
>418
＞boostのlambdaみたいにすればtypeofなしでも同じようなことができるかも。
逆だと思いますよ．lambdaも状況は似たようなもので
むしろlambdaもtypeofがあればいろいろうれしいです．

でもboostのtypeofの実装はさすがにやりすぎな気が・・・
そもそもtypeofの機能をライブラリで提供する/できるというのが異常というか

424:418
05/03/17 10:10:08
420のCode Projectの方のリンクが寝惚けてました^^; 正しいのはこっち。
URLﾘﾝｸ(www.codeproject.com)

>>421
すいません、あいかわらずよくわかりません。subruleが普通のコードでも使え
るってこと? 数字を手で入れる必要があるのは面倒なような……。

>>422
補足サンクスです。そうそう、__typeof__でした。
そうか、MetrowerksはGCC拡張を一部サポートするんですね。

425:デフォルトの名無しさん
05/03/25 00:52:31
gcc 3.4のバグだろうか。
テンプレート関数の中で

boost::mpl::identity<typeof(foo->get_bar())>::type bar;

と変数を定義しようとすると何故か
expected `;' before "bar"
というエラーになる。

普通の関数の中なら問題なく通るのだけど。

426:デフォルトの名無しさん
05/03/25 00:58:26
>>425 typname

427:デフォルトの名無しさん
05/03/25 02:26:51
>>426
サンクス。
typenameは試したはずなんだけど……と思いつつやってみると
コンパイル通りました。吊ってきます。

428:デフォルトの名無しさん
05/03/30 01:09:51
Boost.Serialization の
#include <boost/serialization/shared_ptr.hpp>
にある
#define private public
#include <boost/shared_ptr.hpp>
#undef private
って、shared_ptr の方を変更してもらえないんですかね？

別のスレッドで Boost.Serialization を教えてもらったんですけど、
これが、ちょっと気になります……。

429:デフォルトの名無しさん
05/03/30 01:17:26
変更して貰えるわけないだろ、氏ね(ここまで一筆書き)

430:428
05/03/30 02:21:20
>>429
Boost 同士ということで friend にしてもらうくらいなら、
と思ったんですが、直接には関係しない物のために変更するのは、
やっぱり無理ですよね。

431:デフォルトの名無しさん
05/03/30 04:00:47
そういうのはここで訊くよりboostのメーリングリストを検索した方がいいのでは。

432:428
05/03/30 05:05:42
>>431
読んでも分からなさそうと言う事で避けてました。すみません。

で、検索してみたら、そのままの議論がありました。
が、やっぱり分かりませんでした。orz

ただ使うだけにします。ありがとうございました。

433:デフォルトの名無しさん
05/03/30 05:40:36
そういう場合はスレッドのURLとか貼っておくといいかもね。

434:デフォルトの名無しさん
05/03/30 13:22:32
Serializetionがオブジェクトを覗き見しなきゃいけないことを>>428は理解してないのか?
shared_ptrの方で変えたら、通常利用で保護出来ないじゃないか。

435:デフォルトの名無しさん
05/03/30 13:57:46
>>434
>>430

436:ヽ(´ー`)ノ ◆.ogCuANUcE
05/03/30 18:14:32
これかな？
URLﾘﾝｸ(lists.boost.org)

437:428
05/03/31 11:07:00
>>436
それです。
shared_ptr の人も交えて、実装に立ち入った問題点などが議論されていて、
日頃使っているだけの私では、良く分かりませんでした。

438:ヽ(´ー`)ノ ◆.ogCuANUcE
int 2ch ＝05/04/01(金) 20:35:21
>>437
つか、Thread Index で変なとこに飛ばされて、
議論が追っかけずらいんだよね(´･ω･`)

439:デフォルトの名無しさん
int 2ch ＝05/04/01(金) 23:10:42
>>438
URLﾘﾝｸ(thread.gmane.org)

440:デフォルトの名無しさん
05/04/10 19:16:42
Spiritのアクションってなんで２引数必要なの？
値を代入したい時は冗長になるぅ...

expr = (str_p(L"１"))[boost::lambda::_1,boost::lambda::_2,data=1];

441:デフォルトの名無しさん
05/04/12 10:09:35
template<class T> class A
{
public:
A(const A&); // 引数
A func() // 返り値
{
A a; // 自動変数
return a;
}
};

クラステンプレートで上記のコメントのところのように
Aとだけ書いた場合A<T>と同じ意味になる、という解釈は正しいですか?

442:デフォルトの名無しさん
05/04/12 10:39:06
>>441
正しいです。
URLﾘﾝｸ(www.kuzbass.ru)

443:441
05/04/12 11:09:04
>>442
ありがとう。よくわかりました。

444:デフォルトの名無しさん
05/04/22 04:23:40
鬼車みたいに
マルチバイトで正規表現使えると速度面では有利なのかな？

ワイド文字で
System.Text.RegularExpressions(C#)
boost::wregex
boost::expressive
boost::spirit
試してみたけど敵わなかった...

鬼車>>C#>=boost::wregex>>expressive>>>>>>spirit

445:444
05/04/22 04:52:13
>>444
spiritのパーサの型がわからんかったんで
毎回生成してたは...道理で遅いはずや...
typeid(parser).name()で出力された型にparser保存してループ回したら
鬼車=spiritになったわ...
逝ってくる...

446:デフォルトの名無しさん
05/04/22 21:22:11
CommonLispの正規表現が最速

447:デフォルトの名無しさん
05/04/22 23:32:46
>>445
当たり前だ。C++が遅かったら、コンパイラ言語を使って正規表現を扱う意味が
ないやんけ。

448:デフォルトの名無しさん
05/04/23 01:11:14
コンパイラ言語?
式テンプレートを使ったメタプログラミングのこと?

449:デフォルトの名無しさん
05/04/23 09:45:54
インタプリタ言語と比較してるだけっしょ

450:デフォルトの名無しさん
05/04/23 10:03:21
またなんかミクロな揚げ足取りしてるんだろうね、きっとｗ

451:デフォルトの名無しさん
05/04/23 10:19:30
>>448
友達いないでしょ。

452:デフォルトの名無しさん
05/04/23 10:23:08
>>448
どういう風に表現すれば一番適切なのか教えて。

>>450-451
おまえらはどうでも良い。

453:デフォルトの名無しさん
05/04/23 10:31:09
言い負けるのが余程悔しいんだろうな。
リアルな世界では気の強さが災いして、友達どころか彼女もいないと思われる。
家族にも総スカン。

454:デフォルトの名無しさん
05/04/23 10:32:56
>>453
どうしてそういう返事をつけるのかな?
普段よっぽど抑圧されてるのか? もっと自分を愛そうね。

455:デフォルトの名無しさん
05/04/23 10:36:57
スレタイ嫁

456:デフォルトの名無しさん
05/04/23 10:51:39
>>447は、C++のコードをコンパイルして実行から速いと言っているのか、
汎用のDFSマシンじゃなくて、式テンプレートを使ったメタプログラミングで、
専用レクサーを生成して実行しているから速いと言っているのか、
どっちなんだ? 両方か?

457:デフォルトの名無しさん
05/04/23 17:26:58
>>456
真性のアフォ？

458:デフォルトの名無しさん
05/04/24 04:51:27
GCC 4.0.0 に TR1 が来ましたね。うれしい。
ソースは boost のごちゃごちゃしたコンパイラ分岐が無くなった分、
だいぶすっきりした印象

459:445
05/04/24 10:46:47
spiritの型導出のためにファイル登録型のtypeof作ってみた。
#pragma once

#include<fstream>
#include<string>
#include<typeinfo>

template <typename T> struct id_of{enum {val=1};};
template <int N> struct id_to_type{};
template <> struct id_to_type<1>{};
#include"type_id_dynamic_impl.h"//(初回は空ファイルを用意)

template<typename T> struct sized { char size[id_of<T>::val]; };
template<typename T> sized<T> obj_class_id_helper(const T&);
#define obj_class_id(x) sizeof(obj_class_id_helper(x).size)
#define typeof(x) id_to_type<obj_class_id(x)>::type

460:445
05/04/24 10:47:24
template<typename T> static void make_typeof(const T&,int ID)
{
std::string class_name = (std::string)(typeid(T).name());
for(int i=0;i<class_name.length();i++){
if(class_name[i]==':')class_name[i]=';';
else if(class_name[i]=='<')class_name[i]='(';
else if(class_name[i]=='>')class_name[i]=')';
}
std::string include_filename = "type_id_dynamic_impl_"+class_name+".h";
std::string include_file = "#include\""+include_filename+"\"";
std::fstream fo_d( "type_id_dynamic_impl.h" );
std::string buf;bool check=false;std::istream si(fo_d.rdbuf());
while(std::getline(si,buf))
if( buf==include_file )
check = true;
if(!check)
fo_d << include_file << std::endl;
fo_d.close();
std::ofstream fo( include_filename.c_str() );
fo <<"#pragma once" << std::endl;
fo << "template <> struct id_of< " << typeid(T).name() << " > { enum{ val = " << ID << " }; };" << std::endl;
fo << "template <> struct id_to_type< " << ID << " >{ typedef " << typeid(T).name() << " type; };" << std::endl;
fo.close();
}

461:445
05/04/24 10:49:54
int main()
{
int a=100;
make_typeof(a,1212);//初回に必要
typeof(a) aa=100;//make_typeof実行後に有効
}

462:デフォルトの名無しさん
05/04/25 22:32:41
これってtypeofを使う前にmake_typeofを書いた実行ファイルを走らせないといけないですよね？
実用上かなり使いにくくないですか？

463:445
05/04/26 00:50:17
>>462
それは承知の上、自動で登録できる代償だと思ってる。
でも、type_id_dynamic_impl.hを書き換えるだけにすべきだろうな...
(ファイル大量発生とMAX_PATH超えちゃう問題あるだろうし)
登録してない場合はこんな感じでコード切り替えりゃ済む問題だし、
常用できないという点には同意。
#if if_exist_typeof(a)
typeof(a) aa=100;
#else
make_typeof(a,1212);
#endif

464:デフォルトの名無しさん
05/04/26 00:53:50
BOOST_TYPEOF_REGISTER_TEMPLATEは飾りなんです
偉い人にはそれがわからんのです

465:Lispのマクロテンプレート
05/04/26 01:04:31
俺の話を聴け～♪
五分だけでいい～♪

466:デフォルトの名無しさん
05/05/07 00:44:34
俺しかいない羊羹ﾏﾝ

467:デフォルトの名無しさん
05/05/07 00:47:41
ﾉｼ

468:デフォルトの名無しさん
05/05/08 12:54:43
質問です。
以下の要件を満たす型に対するtemplate class の
特別バージョンを作ろうと考えています。
・任意のContainer
・Container::value_typeがstd::pair
・Container::value_type::first_typeがint
・Container::value_type::second_typeは任意

例えば以下のようなものです。
std::vector<std::pair<int, int> >
std::deque<std::pair<int, char*> >
std::map<int, std::string>

これを実現するのに、どういった記述を行えばよいのでしょうか？

template<typename T> // これが一般の型を対象としたtemplate class である場合
class A {
//...
};

template<typename T, typename U> // ここらの書式は？
class A { // ここは？
// ?????....
};

よろしくお願いします。

469:デフォルトの名無しさん
05/05/08 13:28:55
>>468
↓で map_with_string 以外は成功するみたい。（@ g++ 3.4.1）
そう簡単じゃないな。

#include <utility>

template< typename T >
struct A
{ static bool const is_specialized = false; };

template< template< typename > class ContainerTemplate , typename PairSecond >
struct A< ContainerTemplate< std::pair< int , PairSecond > > >
{ static bool const is_specialized = true; };

#include <vector>
#include <deque>
#include <map>
#include <string>

#include "boost/static_assert.hpp"

typedef std::vector<std::pair<int, int> > vector_with_int;
typedef std::deque<std::pair<int, char*> > deque_with_pchar;
typedef std::map<int, std::string> map_with_string;

BOOST_STATIC_ASSERT( A< vector_with_int >::is_specialized );
BOOST_STATIC_ASSERT( A< deque_with_pchar >::is_specialized );
BOOST_STATIC_ASSERT( A< map_with_string >::is_specialized );

470:468
05/05/08 14:04:40
ありがとうございます。なんか凄い構文ですね…
vector,dequeとmapの特別バージョンを一緒に出来ない件に関しては、
以下のような感じでごまかすことにします。

template <typename T>
struct Base {
// implementation
static bool const is_specialized = true;
};

template < template <typename> class ContainerTemplate,
typename PairSecond>
struct A<ContainerTemplate<std::pair<int, PairSecond> > >
: public Base<A<ContainerTemplate<std::pair<int, PairSecond> > > > {
};

template < template <typename, typename> class ContainerTemplate,
typename PairSecond>
struct A<ContainerTemplate<int, PairSecond> >
: public Base <A<ContainerTemplate<int, PairSecond> > > {
};

471:468
05/05/08 14:56:37
すみません、訂正です。
: public Base<ContainerTemplate<std::pair<int, PairSecond> > >
: public Base<ContainerTemplate<int, PairSecond> >
でした。

472:デフォルトの名無しさん
05/05/08 22:00:30
std::vector<int, MyAlloc>なんかが、特殊化される悪寒ｗ

473:デフォルトの名無しさん
05/05/09 11:32:52
std名前空間のものを
std名前空間のもので特殊化ないし部分特殊化するのは
可能だがやっちゃダメ

474:デフォルトの名無しさん
05/05/09 12:36:59
>>472
MyAlloc どころか普通の std::vector<int> も特殊化される罠

>>473
この場合、特殊化してるのは vector/deque/map じゃなくて
A のほうだから問題ないんじゃないかと思うんだが

475:468
05/05/09 13:06:57
Baseで typedef typename T::value_type::first_type first_type
とか、諸々のstatic_assert置いておけばなんとかなると踏んでたんですが、
やっぱ変でしたかねぇ。

476:468
05/05/09 13:22:32
たびたびすみません、これだとA<std::vector<int> >が作れないや。
勉強して出直します。

477:473
05/05/09 16:30:48
>>474
あ、>>468のvector,deque等の例に対して言ったんです。

478:468
05/05/09 17:44:25
>>473
468では、Aに渡す型の例としてvector,dequeをあげたのであって、
vector,dequeの特別バージョンを作ることを意図したわけではないのです。

479:デフォルトの名無しさん
05/05/09 18:19:20
>468
ユーザ定義型が絡む場合ならば，std::vector等のstd名前空間内のテンプレートを
特殊化することは許されているんですけれどね．

そもそも468は恐らくソート済みシーケンスとstd::mapを汎用に扱おうとする意図だと
思いますけれど，これらは各種メンバ関数の宣言その他もろもろからして違うので
汎用に扱おうとするのはかなり無理がないですか？

480:468
05/05/09 18:44:11
何度もすみません。
>そもそも468は恐らくソート済みシーケンスとstd::mapを汎用に扱おうとする意図だと
>思いますけれど，
その通りです。
>これらは各種メンバ関数の宣言その他もろもろからして違うので
>汎用に扱おうとするのはかなり無理がないですか？
無理がありました(汗いろんなことが出来ませんでした。
とりあえず設計が悪かったということみたいです。

481:デフォルトの名無しさん
05/05/09 18:52:39
>480
それがやりたいならstd::vectorやstd::dequeをラップして
std::mapの要求に合うようにするアダプタ作るのが恐らく最良じゃないかと思います．
それを状況に応じてstd::mapととっかえひっかえする感じで．

482:デフォルトの名無しさん
05/05/10 00:38:29
boostにそんな感じのクラスなかったっけ?
似たようなニーズがあってboostを眺めたらあったので後で余裕があったら使おうと
思いつつ、遅いけどその場はstd::listで済ませたという覚えがある。
そういやその後試してなくてそのままになってるな。

483:デフォルトの名無しさん
05/05/10 00:43:11
multi_index_container

484:デフォルトの名無しさん
05/05/10 00:59:28
>>482
キーと値のアクセスの汎用化、ということなら property_map なんかもそうかな。
あとは boost-sandbox に associative_vector,vector_set なんてのもあるみたいだね。

485:デフォルトの名無しさん
05/05/10 01:05:27
>>480
まあ実用性のことは置いておいて、メタプログラミングのいい勉強になるかな、
と思ってちょっと書いてみた。
ここは BOOST スレじゃないので、敢えて boost::mpl とかは使わず。

template <class T0, class T1>
struct is_same_type {
　static const bool value = false;
};
template <class T>
struct is_same_type<T, T> {
　static const bool value = true;
};

struct sfinae_type {
　typedef char one;
　typedef struct { char arr[2]; } two;
};

template <class T>
struct has_key_type : sfinae_type {
　template <class U> static one test(typename U::key_type*);
　template <class U> static two test(...);
　static const bool value = (sizeof(test<T>(0)) == 1);
};
template <class T>
struct has_value_first_type : sfinae_type {
　template <class U> static one test(typename U::value_type::first_type*);
　template <class U> static two test(...);
　static const bool value = (sizeof(test<T>(0)) == 1);
};

486:デフォルトの名無しさん
05/05/10 01:06:01
template <class T, bool HasKeyType, bool HasValueFirstType>
struct A_specialized_impl {
　static const bool value = false;
};
template <class T, bool HasValueFirstType>
struct A_specialized_impl<T, true, HasValueFirstType> {
　static const bool value =
　　is_same_type<int, typename T::key_type>::value;
};
template <class T>
struct A_specialized_impl<T, false, true> {
　static const bool value =
　　is_same_type<int, typename T::value_type::first_type>::value;
};

template <class T>
struct A_specialized
　: A_specialized_impl<
　　　T,
　　　has_key_type<T>::value,
　　　has_value_first_type<T>::value
　　> {};

template <class T, bool Specialized = A_specialized<T>::value>
struct A { ... }; // 通常版

template <class T>
struct A<T, true> { ... }; // 特殊化版

487:デフォルトの名無しさん
05/05/10 02:23:21
>485
細かいことですけどmapのkey_typeってconstですよ．

SFINAEのこういう使い方はあくまで
「必要条件を満たさないものを振り落とす」ってだけなんですよね．
それにできることが基本的な型特性と内部型の存在のテストくらいだし・・・．
せめてメンバ関数の存在をテストできればもう少し面白いと思うんですけれど．

488:デフォルトの名無しさん
05/05/10 03:24:21
>>487
いや、value_type が pair<const Key, T> なのであって、
key_type は Key のままだよ。
そうでないと一時変数作れないし。

489:デフォルトの名無しさん
05/05/10 09:27:04
>>487
> せめてメンバ関数の存在をテストできればもう少し面白いと思うんですけれど．

typeof(メンバ関数)で何とかなります。

490:デフォルトの名無しさん
05/05/10 10:28:50
>488
マジボケしてました・・・．

>489
何とかなります？typeofってそもそも非標準ですし．

491:ヽ(´ー`)ノ ◆.ogCuANUcE
05/05/10 10:36:09
>>490
まだ sandbox だけど boost::typeof とか。
boost スレかどっかで見たけど、どこだったか忘れた。

492:デフォルトの名無しさん
05/05/10 14:30:49
>>489
これとか見ると、メンバ関数のシグネチャが分かれば
なんとかできそうな気はする
URLﾘﾝｸ(lists.boost.org)

493:デフォルトの名無しさん
05/05/10 22:34:40
>>491
typeofがあってもメンバがなければ単にコンパイルが失敗するだけじゃないですか？

>>492
汎用プログラミングの文脈だと「～～というシグネチャを持ったメンバ関数があるかどうか」というテストより
「～～という構文でメンバ関数が呼び出せるかどうか」というテストの方が重要だと思うので，
そこで使われている技法は少なくとも汎用プログラミングでは非常に使いづらいような気がします．
それにその技法，言語規格的に結構スレスレなことやってるので，GCCではうまく通らなかったり
VC7.1でもうまく機能しないケースがあったり・・・．

494:デフォルトの名無しさん
05/05/11 00:30:14
>>493
> typeofがあってもメンバがなければ単にコンパイルが失敗するだけじゃないですか？

traitsみたいなんじゃ不十分で、条件分岐とかしたいという事?

495:ヽ(´ー`)ノ ◆.ogCuANUcE
05/05/11 10:34:33
>>493
失敗するだけだね。boost::mpl::has_xxx とかで何とかできないかとも思ったが、
寝不足なせいか、頭がこんがらがってきた。

496:デフォルトの名無しさん
05/05/11 19:59:54
>>494
そうです．traitsというよりはintrospectionといったほうが適切ですかね．
traitsはユーザが明示的に特殊化する分，確実ですけれど一方で面倒な側面もあると思うので，
ある程度は要件を自動的にテストしてくれたほうが楽かなという発想です．

>>495
boost::mpl::has_xxxは内部型の存在テストにしか使えないです．

497:デフォルトの名無しさん
05/05/12 00:23:09
>>496
> そうです．traitsというよりはintrospectionといったほうが適切ですかね．

traitsとも違い、
virtual classをinheritしたり、
interfaceをimplementsするのとは違う用途は、
具体的にどういうものを想定しているんですか?

498:デフォルトの名無しさん
05/05/12 03:28:39
>>497
＞具体的にどういうものを想定しているんですか?
いや，あまりろくなことを考えていないんですが，一応，型がどのコンセプトの
モデルなのかを識別するための手段として使えないか，と想定していました．
型がどのコンセプトのモデルであるかを識別できれば，クラステンプレートの特殊化や
汎用関数のオーバーロード選択をより柔軟にできるんじゃないかという考えです．例えば

template<class Iterator, class T>
void replace(Iterator first, Iterator last, T const &x);

という汎用関数があって，TがIteratorの値型に変換可能な型ならstd::replaceの機能で，
TがIteratorの値型を受ける単項述語ならstd::replace_ifの機能といった具合です．
逆に言うと，STLはこのようなコンセプトに基づいたオーバーロード選択の技術がないので
replaceとreplace_ifとに名前を分けざるを得なかった，とも言えると思います．
で，仮に例えばTのoperator()がIteratorの値型で呼び出せるかどうかを
テストできるような実装技術があれば，traitsの明示的な特殊化に頼ることなく
上記のような高度な振り分けができるんじゃないか，という考えです．
ただ，もちろんメンバ関数の存在テストはコンセプトの必要条件を調べられるだけで，
決してコンセプトのモデルであるための十分条件を調べることにはならないのですが・・・．

499:デフォルトの名無しさん
05/05/12 03:29:37
・・・ということを想定していたんですが，

URLﾘﾝｸ(tinyurl.com)

上のような議論を見つけたので読んでみた結果，やはりtraitsの特殊化などで
明示的に表明する方が良いような気がしてきました．より根本的には
言語としてこういうことを直接サポートしてくれればもっとうれしいのですけれど．

URLﾘﾝｸ(www.open-std.org)

次ページ