C++相談室 part80

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

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

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

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

■Books■
amazon.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/


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

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

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

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

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

#include <stdafx.h>
後死ね。

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

　　　　>>1 乙　もう俺に用はない

　　　　ミ　ヽ○ノ
￣￣7　　ヘ/
　　／　 　ノ
　　|
　／
　|
／

テンプレは以上です。

Exceptional C++ 正誤表
http://www.gotw.ca/publications/xc++-errata.htm
http://www.pej-hed.jp/tools/file/download.cgi/1121/Exceptional%20C++%20Errata.htm

C++は全てスタティックリンクでね
ダイナミックリンクなんてしないでね

■長いソースを貼るときはここへ。■
について

ttp://codepad.org/
もいいけど
Ideone.com | Online IDE & Debugging Tool
ttp://ideone.com/
これもなかなか良いよ。

ただ俺はcodepadの方が慣れているしそっち使うけど。

templateクラスの共通する変数とかは非templateにまとめて
それをprivate継承すると実行ファイルのサイズとかコンパイルコストが減るようなんですが
実際そこまでこだわるほどの価値ってありますか？

価値観って人それぞれだよね。

>11
必要になってからやる。
構造の簡素化とか汎用化、一貫性を優先した方が良い。といってもこっちも必要にならなきゃやらんかも。

class Hoge
{
　std::string name;
public:
　const std::string& GetName() const{return name;}
};
ってｸﾗｽがあり、そのｸﾗｽのｲﾝｽﾀﾝｽへのﾎﾟｲﾝﾀを
抱いてるvectorが下記のようにあります。

std::vector＜Hoge*＞ vecString;

このvecStringの中にあるHogeのnameの長さが5以上の数を
C++らしくcount_ifで数えるにはどうなりますか？

http://codepad.org/jexMI50H

>>14
using boost::bind;
std::count_if(vecString.begin(), vecString.end(),
  bind(std::greater_equal<std::string::size_type>(), bind(&std::string::size, bind(&Hoge::GetName, _1)), 5))

>>16
それだとぬるぽの可能性が

C++0xが一番ありがたく思えるシチュエーションかな、こういうのが。

たしかにC++らしいwwww

std::count_if(vecString.begin(), vecString.end(),
[](Hoge* h){return h->GetName().size()>=5;})

あまり楽になった気がしないのは何故だろう

多分、それはコンパイラの気持ちになってパースしてしまうから…

今更だけど、「C++ってコンパイラの気持ち(動作)を良く理解しないと
いけない度合い」が他の言語より相当強いよね。

標準C++の仕様ってのがつまりは"広義のコンパイラ"の動作なわけだけど。

前スレのfriend議論もそうだけど、なかなか強烈な議論だった。

しゃあーない
禿の思惑とは反対方向にC++はどんどん肥大化してしまったからな
PL/Iの二の舞になっとる

std::mapの二分木を巡回しながら各要素に適当な操作をしたいのですが
行きがけ順、帰りがけ順、などを切り替えて巡回する方法って用意されてますか？

マクロ関数

a-> ## b

って記述したいんですけどプリプロセッサエラー
出ちゃうなんとかして困った

そのスペースはなんだい

ｲﾐﾌ

そもそもmapを二分木で実装しなきゃいけないって決まってたっけ？
要素の並び順が規定されてるだけ(ISO の 23.1.2)だから、二分木を想定した方法はないような

#define test(a, b) a-> ## b = 100

C++ってこんなの作れないのかな？
スクリプト言語なら出きるのになんでC++はできないの？

なんでなの？

お前が馬鹿だから

>>29
特殊な技法を駆使すればできるよ

>>29
C++ができないんじゃなくてお前の頭じゃできないだけ。

>>14
つかさ〜
素直にforでまわして、Hoge*へのﾎﾟｲﾝﾀにlengthじゃダメなの？

>>16の回答があってるかどうかはわからんが、それを書くのに２，３分でかけるならいいけど
２０分も３０分も悩んでたら、どんだけ工数あっても足らないし、しかもぱっと見わかりづらい・・・

>>20
boost::bind にかけられた叡智と努力を無視してるから

>>33
boost::bind を理解してれば2、3分も掛からない
掛かるのはタイプにかかる時間だけ

std::count_if(v.begin(), v.end(), bind(&std::string::size, bind(&Hoge::GetName, _1)) >= 5);

確かに見づらいね
でも、 for 文だと余分なローカル変数を導入するし、for 文の方が間違いやすいと思う

この程度ならタイプ量の違いなんてカスみたいなもんだろう
実行コストは…これも大差ねーか？

タイプ量なんてC++においてはクソの次ぐらいに位置するだろう。

TMPを見てみろあの変態共は…(ry

>>35

あの手のコードをタイプ時間のみで書ける、あなたのようは人は多くいはいないでしょ？

>>29
#define test(a, b) a-> b = 100
で何がいけないのか
話はそこからだ

>>39
Token-Pasting Operator (##)
the tokens preceding and following it are concatenated.
White space preceding or following the operator is optional.

MSDNからの抜粋だが、そのような結果にはならないのでは？

29が（bが*で始まってない限り）無意味だから意図を聞いてるんだよ
##の意味くらいみんな知ってるから下らない茶々入れるな

>>41
ちょっとなにいってるか分からない
bが*で始まるという表現のひどさはさておいても、それがプリプロセスエラーになると思えるのはどういう考え？

>>42
トークン連結の結果は、ひとつのトークンを成していなければならない。
"->" と何かを連結してひとつのトークンを成すとすれば、当てはまる結果は "->*" しか
存在せず、したがって b は "*" で始まるほか無い。

この制約を満たさない場合の動作は未定義。コンパイラによってはエラーになったり、
何もメッセージは出なかったりする。

PHPをC++化するOSSツール「HipHop for PHP」、Facebookがベータ版を公開
ttp://www.nikkeibp.co.jp/article/news/20100204/208938/
今更かもしれないけど俺は驚いた。

ひどい流れだ

自作クラスTestをstd::vectorに入れています。

std::sort(vec.begin(),vec.end(),std::less<Test>());

の為にoperator <をTestクラスのﾒﾝﾊﾞに書きましたが
「二項演算子 '<' : 型 'const Test' の左オペランドを扱う演算子が見つかりません 」
とのエラーメッセージが出たんで

クラスの外に定義したら問題なく動作しました。

が、なぜクラスのﾒﾝﾊﾞではダメなのでしょうか？

>>43
平身低頭して謝ることしかできません

>>46
constつけ忘れたんじゃね

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

解決しました。

VC++でビルドスクリプト的な需要を解決する方法って何が一般的ですか？
eclipseだとIDEから簡単に使えたんだけどそういうサポートはされてますか？

カスタムビルドステップのこと？

DLLとかつくるときに「シンボルのエクスポート」とかチェックする項目あるけど
シンボルって言うのは関数とグローバル変数を指すの？
どの範囲を指すのかが良く解らん

>>50
nmake か msbuild のどっちか。VCのバージョンによるからお好きなほうで。

特定のソフトウェアの話じゃなくて
C++についての話をしようぜ。

普段はC＃メインで数年ぶりにC++を触っています
例えばvectorの特定の要素を見つける（条件は少し複雑）場合に

１．for文をbegin〜endまでまわす（なんかかっこ悪い？）
２．find_ifを使う（別途関数つくるのがうざい）
３．boostでラムダとか使う（使い方もう忘れたよ＞＜）
４．VS2010が出るまで寝る

の四択があるのですが一般的またはお勧めとされるのはどれですか？
ちなみに完全趣味利用です。

2

4でfind_if＋ラムダ式がベスト

>>57
それって、普通のC++でも可能なんですか？
MSが開発したﾍﾝﾃｺなC++だけじゃなくて？MC++でしたっけ？

C++では滅多にusingは使わないのですか？

使いません

>>59
boostで使うだろ
いちいちboost::mpl::とかタイプしたいのか

>>58
C++0x

>>60
それどころかusing使わないとできない大事な技法もあるだろ

using std::swap;
とかまさか意味が分からないなんてヤツはいないよなw

>>58
C++0xなら可能。
gccの最新やvc10なら実装されてる。
std::find_if( first, last, [](int v) { return ...; } ); みたいな。

まずusing declarationとusing directiveの話がごっちゃになってる件。

>>65
いや元の質問がごっちゃになっているから、

>>60わざと使わないと言った(using directiveを意識している？)
>>61反例を挙げた(using directiveについて)
>>63あえて別例を挙げた(using declarationについて)

要するに元の質問者をおちょくっているだけだろう。

ちなみに分からない人には

using declarationとusing directiveの違い
ttp://cpplover.blogspot.com/2009/06/using-declarationusing-directive.html

これでも読んでください。

>>63
ごめんなさい、そうしないとできない大事な技法というのが分かりませんでした

じゃあVS2010出るまで寝るか
と思ったら20日に公開されてたんですね
早速落としてみるか

>>68
例外安全とかCopy & Swapを知らないの？
なら勉強不足なだけ。

>>70
usingなんていらねーよカス

>>71
いらないなら何のためにあるの？
その論でいくとtypedefも不要になりそうだが

#include <iostream>

namespace A {
　class N { };
　void swap(N& a, N& b) { std::cout << "swap N" << std::endl; }
}

int main() {
　using std::swap;
　A::N a, b;
　int c, d;
　swap(a, b); // A::swap が呼ばれる
　swap(c, d); // std::swap が呼ばれる（using が必要）
}

名前空間関連のC++の仕様は複雑だよなあ

その例だと std::swap<A::N> で特殊化しないのはなんで？って言われると思う

std::swap<A::N> で特殊化しないのはなんでなのJOJO？

規格で許されてるとはいえ、stdを汚すよりはいいんじゃない？
結局のところ適切なswapを呼び出してくれるんでしょ

swapも演算子レベルで仕様に組み込んでしまえばよかったのに
いびつになってる

>>70
知ってますが、usingを使わなければならないと思ったことがありませんでした。
usingはコードの記述量を減らす為にしか使ったことがありません。

rvalue参照でswapに相当することが出来るようになるし
swapで出来ない、というかちょっと無駄になるような処理も
効率的に表現出来るお

すみません。
2つ目のconstが無いとSTLがうまく動かないのですが。
これはどのような効果があるんでしょうか?

bool operator < (const classdata &x) const { return (n<x.n) ; }

この中じゃ数値を変更しないよ宣言

>>80
エラーならエラーメッセージを貼るべきだし、メンバ関数ならそう断ろうよ。
で、2番目のconstはメンバ関数が静的である。
つまり、メンバの変更は行なわないことを表明している。
ということは、静的なインスタンスからでも呼べるということ。
逆に言うと、静的でないメンバ関数は静的なインスタンスからは呼べない。

サンクス。すみません。
このようなクラスがあったとき、x.nもnも変更しないという宣言なんでしょうか?

class classdata {
public:
int n;
bool operator < (const classdata &x) const { return (n<x.n) ; }
};

メンバに変更が発生しないという宣言

サンクス

>>83
一個目のconstはxの参照先が変更不可。
二個目のconstはそのクラスのメンバが変更不可。
従って、nもx.nも変更不可。

ああ、そうだな。
>>83では2個目のconstに限っていなかった

>>78
まず>>67のusing declarationとusing directiveの違いは理解している？
もしご存じなければリンク先を熟読してください、



>>71お前本当にC++でプログラミングしてんのかよ。
無知を曝してる割に一切恥じないとはなかなかのツワモノだな。
言っとくがそうやって煽られてもお前に教える気はないよ。
…………………………
と思ったのだが、ROMってる純真な初学者さんが>>71の言うことを真に受けてしまうと
可哀相なのでヒントだけ書いておく。

上で述べられているstd::swapの特殊化は可能な限りしておくべきだが、クラステンプレートに対しては(部分特殊化となるため)できない。
そこで
using std::swap;
が活躍する事になるのだが、その辺のconsensusについては
かの名著『Effective C++第3版』
にも記載があるので未読or忘れた人は読んでおきましょう。

ちなみにまさにこういった事を知らない>>71のような無知プログラマが万一プロジェクトに
居た場合の対策についても『Effective C++第3版』は言及しているという名著っぷり。

他にもusingは
基底クラスのメンバを可視にするとか
CRTP関連の変態イディオムとか
いろいろ出番あるじゃないか。

煽りを真に受けて長文レスして越に入っちゃう男の人ってちょっと…

using が絶対に必要な例を１つでも示せれば
そんなに凄まなくていいのにな

>>88
はい、その違いについては理解しているつもりです。
そもそも、using directiveしか知らない方は見かけますが、using declarationの存在を認識していて
それらの違いを理解していない方はあまりいないのではないかと思っています。
起こり得がたい状況にも思えます。

閑話休題しますと、例外安全にするためにswapを使う、その際にstd::swapと記述するのでは
だめなのでしょうか？

繰り返しになってしまって申し訳ないのですが、usingを使わなければならない、逆に言えば、
usingを記述しなければ実現できないという状況をまだ知らないのです。

>>73 で using がないと std:: が必要になる。
std:: を書くようになると、swap の引数が何かによって
std:: をつけるかつけないかが変わってしまうので、
swap の中身を変えたら swap できなくなった、とかの問題が起こる事がある。

swap(a, b); で A::swap が呼ばれるのは、
引数の a と b の型が名前空間 A に属しているので、
勝手に名前空間 A の中に swap が無いか探して、
あればそっちを優先してくれるから。

このあたりのことは Effective C++ に書いてあるから、
この重要性が分からない ＝ Effective C++ すら読んでないヘボPGだと声高に叫んでる
ということになる。

usingよりtemplate使えよ
メンバswapにもSwapにもPODの最適化にも対応出来る

>>76
その結局のところというのは完全合法なのかなぁとか適当に言ってみるんだけどどうなの？

＞usingよりtemplate使えよ
swap技法について言ってるのなら、ちょっと意味が分からない。

>>95
最適なスワップを呼び出してくれる関数をtmp使って書いて
{using std::swap; swap(a, b);}
の代わりに
saikyo::swap(a, b);
って使うんだよ

それTMPなの？

>>96
saikyo::swapはどうやって書くのさ
まさか、必要な型のぶんだけ全部オーバーロード(もしくは特殊化)するの？

>>90
> using が絶対に必要な例を１つでも示せれば
> そんなに凄まなくていいのにな
上で述べられているstd::swapの特殊化は可能な限りしておくべきだが、クラステンプレートに対しては(部分特殊化となるため)できない。

って一行で済ませているだろ
なんでそれが分からないんだよ
なんでEffective C++すら読んでないんだよ

std 名前空間内じゃないから規格を気にせず好き勝手特殊化できる、という事なのだろう
まあ悪くはないように見えるが、std::swap でなくそちらを使うよう周知させる必要がある点が微妙

>>96
お前の言っているテンプレートはC++のテンプレートとは思えんくらい
あり得ない動きを期待しているようだが。

頼むからEffective C++を最低2回は熟読しろ。

>>100
> std 名前空間内じゃないから規格を気にせず好き勝手特殊化できる、という事なのだろう
できないっつーの。
なんでお前までも Effective C++ を読んでないんだよ！

> クラステンプレートに対しては(部分特殊化となるため)できない。
って俺が>>88で述べただろうが！

>>101
tmp勉強すればわかる

>>103
tmpがテンプレートメタプログラミングの略だとしたら
知ったかぶりもいいところだな。

こんなにテンプレートに関してうるさい俺が
Template MetaProgrammingを知らない訳ねえじゃねぇか。

>>104
実際わからねぇんなら勉強不足なんじゃない？

またhitoが暴れてる予感

おまえらただの言語オタクだ

hitoってダレだよｗ

saikyo::swapの実装を考えてみたが、
・メンバswapやSwapが存在するかなどSwappableを判定するtraitsでできる限り網羅的に定義する。
・それ以外のものは実装者自身またはサードパーティが適宜saikyo::swapまたはtraitsを特殊化。
というか俺lexical_castを作るのにこういう実装でやったことがある。
swapに関して言えば、どう考えてもusing std::swap（またはboost::swap）のほうが綺麗で便利。

もっと本当に最強な実装があるというなら教えてくれ。まじで。

今日はあちこちおもろいな。
宿題スレではhttpはtelnetプロトコル以降に生まれたから互換性があると断言してる人もいるし
ここはここでこんなだしｗ

>>99
特定の書籍をどうするかは他人の勝手だよ
話が通じてないと思うなら、おまえが自分の言葉で語らないことを省みたらどうなんだ

#include <algorithm>
#include <iostream>
namespace A {
struct B {};
void swap(B&, B&) { std::cout << 1; }
}
main()
{
A::B x, y;
swap(x, y);
}

くらいのことを自慢できる相手が２ちゃんしかないんじゃないか？

ageてまで自分の無知を宣伝するとかどんなM

ADLと言えば済むところをコードまで書いちゃうおとこの人って

>>73と同じ事書いてるだけだし
何がしたいのか分からない

ヘボかどうかの基準に特定の書籍は登場しないって指摘してるだけだよ
C++ならC++でどんな目的に使ってどのくらい達成できたかに過ぎないのを
わざわざ礼を失した表現を選ぶ者こそ何がしたいのか理解に苦しむ

# スレッドフロートという掲示板の仕様が気に入らないのを一般ユーザに八つ当たりするバカも同類

>>115
# スレッドフロート型を拡張した掲示板の慣例を守っていないことに対する指摘は八つ当たりではない、と書いたところでsage進行スレじゃないことを知る

さらに、ここはム板
強制と任意の区別がつかない知恵遅れに出る幕はない

特定の書籍は共通認識として役に立つぐらいだよなぁ。デザパタと一緒。
デザパタの名前を知らないからヘボと決めてはならないし、特定の書籍を
読んでないことについてももちろん同様。

共通認識としての情報が使えない場合、相手に対して正しく伝えられるかどうかが
ヘボかどうかの基準といえる。

まとめると、この本読んでないからお前アウト、という考えをしてる人はヘボ。もしくはヘボではないが短気。

> この本読んでないからお前アウト、という考えをしてる人はヘボ。もしくはヘボではないが短気。
Effective C++を読んでないからお前アウトとは言っていない。
Effective C++を読んでなくてもそれに相当する最低限の知識を持っていれば
アウトではないし、別にEffective C++を読む必要すらないレベルの方々だということだ。

だが
「それに相当する最低限の知識」を持ち合わせていない
ようなので、お前アウトと申し上げたとおりだ。

上記のstd::swapの議論に荷担したいわけじゃなく、
全然関係ない質問として
swapについて質問をさせてください。


他人の作ったクラスOther_s_Classを利用したクラスMy_Classを作る時、
Other_s_Classの仕様のせいでどうしても
swap(const My_Class&, const My_Class&, )
を例外を投げないように実装できない
（頑張っても不可能）ということは
実際にあるのでしょうか？

ありましたら例を教えてください。

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

例外を投げないようにというそれだけの要求であればすぐできるよね。
ただ、例外を投げない例外安全性を求めるのならずいぶん難しいと思う。

My_Class::swapが例外を投げる可能性があり、しかも何が投げられるか不明確
（たとえばLib+ヘッダのみ公開されていて仕様にも記載がない）なら事実上無理だわね。
throw()で握り潰せば何でもありだけど。

Other_s_Class をポインタで持てば
常にポインタの交換で実装できるんじゃない？
swap のためだけにポインタにする、というのが嫌ならアレだが

みなさんありがとうございます。

> swap のためだけにポインタにする、というのが嫌ならアレだが
swap のためだけにポインタにするのも厭いません。
例外を投げるswapを認めないということは常に実装可能なのかと
疑問に思いまして。

アウト・セーフ・よよいのよいってか
何の話だよいったい・・・

知らなければ論外だと思うならそもそも相手すんな
自分が論内に引っぱってるんだろうが

>>124
123 のレスが全てでしょ

>>124
なんにも制約をつけないとなるとswapってなんだろうという哲学的な問いのような気がしてきた
たとえば連結リストの一つのノードに対する
struct node_t{
node_t *prev; node_t *next; int v;
};
void swap(node_t *n1, node_t *n2);
という関数は必要なのか？
どういう実装にすべきか？

作るなら void swap(node_t& n1, node_t& n2); でしょ
値だけの交換と前後の交換の二種類あるけど、
テンプレートだと値が交換可能である保証が無いから
前後の交換で実装するのが無難かと
これはintだから値の交換でもいいと思うが
前後の交換だと、n1, n2 が連続している時に少し考慮が必要かな

http://codepad.org/FdFoMETP

なんでコンパイル出来ないんですか？

fugaの引数の型がintだけど、
intからhoge<T>::typeのTを類推できないので

typedefされた型は元の型と同じように扱われて、
xには既にhoge<T>::typeという情報は残らない

なるほど
引数からの類推って結構制限きついんですね
最終的にその型になればなんでもいいのかと思ってました

修飾された型名は推論できないんだよな

>>35
それだと5uにしないと警告の嵐

でも警告でしかないんだよね

>>133
それがC++さ！

嵐っちゅっても結局はこれ↓一つでしょ
warning: comparison between signed and unsigned integer expressions

お前らのコンパイラは優秀だな
オレのVCで試したら40行近く出たぜ

テンプレートとかその他の細かいとこの仕様を知りたいんだけど仕様書だと読むのしんどい
わかりやすく細かい仕様を解説してるサイトとか書籍ってある？

>>137
template metaprogrammingをやりたいの？
それとも初めてtemplateに触れるの？

metaのほうで初めてというわけじゃなくて
知識をよりまとまった強固なものにしたい

>>139
なら回り道せずに規格読むのが最善手。
他の人の解説では間違いや省略が混ざる可能性が出てくるので、強固な知識とは言いがたい。

>>137
C++テンプレート完全ガイドとか

激しくスレ違いな気もしますが適切なスレが見つからなかったのでここで失礼します。

C++とDirectXでFlashのようなツールを作っています。
Flashはレイヤーの数やフレームの数が限りなく作れたり、「戻る」もかなりの回数を使うことが出来ますが
編集中のデータは一体どこに保存しているのでしょうか。
自作プログラムでメモリに1分ほどのアニメーションを保持させると
レイヤーの枚数や同時に開いているアプリケーションによってはメモリ不足になります。
ファイルに保存しているのかなと思いましたがファイルアクセス？に若干時間がかかり、
レイヤーやフレームの増減や現在見ているフレームを切り替えたときにカクカクしました。
他に方法があるのかと考えましたが思いつかず・・・何か参考になりそうなことがありましたら教えて頂けると有難いです。
そもそもこういった処理に何か名称があるのでしょうか？

画像、イメージの保持じゃないんだろ。

前後のフレームをバッファリングするとか。

>>142
描画につかったパラメータとかプロパティとかを構造体かなんかでバックアップしといて、
必要になったらそれ使って再描画ってかんじじゃないの？？
面データとかはなるべくフラグに落としたり出来ないか考える。
もしくは、ランダムアクセスできるような数式を考えて逆側に進めるとか。

初心者だからよく解らんけど。

>>142
参考になるかもしれないキーワード
・ベクターアニメーション
・Mementoパターン
・Commandパターン

>>143-144
前後のフレームをバッファリングするにしても再生すると毎フレーム必要になることを考えたら変わりがないような気も。
情報量を圧縮するにも限界があるので根本的な解決にはならなさそうですね。
「アニメーションの巻き戻しをしない」が前提であれば差分データだけでいいので若干良くはなりそうですが・・。

>>147に>>145のアンカーの付加ﾜｽﾚ

>>146
調べてみます。

>>147
ああ、編集じゃなくて再生のことも書いてたのか

それにしてもバッファリングを否定されるとつらいな。バッファリングなしで動画を描画している例って今あるのかね

>>139
パーサー作ってみたら？
() や typename あたりのどたばたまで引っくるめて
C++ を愛せるかどうかも「強固」には必要だろ

flashは基本的に
「三角形を左へ100ドット、100フレームかけて移動せよ」
みたいなデータの集合だから、
よほど複雑なアニメーションでもなけりゃ、10分でもオンメモリ余裕だと思う。

コンストラクタに可変個のstring渡す方法無いですか。
もしくは、("aaa", "bbb", "ccc")が自動で
vector<string>　へ変換させられる方法とか。

自己解決。こんな関数を挟むことにしました。

#define tovecstring(...) tovecstring_sub(__VA_ARGS__, NULL)
std::vector<std::string> tovecstring_sub(char *p, ...){
va_list L;
va_start(L, p);
L = (char *)L - sizeof(char*);
char *ch;
std::vector<std::string> x;
while((ch=va_arg(L, char*))!=0) x.push_back(ch);
va_end(L);
return x; }

こっちのほうがいいや

#define tov(...) tovecstring_sub( "",__VA_ARGS__, NULL)
std::vector<std::string> tovecstring_sub(char *tmp, ...){
std::vector<std::string> x;
char *p;
va_list L;
va_start(L, tmp);
while((p=va_arg(L, char*))!=0) x.push_back(p);
va_end(L);
return x; }

stlのmultimapとmapの要素をvectorにしたのはどっちが挿入が早いですか？

ここで訊くより自分で測った方がよほど早いんじゃ？

「線形時間」とか言われても具体的な係数は決まってないしな

>>157
あるよね。
O(n^2)のはずなのにO(n)より早えぇよとか。
たぶんnがでかけりゃ逆なんだろうが。

良く多倍長整数がうんぬんって話になると
Fast Fourier Transformは実はそこまで早くないとかあるらしいね。
nがそこそこなうちはカラツバ法が良いとか。

すみません。

string str[]={"aaa", "bbb"};　を
関数を使ってvector<string>にするにはどうすればいいですか。

string*を引数にするとサイズデータが無くなるんですが。

template <unsigned N> vector<string> make_strvec(const string (&a)[N])
{
return vector<string>(a, a + N);
}

サンクス

Boostありなら、

#include <iterator>
#include <algorithm>
#include <boost/range.hpp>

string str[]={"aaa", "bbb"};
vector<string> v;
std::copy(std::back_inserter(v), boost::begin(str), boost::end(str));

copyの引数まちがえた。

std::copy(boost::begin(str), boost::end(str), std::back_inserter(v));

コンパイルできないんでこうしましたよ

template <unsigned N> vector<string> make_strvec( string (&a)[N] )
{
int n;
vector<string> x;
for(n=0; n<N; n++) x.push_back(a[n]);
return x;
}

すまん自分で確認してなかった
コンパイル出来なかったか
何がダメなんだろう

横だが、最初のコードでコンパイルできたよ。
@VC9

>>164

BCC6.2.1だがコンパイルして走ったよ

string str_table[] = { "aaa", "bbb" };
size_t num_str = sizeof(str_table) / sizeof(str_table[0]);

vector<string> v( str_table, str_table + num_str );

v.assign( str_table, str_table + num_str );

stringのインスタンスのsizeofは何を返すんだろうな
例えば>>169で文字列の長さが違っていても動くかな

おまえは何を言ってるんだ？

stringのインスタンスのサイズに決まっているだろう
可変長構造体でもあるまいし

なんでオーバーロード解決の候補にprivateなメンバ関数が入るんだコラァ！

ディスパッチしたいときとか、いろいろあるだろJK

友達がいるかもしれないからな。

え・・・・・

C言語を呼び出す時の、extern "C"の"C"って何？

Bの次だからC

C言語の"C"だろJK

あっそうなの

規格で定められているもうひとつは extern "C++" で、これがデフォルト。

へぇ"C++"もあるんだ
どんなふうに使うんだろうね

マクロで切り替えるとか・・・？

使わないな

というか、extern "Pascal"だったり extern "Ruby" だったりができてないだけ

多くの現実のコンパイラが、その目的のために採用したのは、
extern "hogehoge"じゃなくて、独自の指定子だったからな。
VCの__stdcallとか

extern な場合だけじゃないしなあ

基本的なことですみません
配列の演算子をオーバーロードしたいのですが、
T & foo::operator[](int idx)
とかやってるとします。
ここでidxがむちゃくちゃで返すべきTの参照が無い場合、何を返せばよろしいのですか？
例外を投げる？

カラッポのTをつくって返す？っていっても無理矢理なんか帰しても無意味だから
やっぱり例外かな。。

非constの参照を返すなら、空っぽのTを作って返すのはマズいんじゃ？

>>187
俺は基本的にはstd::out_of_rangeすろーかな。

ありがとうございます
例外投げます！

>>187
かのScott Meyersの名言
「intの様に振る舞え」
って知らない？


> ここでidxがむちゃくちゃで返すべきTの参照が無い場合、何を返せばよろしいのですか？
intの配列でそれをやったら未定義の動作だから、
基本的にはその状況は考えないで何をやっても責められないとは思うが、

> 例外を投げる？
現実的にはそれが親切だと思う。
投げるクラスはstd::out_of_rangeまたはそれを継承したクラスを投げましょう。

> カラッポのTをつくって返す？
それは最悪の選択。
返却値の型は T & なんだろ？
テンポラリオブジェクトへの参照を返すつもりなの？

俺ならassertするかも
std::vector とかだと、operator[] は例外投げず、at() は例外投げる、と使い分けてるね

これ超分かりやすいんだけど
http://shota356.blog91.fc2.com/blog-entry-707.html

>>192
> 俺ならassertするかも
俺もそれ言おうとしたが、
assertはデバッグビルドで削除されるってことを
思い出して止めた。

> std::vector とかだと、operator[] は例外投げず、at() は例外投げる、と使い分けてるね
うむ。
たぶんSTLに準拠すると喜ばれると思う。

>>193
そう・・・かな・・・ぁ。
まあ説明は人によってウケが違うしな。

宣伝だろ

>>194
逆！逆！
リリースビルドで削除だ

>>197
ああごめん逆ったｗ

ポリシーで例外を投げるかアサートするか無効なオブジェクトを返すかその他にするか選択できるようにすればいい

operator[] にポリシーねえ
かといって、クラスレベルでポリシー設定したんじゃ粗すぎるし

無効値オブジェクトとか*NULLの参照とかって大抵ろくなことにならないけど使いたがる奴多いよな
なんで？

Null Objectパターンに近いようなそうでもないような

やっぱ近くないな

>>201
クソ設計だけど、もうそうするしかないほど追い詰められている時に
「とりあえず動けばいいんだよ！早く作り終えないとけないし！」
ってなった結果じゃないかな？

誰もがいつでも例外を投げれていい環境で働いてるワケじゃないんだぜ

>>205
あー、なるほどね。
・・・その場合、Boostとか使えないの？
例えばboost::lexical_cast<std::string>()とかどうするの？
例外を投げないオプションとかあるのかな？

あれだ
goっぽくtupleでも返すとか

GoogleだとboostどころかSTLも禁止じゃなかったっけ
bad_allocとかout_of_rangeとか投げるから
そういうとこだと完全に独自ライブラリ

例外禁止って、さらに new が禁止で２段階初期化が強制になるんだろ？
よく聞く話だけど、そこら辺まで考えての判断なのか疑問だね。

例外を使わない過去の資産との相性が悪いからと聞いている

>>208
まじかよ
boostやSTLを廃止したら生産性が下がるだろ。

Googleの躍進を見ていると、それを感じさせないほどの
Google独自ライブラリがあるのだろうかね。

全部例外じゃなくエラー返すようにした
完成度の高いライブラリでも持ってんじゃない

>>212
でも結構オープンソース開発をしているよな。
そのライブラリの一部も公開しているのだろうか。

>>209
> 例外禁止って、さらに new が禁止で２段階初期化が強制になるんだろ？
なるほど。
newは当然のごとく禁止ってのはわかる。
さらにConstructorで失敗した時に例外禁止だとどうしようもないから
init()
メンバを用意する訳か。

ほー。

デストラクタはあるからCの時ほどはつらい制限ではないけどね

initメンバなくてもis_valid的なメソッド有ればええんちゃうの？

valid であると判定できないといけないのは面倒くさい気がする
初期化済みフラグをいちいち導入する必要があったりとか

>>216
まぁね。

new(nothrow) した後 valid じゃない場合は即座に delete するファクトリメソッドを
用意すれば使う側の負担にもならない。これが害の最も少ない対処法だと思う。

例外使ったほうがずっと良いんだけどね。

可変個引数テンプレートがないと根本的な解決には

>>219
なんのこっちゃ？

>>217
逆に言えばbool メンバが一つ必要になる反面、
いかなる状況でもis_validを呼び出せば初期化済みかどうか
確認できるってメリットにもなるよな。

init()で初期化する方式だとそれはできない。

でも例外を使うべきだと俺は思うけどね。

まあ、初期化済みフラグがちゃんと管理されてればな

>>222
>ちゃんと管理されてればな
そんな手間じゃないでしょ。

メンバの
　bool 初期化済みflag;
をConstructorでfalseに設定して、initでtrueにするように設定して、
他のメンバからはいじれないようにすれば大丈夫さ。

復旧不能なエラーが起きた場合どうするかとか

> 他のメンバからはいじれないようにすれば大丈夫さ。
自分で言っててそれはつまりどうする気だと思ってきた。

初期化済み flag をメンバに持つそのためだけの基底クラス class InitFlagImpl を用意して
InitFlagImpl 中で派生クラスの init() を一個一個全て friend 指定する。
また InitFlagImpl の Default Constructor は初期化済み flag を false にセットするようにしておく。

そして派生クラスは InitFlagImpl を private 継承してやれば
派生クラスの Constructor では自動的に InitFlagImpl の Default Constructor が呼ばれるので
自動的に初期化済み flag が false にセットされ、
派生クラスの init() だけに気を配れば良い事になる。


>>224
それは初期化済みフラグには関係ない話だ。

オブジェクトが正常でない状態になったら
is_valid は false を返すべきだと思う

>>226
うむ。おっしゃるとおり。
だがそれは本質的な問題じゃないから解決は簡単だ。
上述の is_valid を is_初期化済み として読み替えてくれ。

復旧不能な状態って初期化済みと自信を持って言えるかね
まあコンストラクタのエラーに対してのみ使う、という規約を周知するのなら

flagの中身が破壊されるようなエラーが出たらダメだから
ちゃんとチェックメソッド書いた方がいいよね

メモリ破壊気にするなら
flagの前後にメモリとって
そこが破壊されてるかチェックしたのでいいと思うの

>>228
bool is_初期化済み()
と
bool is_valid()
があれば自信を持って言っていいと思うぜ。

>>229
>>225方式ならflagは破壊されないんじゃね？

めんどくせー。例外投げりゃいいじゃねーか。
Google みたいな事情がおまいらのところでもあるのか？

おい議論がおかしくなって居るぞ。

今は
1.「例外を禁止したが故に生じる問題点とその解決策」
について論じているんじゃないのか？
なのに不法なメモリー破壊の話とか、
2.「例外を禁止していようがいまいが生じる問題点」
じゃないか。

1.と2.を混同してないかい？みんな。

かわいい映画を見に行こうと思って「テディ」を選んでしまったときの気持ち

AMD製 CPUを搭載しているPCでｺﾝﾊﾟｲﾙしたEXEが
Intel製 CPUを搭載しているPCでなぜ動作するのですか？

コンパイラはネイティブコードを出力するとすると、動作しないのでは？

>>235
動作するように互換性を持たせてるからです。
http://ja.wikipedia.org/wiki/X86
http://ja.wikipedia.org/wiki/AMD64

もちろん、IntelやAMDの独自拡張命令を使ってると
ほかのCPUでは動かなくなる

ファンクタって何が便利なんですか？

関数ポインタと比べると最適化されやすいあたり

単に一時オブジェクトの関数呼んでるだけじゃなかったんですね

何も便利とは思わんが・・・

boost::function使い倒してからもう一度出直してこい

>>242
今使い倒してみました
高が知れてますね

私が知りたいのは、ファンクタは無理に使う必要は無いか？ということです

C++に慣れてくれば自然と使いたくなるので、無理に使う必要は無いです。

>>235
下手にある側が、上手にある側にいやいやでも合わせて互換性を持たせる
なんてことは良くある話だ。

>>244
> 私が知りたいのは、ファンクタは無理に使う必要は無いか？ということです
無理に使う必要は無い。
だが使わない方が無理とは言わないまでも、不便だし
デザパタ上もまずいと思いませんか

面白いやり取りを発見しました。

http://rararahp.cool.ne.jp/cgi-bin/lng/vc/vclng.cgi?print+200309/03090053.txt

レベルの高い方々はその程度のことでもカリカリして大変そうだな

レベルが高いとかの問題じゃないでしょ。
見本となる人がこの程度の事で手を抜いてどうするの？

いやこれは手を抜いていいだろ

日付見てスルーしろよ

プログラマって知的でいつも冷静沈着な人種と思ってたけど、案外沸点低いよね

下記のように配列をまとめて代入したいのですが、良いアイディアはないですか？
char value[] = {1,2,3,4};
vallue = {5,6,7,8};

>>254
static char const next_value[] = {5,6,7,8};
std::copy(next_value, next_value + 4, value);

さぁ不満なところを列挙してもらおうか？

freadって

>>256
std::fread()のことならC標準関数のそれと同じものです。
つまり、ストリームから指定バイト数の要素を指定個数読み取る関数ですね。

enumしてもらおうか

>>225の方式って読んでみたらかなり綺麗に見えるけど、
コンパイル通るんかいな。

デストラクタの挙動で質問です。

すべて純粋仮想関数のメソッドを持つクラスを基底として、
継承したクラスをdeleteした際、デストラクタが呼ばれないようです。

テストは下記のように作りました。

class ITest {
public : virtual ~ITest(){};
public : virtual void Print() = 0;
};

class TestOne : public ITest {
private : char* str;

public : TestOne( char* str_ ){
str = str_;
};

public : virtual ~TestOne(){
printf( str );
str = NULL;
};

public : virtual void Print() {
printf( "ONE " );
printf( str );
};
};

class TestTwo : public TestOne {
private : char* str;

public : TestTwo( char* str1_, char* str2_ ) : TestOne( str1_ ){
str = str2_;
}

public : virtual ~TestTwo(){
printf( str );
str = NULL;
}

public : virtual void Print() {
printf( "TWO " );
printf( str );
}
};

int _tmain( int argc, _TCHAR* argv[] ){
TestTwo* _two = new TestTwo( "1111","2222" );
TestOne* _one = _two;
ITest* _ites = _two;

_two->Print();
_one->Print();
_ites->Print();

delete _ites;

return 0;
}

_itesをdeleteした際に、PrintTwo、PrintOneの順でデストラクタが
呼ばれることを期待しましたが、呼ばれないようです。

コンパイラはVC++2008でPSはXPのSP3です。

_oneや_twoをdeleteした場合は、
期待したとおりにデストラクタが呼ばれております。

この挙動はC++の仕様なのでしょうか？

申し訳ありません。

class ITest　は下記の物と差し替えてください。

class ITest {
public : virtual void Print() = 0;
};

>>255
代入するのに２行必要なのが不満です。
その後必要ない変数next_valueが残るのが不満です。
そうではなく下のように１行で書きたいです。

value = {5,6,7,8}

どうにかして書けませんか？

0xに移行してvector使う

>>264
あと1年くらいでそれがコンパイル通るようになるから
しばらく待てない？

Boost.Assign

クラス、テンプレート駆使したらできるだろ

>>254
strcpy(vallue,"1234")

どうやればいいかはしらんが

value = {5,6,7,8}

はできるはずだ。

>>269
それを書くなら、memcpy(value, "\x5\x6\x7\x8", 4)だろ。

>>269 にプログラムを書かせると
平気でメモリ破壊するということが分かったな

こまけーことはいいんだよ

こまかくねーよw

メモリ破壊どころか、値も滅茶苦茶。

>>265-266
C++0xって奴ですか（本当に出るの？）
今すぐにできないならあきらめます。
全く使えない言語だ

タスケテー・・・

>>263 の通りなら、>>260 のように基底クラス(ITest)のデストラクタを仮想にしてやらないと
基底クラスのデストラクタしか呼ばれない。

>>276
> 全く使えない言語だ
あきらめろ。お前には無理だから。

>>278
レスありがとうございます。
そのような挙動でしたか。

インターフェースにもvirtualのデストラクタをつけなければ、
継承した子のデストラクタもよばれないのですね・・・。

お手数おかけいたしました。

>>280
deleteを独自に定義とかしていない限り、

struct Derived : Base
{};

Base * p = new Derived;
delete p;

としたとき、BaseがvirtualなDestructorを持っていない場合の
動作は、標準C++では未定義の動作である。

//////////////////////////////////////////////////


　struct MyContainer : std::vector<int>
　{};
でも
　std::vector<int> * p = new MyContainer;
で未定義の動作になるのは
　delete p;
とした時だけで、例えば
　delete (MyContainer*)p;
だったら未定義の動作にはならない。

あるいは
　boost::shared_ptr< std::vector<int> > * p(new MyContainer);
としても未定義の動作にはならない。


そもそもMyContainerを基底クラスのポインタに入れるということをしなければ
全然問題ないし。

>>276
つ GCC4.4以上

>>282 まじっすか。
なら4/29発売のUbuntu10.04がgcc4.4.3らしいので使えそうですね。
これは楽しみだ。gcc最高

>>283
Ubuntuが売ってたらびっくりだわ。
・・・じゃねぇや、gccのバージョンなら今でも自分で上げられるんでは？

その代入そんなすげえか？

>>276みたいな低脳にいちいち教えてやるなんて
お前ら優しいな。

>>281
そのソースを使う人のことを考えないなら確かに「全然問題ない」ね

>>281
詳しい説明ありがとうございます。

動作未定義でしたか・・・。

Webの入門系しか見てなかったもので、
こういう所の動作は知りませんでした。

確かに基底クラスのポインタに入れなければ問題ないですね。

外部に提供する時にすべてvirtualのインターフェースを
返していたため、その型で保存しておりました。

考えてみれば、元の型で保存しておいて、getXXで返す型を
すべてvirtualの基底クラスにしておけばよかった事にいまさら気づきました。

>>287
問題ないと思うけどな。
仮想デストラクタを持たないクラスを継承するなんて、
stlでもboostでも普通に使われてるじゃない。

>>287
> そのソースを使う人のことを考えないなら確かに「全然問題ない」ね
いや、普通におかしくないだろ。
もしかして
「多態的にデザインされていないクラスのデストラクタは仮想にしない」
ってのを知らない？
デストラクタが仮想になっていたら多態的に使ってください！って言ってるようなもんじゃん。

>>290
正確な日本語で言えば
×「多態的にデザインされていないクラスのデストラクタは仮想にしない」
○「継承されて基底クラスとして多態的に使用することを想定して作られていないクラスのデストラクタは仮想にしない」
だな。長いけど。

>>289
stlは見た事無い気がするけどboostでなら当然のようにあるよ。
polymorphicに使わない基底クラスでDestructorをvirtualにするのは間違いで、
無駄にオーバーヘッドが出るだけ。

>>292
std::unary_functionとかste::iteratorとか。

でもまあ、普通はstd::vectorから派生なんてしないよな。大抵は包含すりゃ済むし。
>>281は単なる例だと思うから気にしなかったが、
そういう意味では>>287の言うこともわかる。

ste→std

>>294
あー、そっか。それがあったね。

> まあ、普通はstd::vectorから派生なんてしないよな。大抵は包含すりゃ済むし。
うむ。おっしゃる通りで、大抵は包含すれば, だめでもprivate継承すれば十分だ。

俺は確かに例としてのためだけにstd::vectorを継承したんだけど、
>>287はそうは取らなかったってわけか。

なるほど。

継承を前提とするクラスで非仮想デストラクタにするなら、
そのデストラクタはprotectedにすべしと、C++ Coding Standardsに書いてあったはず。
それを守ればいい。

>>296
それだと継承してない場合にその基底クラスを使えないんじゃないか？

>>297
「継承を前提とするクラス」
むしろ使えないようにしといた方がいいという場合のこと

C++使って趣味でゲームプログラミングしてる人って結構いるもんなの？

>>299
結構いるかはしらないけど俺の周囲には俺も含め3人いる
皆別々の作品を作っているよ

>>300
俺の周囲･･･っていうとサークル所属か何かかな？
もし良かったら、各々が作ってるジャンルと深さ（エンジンまで作ってるとか、そこまでじゃないけど制作用ツールは作ってるとか色々）を教えて欲しいな

制作用ツールってなんだろ。

C++でゲームプログラミングか。Mですなぁ。

なんかもっと、こう　簡単に作れそうなframeworkとかないのかね。

>>302
開発が楽になるような自分用ツール。

サークルとかじゃないよ
俺->日曜プログラマー MMORPGのサーバサイドの処理をC++で作成中
友人->趣味としてWindowsのシューティングを作っている 本職もゲーム屋さん
友人の友人(俺の知人)->大学生 今は3D関連のライブラリーだかエンジンだか作っている。俺3D弱いから彼が何言っているかよく理解出来ないｗ

>>305
THX
っていうか凄い人達だな。何だその繋がりｗｗどこで知り合ったんだ？
俺も大学生だけど経済学科だし、3Dのライブラリとかエンジン作るとか夢のまた夢って感じだ・・・・

横槍レスだけど

>>306
まあもしゲームをC++で作りたい場合でも別に3Dライブラリを作る必要まではないんじゃないの？
3Dライブラリは日進月歩だし、自分でライブラリレベルから作ってたらたぶんゲームが完成しないw
既にある優秀なライブラリを借りればいいじゃないの。

関数テンプレートのプロトタイプ宣言ってどうすんの？
必要ないの？

必要は無いけど、書ける
普通に定義したものの { } をなくせばいいだけ

>>309
ｻﾝｸｽ

>>307
DXやGLレベルのことじゃなくて、それらを使った便利オレオレラッパーとかのことじゃねえかな。

>>311
あーびっくりした。
そうだよな、OpenGLレベルを自力で書ける大学生とか
もう卒業待たずにGoogleに入れるレベル。

>>312
膨大なだけで根性さえあればかけると思われ・・・

そんな根性ある学生が居るならうちで雇いたい

ハードウェアサポートなしなら作れるんじゃない？
時間さえあれば

>>315
やるならもちろんソフトウェアレンダでしょうね。

15年昔ならアセンブラで手書きとかがあったよね。
グラボ会社も資料出してくれてたこともあったし。

Mesaと同レベルの物をスクラッチから書くなら応援するわ。
どれくらい意味があるかは分からんが。

まて、例え出たとしても超えなきゃ意味ないしバグが取れるまで…(ry
とか考えると、やっぱり便利なラッパを書いてくれる方がうれしいな。

iostreamとSTLについての質問です。

標準入力から読み込んだ英文を単語毎に分解する目的で、
よく以下のようなコードを見かけるし使うのですが、

cout << "Please input strings : ";
istream_iterator<string> start(cin);
istream_iterator end;
vector<string> v(start, end);

これを複数回繰り返す方法がよくわかりません。
＃正確に書くとこのコードの後に普通にcinから読み込ませる方法を知りたい
上記コードに続けて、

cout << "Please input strings again : ";
cin.clear();
vector<string> v2(++start, end);

とするとWindowsXP(MinGW)の環境では意図した通りに再度入力できるのですが、
FreeBSD上のgcc環境で試したところcinから何も読み込まずにv2に空vectorが出来ます。
#cin.clear()が無いときと同じ動作
何とか移植性のある方法は無いものでしょうか。

cin.seekg(0); したらいけた

すみません　STL を勉強しているところですが、
gcc-4 では、教科書の次のコードがコンパイルできません。
（bcc32 ではコンパイル・実行とも問題がありません。）
コード上で問題はありますでしょうか？

http://codepad.org/SyLoUb14

よろしくお願いいたします。

sinは現在オーバーロードされてるので、
どれを使っていいのか分からないというエラーになる
目的の関数ポインタ型でキャストするか、
テンプレート引数を明示的に与えるといいのだが、
transformでテンプレート引数を明示的に与えるのは面倒臭いので、キャストがベスト

>>321
ご丁寧に unresolved overloaded function type って書かれてます
つまり、sinがオーバーロードされてるのでどれを使ったらいいか分からないということ

Line 19: error: no matching function for call to
'transform(
  __gnu_debug::_Safe_iterator<__gnu_norm::_Deque_iterator<double, double&, double*>,
    __gnu_debug_def::deque<double, std::allocator<double> > >,
  __gnu_debug::_Safe_iterator<__gnu_norm::_Deque_iterator<double, double&, double*>,
    __gnu_debug_def::deque<double, std::allocator<double> > >,
  __gnu_debug::_Safe_iterator<__gnu_norm::_Deque_iterator<double, double&, double*>,
    __gnu_debug_def::deque<double, std::allocator<double> > >,
  <unresolved overloaded function type>
)'
compilation terminated due to -Wfatal-errors.

まだ悪夢には程遠いけど、やっぱ見づらいな

>>321
>>322
ありがとうございます。これでコンパイル・実行ともできました。
transform(radians.begin(), radians.end(), sines.begin(), (double(*)(double))sin);

すみません
>>322 >>323 でした。
的確な回答ありがとうございました。

横槍だけど
>>322-323
sin(0.3)とかはstd::sin(double)が他より優先的にマッチするから
オーバーロード解決が問題じゃないのでは？

VC2008ではコンパイル&リンクできて
C:\>aaaaa.exe
0.1:0.0998334
0.2:0.198669
0.3:0.29552
0.4:0.389418
0.5:0.479426
ってなったよ？

Comeau C++では


Comeau C++では

Comeau C/C++ 4.3.10.1 (Oct 6 2008 11:28:09) for ONLINE_EVALUATION_BETA2
Copyright 1988-2008 Comeau Computing. All rights reserved.
MODE:strict errors C++ C++0x_extensions

"ComeauTest.c", line 19: error: no instance of overloaded function "transform"
matches the argument list
The argument types that you used are: (std::_Deque_iterator<double, double &, double
*>, std::_Deque_iterator<double, double &, double *>,
std::_Deque_iterator<double, double &, double *>,
<unknown-type>)
transform(radians.begin(), radians.end(), sines.begin(), sin);
^

"ComeauTest.c", line 9: warning: variable "n" was declared but never referenced
double n;
^

1 error detected in the compilation of "ComeauTest.c".

ってなったわ。
つまりなんなんだ？？？？

>>327
テンプレート引数は
関数テンプレートの引数のみの情報から推論できないといけない
関数テンプレートの中の処理なんて一切見ない
transformのテンプレート引数を見れば、推論不可能なことが分かる

わかり易い例
http://codepad.org/XutU6qLk

>>329-330
ほー、ありがとう。
今 gcc と VCの<algorithm>を漁って定義を確認してきたところ。
おっしゃる通りでございました。

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

イテレータじゃなくてポインタ使ってるなら推論効くけどね
イテレータ使ってるってのがポイントなのよね

transform(radians.begin(), radians.end(), sines.begin(), (double(*)(double))sin);
って関数ポインタにキャストしているように見えるんだけど、
最適化の障害になったりはしないの？

つまり今回は
テンプレート引数の推論の問題であって
Overload Resolutionの問題ではないということか。
ややこしや

>>332
関係ないよ
http://codepad.org/yT2ckp7t

もしtransformの定義がtransform(T*, T*, T(*)(T))ならって話

>>333
double(*p)(double) = sin;
のpと同じ一時オブジェクトを作る意味になるから
やってることはオーバーロードの選択

オーバーロードの選択でキャストするのって面倒臭いよね
長くなるし、いちいち typedef するのもめどい

while(1) {
Hoge h;

func(&h);
}

funcに渡されるアドレスって毎回同じインスタンスですよね？

いいえ毎回新品です

毎回新しく作られる
普通は同じアドレスだろうけど、そう保証されているわけではない
とりあえずコンストラクタとデストラクタはループごとに毎回呼ばれる

>>339
なぜそう思う。
むしろ違うと思うのが自然では？

例えば
while(1) {
Hoge h;
hをいじる。
func(&h);
}
だったとして、次のループのhが前回hをいじった結果を継承していたらおかしいでしょ？
なぜおかしいかというと、}のところで一回スコープから外れているんだから
hはデストラクトされているわけだ。

>>342
C言語だと同じなのですが....

割り当てされるメモリ上のアドレスは同じでも「インスタンス」は別。

>>343
C言語で同じ事が規格で保証されているってこと？
そんなこと無いでしょ。

C++だって同じになるかもしれないけど、同じにならないかもしれない。
規格ではどっちでも良い事になっている。

>>345
規格ではどっちでもいいけど
実装は同じになるのですが

>>346
結局何を聞きたいの？

> 規格ではどっちでもいいけど
> 実装は同じになるのですが
そういう実装なんだろ？
コンパイラのマニュアルでそう保証されているの？
それとも今のところ一緒ってだけ？

>>347
こうゆう書き方ってまずいのか
よくわからなくて

こまってます

同じhをいじり続けたいなら
Hoge h;
while(1) {
func(&h);
}
でいいじゃないか

>>348
まずいかどうかはfuncを君がどう定義しているかによる。
funcはhが次の4パターンのどれを期待しているの？

1.常に同じオブジェクトかつ同じアドレスが必要 -> >>349が言っている通り。
2.常に同じオブジェクトかつ違うアドレスが必要 -> 言ってる事が矛盾している。
3.毎回新しいオブジェクトが必要かつアドレスは同じでも違ってもいい。 -> 君のコードのままでおｋ。
4.毎回新しいオブジェクトが必要かつアドレスは同じでないとやだ。 -> 配置構文newを使うしかないと思う。

ねるわ。
もしパターン4を期待しているなら誰かが 配置構文newを教えてくれるよ。

ちょっと待って、そもそもCで変数の途中宣言って出来たっけ

>>350
3が保証できればそれでいいのですが

例えば、funcの中でスレッドを生成し
hを渡す場合も保証できるのかなぁって
心配です。

4はオブジェクトを初期化するメンバ関数でもいいんじゃないか？

C99

>>352
最近のCはできる。

>>353


>>354
Hogeの作者が作ってくれていればそれでOKだね。
あるいはHoge h = Hoge()で初期化同然に動作する仕様になっていればそれでもOKか。

>>353
> 3.毎回新しいオブジェクトが必要かつアドレスは同じでも違ってもいい。
は保証できるだろ。

だが君が言っている
> funcの中でスレッドを生成しhを渡す場合
ってのが謎だが、

while(1) {
Hoge h;
func(&h);
}<-制御がココに達した瞬間にhは破棄されるため別スレッドがこの&hにアクセスしないこと

っていう条件が必要。

もうバカは放っておいていいんじゃないか？

規格と実装の区別も付かないどころかスコープも理解していないのに
スレッドとか言っちゃうやつにC/C++プログラミングは不可能！

これ、結論でOK。↑↑

C言語を知っているようなことを言っているが、
良く良く突っ込んでみると確かにC言語すらあやしいようだしな。

配置構文newとかwww
知識では某書で見た事ある程度だが使った事ねぇw

>>353
ローカル変数のアドレスをスレッドに渡すのはやめとけ。
グローバル変数か、newで確保したオブジェクトか、どっちかのアドレスを渡すほうがいい。
newで確保することにした場合はdeleteを忘れないように。

最適化して外に出されてない限り、たまたま同じアドレスに配置されただけなんじゃないの？

>>356
今回の記述が許されないCってどのC？

> そもそもCで変数の途中宣言って出来たっけ
↓
> 最近のCはできる。

↑のC99?の話と
>>339のブロックの先頭で変数を宣言するってのは別件でしょ
>>352がC言語の事あまり詳しく知らないだけなんだと思うけど

配置構文newってこれか！

C++編（言語解説）　第３６章　placement new
ttp://www.geocities.jp/ky_webid/cpp/language/036.html

うへぁ

流し読みしただけだけど、newのオーバーロードってことかいな？

>>366
それは分かった事にならんだろ。
自前で定義したnewとは違う意味ですよ？

>>366
普通のnewはメモリ確保も込みだけど、既に確保されている領域に
インスタンスを構築するのがplacement newってだけだよ。

placement newってイマイチよく分からんないから
newのオーバーロードで配列プールを返すようにしてるんだけど
やっぱりplacement newを使った方がいいんだろうか

どうやってコンストラクタ走らせてるんだろう？

>>367
まあ、規格的には 引数付きのnew＝配置new なんだけどな
コンストラクタを呼ぶだけのものを指す事が多いし、それが語源なんだろうけど

>>370
いや走るだろ。
配列プール作成したときと、newされたときで、2回走ることになるが。

え、二回も走らんでしょ

クラスの配列作ってんじゃないだろうね
普通型無しのメモリ領域に対して使うんだが

void* p = operator new(n * sizeof(A));
A* pa = (A*)p;
for (int i = 0; i < n; ++i) {
　new(&pa[i]) A; // ここでのみコンストラクタが呼ばれる
}

...使う...

for (int i = 0; i < n; ++i) {
　pa[i].~A(); // ここでのみデストラクタが呼ばれる
}
operator delete(p);

>>374
>new(&pa[i]) A;
これってplacement newじゃないの？

配置構文newが大人気だな。
このスレで過去に出て来たのはいつだろうと思うくらい前だろうに。

配置構文newなんてメモリ節約の基本だろ。人気も何もない。必須。

(ﾟДﾟ)ﾊｧ?
メモリ節約したいならC言語使えばいいじゃん
オブジェクト指向の恩恵を受けるんだから多少のオーバーヘッドとか無駄とか我慢しろよ！

と無駄に煽ってみるテスト

現実問題C言語は低機能過ぎて使いにくい。
というか配置構文newのどこがだめなの？これ使ってもオブジェクト指向の恩恵を十分受けられるだろ。

配置newのメリットって速度だと思ってたんだけど・・・。

配置newって、渡すメモリ領域の大きさを考慮してもらえるのだろうか・・・

>>380
newって速いの？

ﾒﾝﾊﾞ変数をpublicにすると、いけないらしいのですが、
わざわざ{ return ﾒﾝﾊﾞ変数;}なんてﾒｿｯﾄﾞ呼んでたら
遅くなりませんか？

>>383 気にすんな。 心配するほど遅くならない。

>>383 速度は実測が基本

配置newはコンテナを作るときに必要になるんだよ。
速度のために使うこともあるだろうけど。
>>381
考慮されないよ。メモリを正しく確保するのは呼び出し側の義務。

>>383
そのメンバ関数を別の翻訳単位にしていなければ、
コンパイラの最適化でインライン展開されて事実上、
全く同じコードになる。
おまけに、デバッグ時にはメンバ関数でトラップを張ったり
ログ出力したりと、効率よく対処できる。
それなりに大きなクラスならpublicメンバをデバッグするより
トータルコストが抑えられる場合が多いと思われる。
もし仮に、ほんの僅かなパフォーマンスさえ気にするのであれば、
一旦完成させた後に実測した上で、必要に応じてpublicにすればいい。

>>380
>>381
例えばMSVCのnewの実装を見てみるといい。あれは中でmallocをOSから応答があるまでwhile(true)で待ってるだけだから。（マルチスレッドでコンパイルしたプログラムは知らん）
そういう意味で確保済みのメモリ領域をOSの処理にまで委ねなくても再利用できる点では優秀だし、カスタムアロケータを使っている場合はプールで高速化を図る時に
統計的な裏づけを元にOSではなくプログラムがメモリを管理するのだから配置newがあって当然だと言える。

ハイチ乳

mallocはアロケートかわいい

配置構文new でメモリって節約できるんですか？
基本らしいですが何故節約になるのかわかりません。

趣味でC++を勉強してる人、C++を勉強する目的って何？

new HogeHogeType; ← クラスのコンストラクタに加えOSのAPIを呼び出したりするからデバッグでスタックの余裕がないと大変
new(ptr) HogeHogeType; ← HogeHogeTypeのコンストラクタしか走らないので余裕がなくてもそれなりに使える。ただしHogeHogeTypeの中でスタック浪費してると論外

shared_ptrってboostのとstd::tr1のとどっちが良いの？

配置newすると普通のnewよりはやくなるの？っていうか、普通のnew遅いよね

>>395
普通のnewが何をするか分かってる？
ネックになってるのはメモリ管理だからplacement newみたいに既存のメモリ空間にコンストラクタを走らせるだけなら速くも遅くもないけど。

再配置newの方が早い。メモリアロケートしないから。

”仕事が開始してから終了するまでの時間だけでいえば”
普通のnewの作業
=メモリアロケート作業+配置構文newの作業

である以上、そりゃもちろん配置構文newのが
普通のnewよりずっと早いさ。

だが仕事の内容が違う以上、どっちが早いとか論じるのはおかしい。

>>391
> 基本らしいですが何故節約になるのかわかりません。
節約にはならないだろう。
普通にコンストラクタを起動するだけなのだから。
もしかしたら>>377を読んで思ったのかもしれないが、
誰も指摘していないだけで>>377は普通に間違っているから
鵜呑みにしてはならない。

配置newした場所にまた配置newしたら、後にnewした内容で初期化される？
頻繁にnewする必要がある場合、どうしたら早くなるだろうか。

g++ (GCC) 4.2.1
のコードに
#include <stdio.h>
こんなのがあったんですが、どういう意味ﾃﾞﾂｶ

>>401
その部分にstdio.hの内容をコピペするって意味。

>>400
配置newしたら、対応したdelete呼ばないと悪い意味で破壊されるんじゃね。
new(GlobalPool)->delete(Pointer,GlobalPool)->new(GlobalPool)->dele...
の順じゃないとだめじゃね？

利点はメモリを確保するという動作を放棄できる。

>>402
昔からある、仕様なのでしょうか？それとも最近のC++0x 9の仕様ですか。

もうスルーでいいよ

>>402
ごめんなさい、firefoxのバグなのでしょうか
IE で見ると
#include <stdio.h>なのですが、firefoxでは
#include <stdio.h＆ｇｔ；
＆ｇｔ；この部分は半角
こうなってた、ソースコードがあったんでびっくりして聞いてしまいました。

そりゃHTMLの特殊文字だ。C++関係ない。
HTMLスレかFirefoxスレ逝け。

HTMLのソースで>が&gt;になってたんじゃね

―ッ!!?

> &gt;が&amp;gt;になってたんじゃね
のまちがい

>>404
#include <cstdio>
じゃないのが納得いかないという雰囲気でもない？

ってごめんよー続き見てなかったよー
具体的にどのファイルか教えてもらえると助かる、、、わけでもないけど興味がある

>>411
それは知らん。
人によって違うから。
#includeのルールに則って考えて見て。

普通はコンパイラのパスの通っているディレクトリで、
stdio.hって名前のヘッダを探せば一つしか無いと思うけど。

いや、GCCのコードに、だろ？

>>413
？何？？

まあいいや。

そうですね。

>>414
>>401を読めばGCCのソースコードであることは明らか
どのファイルか教えてもらえてもよかろ

可変引数を使うとときって、引数の総数が必要になる場合、
最初の引数に総数を自分で渡すとか、"%d"とか、総数が分かるような情報を与えないとだめなんでしたっけ？

勝手にスタックから自動計算して、”あ、引数はこんだけだな”って分かってくれるマクロとか無いんでしたっけ？？

それが必要になるようなら考え直すべき

>>417
可変引数は使わないほうが良いよ。

「無いんでしたっけ？」って言い方は過去にそれに関する知識を得たことをあらわす言い回しに思えるんだが、
そのときはどうだったの

boost::preprocessorでいっぱい関数定義すれば解決するよ！ するよ！

なんかあったような錯覚を覚えなくもないが、少なくとも標準ではないはず。

あ、417です。
可変引数ってもしかして人気ないんですか？

過去に使ったのは・・・va_list apをそのままvsprintf系に食わせていたので、
それ以外は使ったこと無いかも。。

人気ないです。
選択肢が限られるCならともかく、C++では完全にいらない子です。
たぶんregisterさんと同じぐらいかわいそうな子です。

え
まじですか。
C++だとどんな風にやるのがトレンドなんですか？

そもそも可変引数てどんなときに使うんだ？
Cならオーバーロードもデフォルト引数ないから、そういう用途で使われることがあったようだが、
それも「シンボル名は8文字まで」とかの制限があった時代の話だし。
あとはprintf,scanf系列くらいしか思いつかないが、streamで代替できるし。

C++でprintf相当の機能でいくと
std::ostreamだと、
std::cout << a << b << c;
書式ありのboost::formatだと、
std::cout << boost::format("%d %d %d") % a % b % c;
とか、演算子オーバーロードによる連結で
可変個引数的なことをやってる。

自分で定義したmyclassのローカルインスタンスを関数から返すと、
myclassのコピーコンストラクタがへんな引数で呼ばれるのはなんで？

myclass fuck()
{
　myclass x("hello");
　return x;
}

class myclass
{
public:
　myclass(const char * p){ppp = new char[strlen(p) + 1]; strcpy(ppp, p);}
　~myclass();
　myclass(const myclass & x)
　{
　　ppp = new char[strlen(x.ppp) + 1];　　　　//ここでx.pppが0xCDCDCDCDなんですけど。。
　　memcpy(ppp, x.ppp, strlen(x.ppp) + 1);
　}
private:
　char * ppp;
};

デストラクタにブレーク張ってるけど呼ばれてないし。。

>>427
・再現しない、ちゃんと "hello" が返る＠VC6SP6
・0xCD は、VC の Debug ビルドで新しく malloc()・new した時にそう初期化される仕様で、未初期化領域を検出する目安になる
・というか strdup() 使え
・ブレーク張ってるデストラクタとやらは何処だ

>>428
ありがとうございます。
breakは~myclass()ではっています。
なので解放はされてないと思ってるんですが。。
もう一度良く見てみます。

>>428
すみません、超ド単純なミスでした

myclass(const char * p){ppp = new char[strlen(p) + 1]; strcpy(ppp, p);}　じゃなくて

myclass(const char * p){char * ppp = new char[strlen(p) + 1]; strcpy(ppp, p);}　ってやってました・・

>>429
> breakは~myclass()ではっています。
> なので解放はされてないと思ってるんですが。。

え、意図的にメモリリークしてるの？
意図は分からんが、そうしたいなら ~myclass(); じゃなくて ~myclass() {} と書くべき
~myclass(); だけじゃただの宣言で、定義になってない

試しに例外禁止してやってみたら思ったよりめんどくさかった
知識もないとバグだらけにもなりそうだし素人にはお薦め出来ないな

>>431
はしょってるだけです。
あとホントの開発コードは貼れないんで意味的に同じになるようにサラっと書いたコード（myclass）なんで
あまり深く突っ込むのは勘弁してください。。

>>388
そのループは new_handler を呼び出すループじゃないのか？
OSからの応答をループで待つとか間抜けなコードが使われてるとはにわかに信じがたいな。

>>433
問題の発生する最低限のコードを書き出すくらいはできるだろ
っていうか、それが質問者のマナーであり常識
でないと本来1レス程度で解決できる問題が今回の様にだらだら長引く事になる

偉そうにｗ

マは総じてスルースキルが低いからこうなる
小言言ってないで無視すればいいのに

偉そうじゃなくて偉いんだが

ｐｇｒ

>>424
可変長引数は、引数の個数も型もコンパイル時にチェックできないから危険なのね。
>>426のほうほうなら型がコンパイル時にチェックされる。

少なくとも
自分以外の読者がいるという事実は気に留めておけば良いと思う。

>>440
静的型の言語だと、簡単に可変長引数を実装できる構文って作りにくいのかな
C++0xのinitializer_listでも単一型しか受けられないし
JavaもObject[]で型チェックなしだし

そんなあなたにvoid*

templateで可変長もどき美味しいです

boost::fusionで可変長もどきとか

>>417
そのとおりです。f(...) はできない。

sizeof(bool) が１みたいですが、
true false
しかないのに、なぜに１バイトも占有するのでしょうか？

1bitだけ確保したらalignmentがめちゃくちゃになるから

sizeof(bool)が1っつー保証すらないが

でもsizeof(bool)は1の倍数

std::vector<bool> でも使ってればいいよ
C++03まで限定の命だがな

C++0xでもvector<bool>はそのまんまだけど

GWなのにスレが伸びるなあ

プログラミングの勉強は、2chブラウザで常駐スレ一覧の更新をチェックしたのち、
勢いの速いスレを自動更新にしながらモニタの前に本を置いて読むに限る

プログラミングの基礎学んだら
アルゴリズム？デザインパターン？に進めばいいの？

>>455
とにかくコードを書け。アルゴリズムもデザパタも書かなきゃ理解できない。

そうですね

>>456
はい。入門書からコーディングは自分でやるようにしてます。

Visual Studio2010 Expressが出たけど、これってつまり、
今Visual Studio 2008 Express版持ってる人は2010に乗り換えた方が良いってこと？
割と最近このスレで2008EX版勧められて導入したばかりなんですけど・・・・

>>459
欲しい新機能がなければ急いで替える必要はないなって言うのが、俺の率直な印象。
時々IDEが黙るし、マウスのホイールの移動量がおかしいし、早くSP1が出ないかなと思う。

>>460
分かりました。もう少し様子見てみることにします。

>>456
逆だろ？
コーディングなんて猫でもできる

仕事できない奴の典型、アルゴリズムが頭に浮かんでないのに
行き当たりばったりでコーディングを開始する奴

どっちなんだYO！ｗ

コーディングなんて工数を占める割合は２割以下
設計仕様　　　５
コーディング　２
デバック　　　　３

位だろ。

ずいぶん優秀な猫だな。

我輩は猫でないし、名もある

でもまあ確かに無から有はうみだせませんから、
そういう意味では知識と組み立て（段取り）が頭の中にあらかじめ入ってないと意味内ですよね。

鴎外先生ｷﾀ━━━━━━(ﾟ∀ﾟ)━━━━━━ !!

鴎外？

山芋は眠らない　（・｀ ,_ゝ・´）ｷﾘｯ

いまどきウォーターホールでやってるところってあるんかね？

仕様なんて最初の段階じゃ良くて7割しかきまらないような・・・
作っているうちにより良い手立てがあることに気づくことってざらだよね？

おれが設計素人なだけかもしれんが・・・。

そもそも顧客自体もほしい物がわかって人っていないよね？

C++以外のことですまねえ。

実際に手を動かしてモノを作ってる人じゃないんだろう

>>471
仕様なんて決まらないじゃない、決めるんだよ
確かに、顧客自体もほしい物がわかって担当がいるが
そういう時はラッキー、こっちの言いなりで決めれてしまう。

後で変更になったら、追加を請求できるし。

＞作っているうちにより良い手立てがあることに気づくことってざらだよね？
まず、ない
それは設計自体に問題がある。深く考え込まれていない証拠。

まぁ、数十人程度でやってるなら、それでもいいが、１００人以上で
開発しているプロジェクトだと、コーディング途中に設計変更なんて
考えられない

素人だからよく解らんけどゲームとかって仕様変更しまくるんでしょ
こういう場合はスパイラルモデル？っていうのがいいのかな？

水穴？ウォーターフォールだろ…ってのは置いといて
残り三割を決めるためのスケジュールを
「最初から」全体計画に盛り込めないことは多々あるな
下請けの辛い所だよ

俺のノートPC、1024x768なんだよね…
VS2010のバカタレ

>>474
どかたの方にわかりやすく言うと、道路工事中に水道等をぶち破ったら、
あなたはどう思います？普通は
「設計！、調べんだろ普通！！」って感じで怒鳴りつけるでしょ

それと一緒、コーディングなんて、やってる最中に、これじゃ成り立たない
なんてわかったら、設計者として無能

仕様変更に弱い糞プログラムしか書けないということはわかった

ゲームの場合はスクリプトを読み込むエンジン作っておいてあとから柔軟に対応できるように作っていたら
いつの間にかエンジンの方ばかり変更してしまってスクリプトを全然弄らないという事が結構あるなー

>>473
うむ、正しいな
数十人どころか数人でやっていても金と工数を貰わない限り設計変更なんてお断りだぜ

どかたと違って瞬間復旧ができるかんな

土方と違って徹夜が多いぞ

所詮、趣味でやってるようなｦﾀには分からないだろうな
設計なんてなくて、いきなりVC++立ち上げるような連中だろうからなｗ

仕事でしかコード書かないんじゃ1年に数千行くらいしか書かないじゃん。そりゃまともなプログラム書けるようにならないよ。

>>483
だから、コードを書くか書かないの問題ではない、ソフトウェア工学を理解できるか否か
が重要であって、プログラムを書くなんてのは仕様さえ決まれば、なんてことないんだよ

まぁ、商用に耐えうるプログラムを書いたことがない君には分からないだろうけどねｗ

>>474
仕様変更つったって、ほとんどはコードの極一部にしか影響しない変更ばかりだよ。
全体に波及するような変更は、たとえやりたくても予算と納期が許さない。

かくして、初期の的外れな仕様のままマスターアップを迎え、
世には箸にも棒にもかからない駄ゲーがあふれることになるのだが、それはまた別のおはなし。

スレち乙

C++相談室ですよ

日本の技術者はコードなんてあんまり書かないよな。設計が主業務だからな
コード書くのはコーダーの仕事で技術者がなんで
そんなことするのって感じだからな。

コードも碌に書かないやつが何でソフトウェアの設計ができるんだって話だよ。
結局下請けに丸投げで客と下請けの連絡係なんてしてるから仕事の効率が悪いんだ。

お前らいつも偉そうなこと言って人を見下してるけどそんなに自信があるならなんで独立しないの？

でも、効率悪かろうが下請けよりはるかに良い給料貰っているんじゃね

たいしたプログラムかけないのにずいぶん偉そうだな
悔しかったら晒しみ

こういう技術に興味のない奴らが技術がなくても食っていけるように人売り派遣の仕組みを作って日本のソフトウェアをダメにしたんだろう

日本が駄目になろうが、自分らが金儲けできれば良いって考えは
日本人なら普通じゃないの？　
で、いまや人売り派遣がないと困る下請け多いんじゃないの？

ストライキしよーぜ

金儲け目的で生きてて楽しいの？何のために生きてるの？生きてる意味あるの？

じゃぁ、おまえさんは何のために生きてるの？

生きるのにいちいち意味だの目的だの考えるのは
そういう趣味ならいいけど、必要だと思ってるなら救いようのないヴァカ。

おまえら何度スレチと言わす気だ

C++相談室だぞ。
職場環境相談室じゃねーんだよ。

まったくだ、なんの為にム板とマ板に分かれてると思ってるんだ

・・・という話を続けるのもスレチではあるのだが

namespace hoge {
class Test;
}
class Test;とするとclass Test{}と同じ意味になるのですか？

ならない

宣言と定義は違う

それじゃ、前方宣言なのかな？
class Test;
namespace hoge{}
って、普通なら書く気がすんだけど

namespace内に閉じこめるかどうか

::Test じゃなくて
hoge::Test を宣言したかったんでしょ

>>506
thx

namespace hoge { void __stdcal fuga(void); }

この関数をDLLにしてエクスポートするにはどうすればいいんですか？

>>509

DLLって何ですか？
ここはC++相談室ですけど。

えっとtemplate template....何とかって知っている？
使ったことある？

とあるソフトの設定ファイル関係のクラスを読んでいます
メンバ変数をpublicにしているようですが、お前らだったらprivateにする？

privateにする理由がわからん。
外から書き込まれるのを禁止したかったら、コメントを入れておけば十分

privateにして、わざわざアクセサ書くの面倒だし、無駄なオーバーヘッドあるし。

privateにしたほうがいいんだろうなあ
と思いつつも面倒だからpublicにしてしまう

複数でやってるようなプロジェクトならprivate/protectedにしてget/setﾒｿｯﾄﾞを
実装するのが普通だろうが、一人でやってるようなものはすべてpublicでOK

アクセサならまずinline化がきくから、実行時オーバーヘッドは無いだろ。

一人でやっていようがメンバ変数はprivateだろ。

>>516
中途な知識でinlineなんて言葉使うと突っ込まれるぞ
ちなみに、inlineとしてコンパイラからみえないこともあるんだぞZ

以前、設定ファイルをprivateにしたときは、
get/setだらけのクラスが出来上がって気持ち悪いことになりました

でも、publicだらけにするのも気持ち悪い

ただ読んで使うだけならいいかもしれないけど、
後でエラーチェックが必要になったときとかにその変数にアクセスしてる全ての箇所を
修正するのとget/setの中だけ修正するのとどっちが仕様変更に強い良いプログラムかってことだな。

＞inlineとしてコンパイラからみえないこともあるんだぞ
どういう意味か教えてほしい

>>521
inlineとしても展開されないことがあるといいたいんだろう。
でも展開されないアクセサはまずないだろう。

>>519
そのような値を持つだけで機能が無いものは構造体にしてもいいと思うよ。
機能を持ち、メンバー変数を隠蔽するのはclassでと使い分けるのもいいと思う。

他人が書いたコードを読んでいたら
「GetER()->AddErrorMessage("エラー")」という箇所がありました。

エラーを処理しているメンバ関数みたいなのですが
なぜ関数にアロー演算子がついているのでしょうか？

GetER->AddErrorMessage("エラー");
ならオブジェクトポインタから関数にアクセスしていると分かるのですが･･・

>>524
ヒント： 戻り値

>>524
CFoo* GetER();

ってな、感じで宣言されていませんか？

>>526
はい、されてます！
こんな感じになってます。
static CErrorReport* GetER(){return &m_ErrorReport;};

ちなみにm_ErrorReportは下記です
static CErrorReport m_ErrorReport;

>>527
GetEDがCErrorReportへのﾎﾟｲﾝﾀを返すんですよね
だから、その戻値をアロー演算子で参照して、AddErrorMessageﾒｿｯﾄﾞを呼んでる

って感じですね

>>528
ありがとうございます。
戻り値をアロー演算子で参照ですか・・・。

やっている事は何となく分かったのですが、どうしてそんな間接的な方法を取るのでしょか？
直接オブジェクトから呼び出してはダメなのでしょうか？

>>529
簡単に書くと（クラスの中）

CErrorReport* errorReport = GetER();
errorReport->AddErrorMessage("エラー");

と２行で書いていもいいんですよ
GetER()->AddErrorMessage("エラー");

と書いたほうが１行でかけますよね？

ただ面倒でかつ、errorReportの使い道がそこしかないなら、

間接段階があると、あとからなにかあったときとか、なにかと便利なのだ。

>>530
あら、日本語がおかしくなっちゃったｗ

ただ面倒でかつ、errorReportの使い道がそこしかないなら、
GetER()->AddErrorMessage("エラー");
と書いたほうが１行でかけますよね？

＞どうしてそんな間接的な方法を取るのでしょか？
static CErrorReport* GetER(){
    return m_ErrorReport.isValid()
        ? &m_ErrorReport
        : m_ErrorReport2.isValid()
        ? &m_ErrorReport2
        : 0
        ;
};
みたいなことができるから。

hoge()->hoge2()->hoge3()->hoge4()…とかね

haskellたのひ

なんか話がごっちゃになってるな。
>>531>>533 は関数の実装側にとってのメリットの話。
>>530>>532>>534 は関数を呼び出す側の記述スタイルの話。

質問者さ〜ん、ついていけてますか？ｗ

ポインタ返すのにぬるぽチェックしないのとか
この値は開放しなくていいのかなとか
なんか気になるんですけど
みなさんはそうでもないんですか？

自分だけのテストソースなら気にしない

返却値のNULLﾁｪｯｸなんてやってたら、面倒でしかたないよ

普通、例外処理でしょ

だったら参照返してくれって思うんだけど
わざわざポインタで返すってことは暗に無効値を返すぜって言ってるようなもんだろう

参考になるのでこのスレ見てる初心者の疑問なんですが
参照を返した場合それの解放ってどうするんでしょうか？
ちなみにあまり一連の質問応答にはついていけてません
ただ、参照を返すという一言を見て生じた疑問です

返値が参照の場合、ふつうそのオブジェクトの所有権は呼出先のクラスなり関数なりにある。
よほど変な設計になっていない限り、呼出元は解放処理を気にする必要はない。

Foo& foo = obj.GetFoo();
delete &foo; // obj < おいやめろ馬鹿！

つくったとこが解放するのが常識

値を取得できたってことは，そのクラスでつくったってこと

あとはわかるよな？

class base
{
int x;
};

class sub1 : public base
{
};

class sub2 : public sub1
{
};

・・・

class sub10 : public sub9
{
};

みたいな感じで継承を繰り返すときに
sub10から一発でxを初期化する方法はある？
仮想継承はコストがかかるので無し
引数でリレーするのは書くのがめんどくさいです

>>538
そもそも、アプリの上位のレベルでdeleteを書かなくちゃ
いけない様な設計は危険すぎると思います。

普通はスマポか内蔵参照カウンタ使うよな

実装の途中段階から参加すると
そういうインターフェースがごろごろ転がってるから油断ならない

>>543-544
ご回答ありがとうございます

そういうケースでは参照で返したらいいんじゃないかっていう話だったんですね
関数、参照で返すしか見てなかったためにあほな質問してすいませんでした

>>545
sub10::sub10() { x = 1; }

無理じゃね？

コンストラクタで代入はできるけど初期化リストでは無理な気がする

ごめんなさい
見なかったことにして下さい

class base{ public: int *px; base() : px(static_cast<int*>(::operator new(sizeof(int)))){} };
class sub10 : public sub 9{ public: sub10(){ new(base::px) int; } }: //初期化リストは使えないけど関数内部でplacement new

そういえば仮想継承しないのはコストが嵩むからだったな。
pxに動的なメモリ空間を入れるのも気に食わないだろう。boostのalignment_storageでメンバに持つように書くといい。

初期化リストは使えないの？

xはbaseのprivateなんだからbaseで面倒見るべき
遙か彼方の派生クラスからいじくろうと思うこと自体が間違い
設計に問題がある

メンバ関数testMethod
メンバ変数mTestobj、sTestobj
クラスClassTest
って感じの命名規則でおk？

sTestobjの接頭子sてなにーーーーーーーーーーーーーーー？？？？？？？？????？？？???????????？？？？？？？？？？？？＾−＾

命名規則なんて上が決めるからどうでもいいよ

>>558
staticのs
この命名規則はaroraってブラウザで使われていた

>>559
職場はVBとC#

システムハンガリアンはキモい……

C++で関数の引数で以下のような場合は各関数a,b,cが評価される順序は不定だそうですが、,演算子の場合や、コンストラクタの初期化子の場合も同様ですか？

int n=func(a(x),b(y),c(z));　//関数

int n=a(x),b(y),z(z); //,演算子

hoge(int x,int y,int z):m1(a(x)),m2(b(y)),m3(c(z)){} //初期化子

>>562
カンマ演算子は左から順番に評価されると規格で決まっています
初期化子はその並び順は無視して、そのメンバ変数(メンバ変数と決めつけちゃったけど)の宣言の順番で行われます

二つほど疑問点。
カンマ演算子はオーバーライドしたやつ(boost::assignとかの)は違うんだっけ？
あと、関数の評価順序が不定っていうのはa(),b(),c()に副作用がなければ関係ないんだっけ？

>>563　早速の回答ありがとうございます。評価順がはっきりしたので安心しました。

初期化子の評価順に従えばメンバーを参照して初期かも可能なのでしょうか？
たとえばこんなかんじ。
class hoge
{
int m1;
int m2;
int m3;
public:
hoge(x)
:m1(a(x)
,m2(m1+b(x))
,m3(c(m2))
{
}
};

>>564
> カンマ演算子はオーバーライドしたやつ(boost::assignとかの)は違うんだっけ？
オーバーロード？
> あと、関数の評価順序が不定っていうのはa(),b(),c()に副作用がなければ関係ないんだっけ？
関係無いって何？関係はあるだろうが、結果には影響が無いね。
不定なだけで、順番は処理系依存ではあるが、実行はされるから。

>>561
その例はアプリケーションハンガリアンだと思うよ。
メンバーを示すためにプリフィックスmをつけるのは有益だと思う。
記憶クラスの間違いは型チェックだではコンパイルでチェックできないからね。

C++は型情報を多相性で曖昧に判別できるからせっかくのその機能を命名規則で台無しにするなんてできないな。
staticとかならいっそのこと、変数名にそのままstatic_hogehoge_valueという風に組み込んでしまった方が分かりやすいし。

>>565
いいけど注意して書けよ

>>569　うんわかった。注意して使うことにするよ。ありがとう

>>565
VC++2008でやってみたら　初期化の場合は宣言されてる変数順っぽいかもよ
初期化部分が
hoge:m1(1), m2(m1+1), m3(m2+1)
として
int m1,m2,m3
と
int m2,m1,m3
だと結果が異なった

＞初期化の場合は宣言されてる変数順っぽいかもよ
>>563の人が
＞初期化子はその並び順は無視して、そのメンバ変数(メンバ変数と決めつけちゃったけど)の宣言の順番で行われます
とすでにいっているんだけど

>>572
ごめんなさい。>>565に驚いちゃって見落としてました。

先に初期化して欲しい変数は、それ専用の基底クラスに持たせるかな
宣言順でもいいけど意図が伝わらないと困るかもしれない

enumの定義でtypedef使う場合と使わない場合の違いってなんでしょうか？

>>575
エスパーしたんで要点がズレてたらすまんが、機能的には同じ。
もともと、C言語では
enum Hoge {
ABC,
};
と書いたら、使うときも
enum Hoge h = ABC;
~~~~~
みたく、明示的に enum を書かないといけなくて、長ったらしくて面倒なのでtypedefしてた。つまり、

typedef enum Hoge {
ABC
} Hoge;

と書いておくと、enum Hoge に Hoge という名前がつくので、
Hoge h = ABC;
と書けるようになって便利だった。

C++では明示的に enum と書かなくてもいいよ、という風に規約が変わったので、typedefは不要になった。（文法的には正しいので使えるけど）
typedef struct ... も同様の理由。

C++で書くなら typedef は不要、と考えていいとオモ。

>>576
ありがとうございます。スタイルの問題なんですね

>>434
信じがたいというかタダの嘘だよ
シングルスレッドでそんなの間抜けなコードじゃなく不可能なコードだし。

雰囲気よくってなってんな

>>576
みたいな初心者に優しい方ばっかならいいのにな

struct hoge
{
hoge(int x) : m_x(x), m_y(get_x())
{
}

int get_x(void) const
{
return m_x;
}

int m_x, m_y;
};

これって未定義？
get_xの時点で暗黙にthisを使ってるからアウツだよね？

>>580
分かって使うならいいんじゃね？

thisを使うのは別に問題ないだろ

初期化の順番は保証されてるから問題は無いと思うが
初期化式でthisを使うのは警告出る場合もある

>>583
VCは警告出るね。抑制してるけど。

システム全体で使う設定ファイルを扱う関数に付いて

お前らなら「singleton」 or 「staticだけのクラス」 or 「クラスに属していない関数」 or その他
のどれを使いますか？

singletonかsingletonですらない普通のクラスのどちらかだな

singleton>=staticのあるクラス
singletonが使えるならsingleton。後は気分

Singletonかなぁ。
読み込むタイミングと書き戻すタイミングを制御したい時は
どうせInitialize,Finalizeみたいな関数用意することになるからmonostateにしてまうかも。

singletonは基本的に高度なグローバル変数だから
使わないでいいなら使わないに越したことは無い

普通のクラス+それをラップしたシングルトン

参照カウントで複数オブジェクトをディスる

結論、>>585は自分の好きな方法を使え

シングルトンは全部staticなクラス同士の初期化順問題を回避するためのものであって、
全部staticなクラスはシングルトンの代替にはならない

逆に言えば初期化順がどうでも良ければmonostateの方がよろしい

シングルトンには破棄側に問題がある事があるからなあ

そんじゃ、monostateパターンを使うことにするよ

お前らやさしいな、ありがとうよ

深い知識はないから、具体的に質問されると下向いて閉口だがなｗ

あとはクラスとしてまとめる必要があるか、かなあ。
なかったら只の関数でも十分。

>>585みたいなのはnamespaceに全部突っ込んでるけどこれはダメなのかな
どうせインスタンス作らないんだからclassじゃなくてもいいだろって考えなんだけど

クラスにすればprivateメンバとかテンプレートが使えるよやったねたえちゃん

privateだとヘッダ書き換えるのめんどくさくない？
実装側に無名namespaceで書けばヘッダ書き換えなくていいから楽だなーと

テンプレートは全然考えてなかった
というかまだ使いこなせない

>>599
意味もなくインスタンスを生成するのはキモいですね

クラスはnamespaceに属させないで、>>599のやり方の時だけnamespaceを使うのは非常識ですかね？
テンプレートは全然わからない & わからないので、使うつもりは無いです

どっちの実装も見たことあるな。
用途にあった方を使えばいいんでね？

template入るとソースと分離出来ないから隠蔽するならprivateするしかない
そして隠蔽しなくてもクラスにした方ができることが多い
継承したりtemplate引数に渡したり

自分でつくったクラスvarにoperator[]を作ったら多次元配列できますか？

実装は
var * operator[](int idx){return parray[idx];}

ここでparrayはメンバで、以下の様にします。
var * parray;

使う側が
var x[2][3]とかやります。
次に
var v = x[0][1];
とかやります。
するとまずoperator[]が引数idx=0で呼ばれて、var*を返し、次にvar*の一時オブジェクトに対して->operator[](1)が
コールされるとかそんな感じに動きますか？

あ、まちがえた

>ここでparrayはメンバで、以下の様にします。
×var * parray;
○var ** parray;

動くかどうかは知らないけど
分かりづらいから
やらないほうがいいと思う

>使う側が
>var x[2][3]とかやります
この時点で多次元配列なわけだが…

>>608
C/C++に多次元配列は無いわけだが…

さすがにそれはねーよ

>>607-608
配列の[]とoperator[]って別モンなんですかね？？

別モンです。
var x(2, 3); とかやって x[1][2] みたいなことはできる。
ちなみに返すのはポインタ(var *)じゃなくて参照(var &)な。

>>605
これで２次元配列だ。
std::vector<std::vector<var>> array;

俺、>>605じゃないけど
var x = A[i][j];　や　var x = B[i][j][k];　を実現する　
operator[]ってどうするんですか?

>>614
返り値にまたoperator[]する感じ
つまりすごいめんどくさい

>>614
考え方としては>>613が基本。

var& var1::operator[](int ind);

var1& var2::operator[](int ind)

var2& var3::operator[](int ind)

好きな次元だけ繰り返す。

>>615
えっ、次元の数だけ型に合わせたoperator[]を用意するんですか＞＜
力任せじゃなく賢い方法無いですか

こういう時のために神はテンプレートを創った

>>617
っMoreEffectiveC++

神はじゃなくて禿はだろ

Boost.MultiArray

>>617
そんなあなたにテンプレート。
つ>>613
つboost multi array

template作ったの禿げ神じゃないでしょ。禿げ神はパクッタんじゃなかったっけ

流れ読まずに何でもかんでもboost勧める奴って馬鹿なんじゃないかって思う

原理が知りたけりゃ実装嫁って話だろ

boostはデザインパターンの実例の宝庫だからな。使うだけでも勉強になる。

お前らが今までC++(ひいてはC言語)の勉強にどんな本読んできた？
どんなフローチャートで勉強したら良いか、の参考にしたいから是非勉強した順に教えて欲しいな

×お前らが
○お前ら

猫でもわかるシリーズ一択だろjk

この質問者のレベルでboostのソース読めるわけねーだろ

読めなきゃステップ実行でも良いんじゃないか

>>627
猫でもわかるC言語
Windowsゲームプログラミング
C++ 入門書の次に読む本
Boost C++ Libraries プログラミング
Modern C++ Design
Effective C++
More Effective C++
Exceptional C++
Exceptional C++ Style

>>632
C++の入門書がねーじゃん

言語仕様（非C部分）は次読のサンプルコード打ちながらSTLのソース追いつつ覚えた。

exceptionalなぜか大学の図書館においてないから困る

>>632
THX
やっぱ猫でもわかる〜で導入の後、WinAPI（？）か・・・、俺は今「基礎からのC」で勉強中なので先が長いなあ。

他の人達も>>632みたいな感じで書いてくれると助かる。

ググれカス

いや、ググっても他人の勉強歴ってあんまり出て来ないよ・・・・・
貴重な情報の一つだけどネットには中々転がってない情報でもある気がする

昔の人間に聞いても古い本が出てくるだけじゃないかな
C++の昔の本は仕様が古い場合があるとか（iostream.hとか）
Cを長く使った上でC++を適当に覚えたとかあるから、
今の人には役に立たない事も多いと思う

>>638
プログラミングの本って面白くないよな
例えば、例題が「女性の平均バストを求めよ」とか少しやる気出るのに

「結城浩」はわかりやすくていいよな
でも、俺は絶対に本でプログラミングの勉強をしたいと思わないな〜
オライリー本は高い&難しいからやめといた方がいいよ

その程度でやる気が出るお前がおかしい。

サンプルフォームの内容がことごとく「宇宙人」「異世界人」「これを衆目に晒すというのか」
だったりピクチャボックスが自作の萌え絵だったりする本でVC++(C++/CLI)勉強したけど糞も面白くなかったぞ。

>>640
？？
いや、プログラミングの本って自分は大好きですが・・・

エロに絡めて勉強って言うのは斬新で効果あるかもしれないな
ぶっちゃけPC覚えた理由ってエロ目的じゃん俺らって
あれと同じノリで簡単なエロツールを作るのを目的に
プログラミングを勉強していくのっていいんじゃないだろうか

>>642
おっと赤坂玲音さんの悪口はそこまでだ。

>>644
エロが目的でコンピュータ&プログラミングを覚えたわけではないが、
エロのためにコンピュータ&プログラミングを使っている点では俺と同じ

↓のようなコードを作ってみたんですけど、最初のwhileの所で、2周目以降のループでは
scanf関数が飛ばされて（？）、printf関数が2連続で並んじゃって意味不明になってしまう・・・・・
あと、2つめのwhileループでも、アルファベットで入力すると無限ループになってしまう・・・・・orz
何が原因なのでしょうか。どなたかご助力をお願いします。
※#include<stdio.h>、#define TSUUJOU 0、#define URUUDOSHI 1です。
※main(void)や配列の初期化や、最後の文字表示の部分は簡単なので飛ばしています。


while((which!='y')&&(which!='n')){
printf("通常の年ならyを、閏年ならnを入力してください。");
scanf("%c",&which);
if((which!='y')&&(which!='n')){
printf("入力ミスです！\n");
}
}
while((month<=0)||(12<month)){
printf("何月についての日数を見ますか？");
scanf("%d",&month);
if((month<=0)||(12<month)){
printf("入力ミスです！\n");
}
}

※#include<stdio.h>、#define TSUUJOU 0、#define URUUDOSHI 1です。
↑これは余計でした。すみません。

無駄な括弧が多いくせに空白が少ないから読みづれぇ

while (which != 'y' && which != 'n') {
　printf("通常の年ならyを、閏年ならnを入力してください。");
　scanf("%c", &which);
　if (which != 'y' && which != 'n') {
　　printf("入力ミスです！\n");
　}
}
while (month <= 0 || 12 < month) {
　printf("何月についての日数を見ますか？");
　scanf("%d", &month);
　if (month <= 0 || 12 < month) {
　　printf("入力ミスです！\n");
　}
}

＞printf関数が2連続で並んじゃって意味不明になってしまう
２度目は which に改行が渡されるから

＞アルファベットで入力すると無限ループになってしまう
%d に対してアルファベットを入力すると
scanf が失敗して永遠に %d が出てこないので無限ループになる
scanf の戻り値を確認して、失敗したら１文字飛ばしてもう一回 scanf するといった処理が必要になる

ありがとうございます。読みづらくて申し訳ないです。さっきは間違ってTabスペースを消してしまいました。


>戻り値を確認して、失敗したら1文字飛ばしてもう一回scanf
すみませんこれがよく分かりません・・・・いや言ってることは分かるのですが方法が全く浮かばなくて・・・・

scanfなんぞ使わずに fgets+sscanf にすれば万事解決なのだが

scanf は入力が終わった場合かエラーになった場合にEOFが返ってくるので、
まず、EOFが返されたらループは終了しないといけない

入力があっても、%d に相当する入力（要するに数値）でないと失敗して 0 を返すので
この場合は１文字読み飛ばす（要するに getchar する）必要がある

ああ、仕様によっては１文字じゃなくて１行丸ごと読み飛ばす必要もあるわな
その場合は
\n が出てくるまで fgets しても良いし、
\n が出てくるまで getchar しても良い

>>651-653
ありがとうございます。
今読んでる本の索引で調べてみたんですけど、この本（基礎からのC）だとgetcharとかsscanfの使い方が載ってなかったですorz
で、fgetsについてはまだ読んでない関数・構造体・ポインタのページで解説されてるようですし、
皆さんのレスを読んでいると、恐らく1文字読み飛ばしたりするのは自分にとって未習の知識なのではないかと思いました。
なので、せめて読み通すまではオリジナルのコードを書くのはあまりしないようにしておきます。
すみませんでした。

C/C++の入出力ライブラリは曲者揃いだから
勉強でやってるならあんまりそこで詰まらない方がいいよ
もっと大事なことがいっぱいある

「詰まらないようにする」とは要するに、分からない部分があってもサッサと先に進んで、
その後で辿ってきた道のりを概観してみろ、ってことですよね

そうね
後で分かる事もあるし

getcとケットシー

入出力なんてただの一機能に過ぎないし
はっきり言ってC/C++の入出力ライブラリって出来悪いしな

どうしても標準出力に吐く所から勉強が始まるもんで
それだけ見てプログラムとはこういうもんなのかと嫌いになる初心者が結構いるから

stdioはまだ許せるけどiostream、オメーはだめだ
ios_stateなんてのが出てくる時点で欠陥品

コンソールじゃなくてMassageBoxとかから教えた方が初心者はやる気でんのかね？標準じゃないけど

ファイルを本格的に扱うにはiostreamよりWin32API直接が確かに楽だね

#include <malloc.h>

class T1{
public:
　　　void* operator new(size_t size) { return malloc(size); }
　　　void* operator new(size_t size, size_t n) { return malloc(size); }
};

class T2 : public T1{
public:
　　　void* operator new(size_t size) { return malloc(size); }
};

int main(){
　　　T1 *t2 = new(1000) T2;
　　　return 0;
}


これを実行すると、
「error C2660: 'T2::operator new' : 関数に 2 個の引数を指定できません。」
というエラーが出るのですがなぜでしょうか？
T1の「 new(size_t size, size_t n) 」が継承されているはずなので、エラーにならないと思ったのですが…

まずはstaticにしよう

std::iostreamは高度な処理には向いていないが、
だからこそ意義があるんじゃない？
例えば広く使えるライブラリの文字列処理とか。

operator==とoperator>をオーバーロードすれば
operator>=も自動でオーバーロードしてくれるんですか？

してくれませんが、自動化するテクニックはあります

そういうわけではありません。

>>666
それをやられると困るシチュエーションが考えられるから
(思い浮かばないけど理論上はね。)
それはない。
自動化させるテクニックはあるよ。
boost operator
でggr

６６６です。ありがとう！

668です。どういたしまして！

#include<stdio.h>
int main(void){

int a,b,c,max,mid,min;

printf("異なる３つの整数型データをお入力してください");
scanf_s("%d%d%d",&a,&b,&c);

if(a>b){
max=a; min=b;
}
else {max=b; min=a;}

if(c>max){
mid=max; max=c;
}
else if(c>min) mid=c;
else mid=min; min=c;

printf("大-->%d\n中-->%d\n小-->%d\n",max,mid,min);

return 0;
}

異なる３つの整数を入力して大中小を判定するプログラムです。
これでコンパイルにはエラーがないのですが、実行結果が大と小が同じ値になってしまいます。
どこが間違っているでしょうか？

{}が足りない

どこに足りませんか？

else mid=min; min=c;

else { mid=min; min=c; }

else mid=min; min=c;
を
else mid=min, min=c;
か
else{ mid=min; min=c; }
に書き換えよう！
中括弧で囲まずにステートメントを「;」で終了するとif分のelse分が最初のひとつで終わってしまうぞ！

それはelse文の中が複文だからですか？

>>675>>676
ありがとうございました

676です。どういたしまして。

なんか最近みんな言葉づかいが異常に丁寧だな。
>>672のメッセージも「お入力してください」になってるし。
流行ってるの？

max=c;
mid=max;

これはmaxにcを格納して、maxをmidに格納するといういみですが、イメージとしては


｜｜　ｃ　｜｜
｜｜＿＿＿｜｜　
｜＿＿＿＿＿｜ 大きい箱がmid　小さい箱がmax

こんな感じでいいでしょうか？

>>680
ただのミスですｗ

何？
イメージとか言われても全然分からん。

どこの言語 出身の方？
少なくともC系列じゃないよね？

６８１は図がずれましたが、c系列です・・・

失礼しました

>>681
宣言を書いてくれないと分からん

「変数は箱だ」という説明から生じた誤解のような気がする。

a = b という代入は、
aという箱の中にbという箱を入れているのではなく
aという箱の中にbという箱の中身を入れている。

>>680
日本語を誤って使ってしまっては元も子もありませんが、言葉遣いを丁寧にするというのに流行などは関係ありません。
普通です。

>>687
細かいこと言うと、複製してるだね、
中身を入れるだと移動と取られかねない

>>684
C系列なのにその誤解は・・・
と思ったら>>687「変数は箱だ」と教わったという事か。

そんなクソみたな例えは止めて、
C/C++でプログラミングしたければ
「メモリ」っていうものについてちゃんと真っ向から向かい合った方がいいよ。

そうだな
「箱」の例えでいいのはBASICだな
C/C++は箱の概念だと間違いなくポインタでつまずく

つまずいて理解を深めればいいじゃない

>>689
メタトロンはそのまま移動だよ。

まあ苦しむのは俺じゃないからな
苦しめ苦しめ

苦しんだ人間がめちゃくちゃなコードを書いて保守する人も苦しめる

最終的に>>694まで回ってくるんですね。

>691
ポインタは箱にそれぞれ異なった内容のラベルが貼ってあってそれを書いた紙で考えればいいんじゃないの？
ポインタへのポインタは、「ラベルの内容が書いてある紙が入った箱」のラベルが書いてある紙、で。

http://www.amazon.co.jp/dp/4774121770

newで確保した値を別の関数にアドレスで渡してdeleteするのって大丈夫でしょうか？

関数Aで「obj.table = new int[ 10 * 10 ];」ってやって、
それを関数Bに渡して「delete[] &obj->table;」とやるのはどうなのでしょうか？

関数AがコンストラクタでBがデストラクタだとしたら普通だな

>>699
大丈夫だけど、確実にdeleteされる保証がもてないならしないほうが良い。

それと、なんで　delete[]　obj.table;　じゃないのだろうかと思う。
というかコンパイルエラーになると思うんだが。
どうしてもやるなら　delete[] (&obj)->table;　だと思うな。

>>663
T2::operator new で T1::operator new が隠されている。
http://www.fides.dti.ne.jp/~oka-t/cpplab-hide-overload.html

>>699
できるけど std::vector<int> を使っとけ

class X
{
void *operator new (std::size_t size) { return ::operator new (size); }
};

class Y
{
static void *operator new (std::size_t size) { return ::operator new (size); }
};

動作を見た感じは同じなんですが、上下で違いはありますかね？

>>704
static付けても付けなくても同じ。

ありざす！

>>704
リンク時に関数が外に見えるかどうか、だったかと。

え？

だったかと(ｷﾘｯ

>>707 ここはC++スレです。

configureオプションに以下のようなものがありますが、
これはプログラマーが任意に作成することができるオプションなのでしょうか？
これをコンパイルすると、マクロが定義され機能のON/OFFが出来るってことでおk？

>--with-gthread
> pthreadの代わりにgthreadを使用する。
>--with-[native|core2duo|athlon64|atom|ppc7400|ppc7450]
> CPUに合わせた最適化
他にはalsa、pangoの設定等など

どこの誤爆？

WS_SIZEBOXだと境界線が出るんですが
クライアント領域がサイズ変更可能で境界線を持たないウインドウはどうすれば作成できますか？

C++の話題じゃないな。Win32スレへ

C++でboost::shared_ptrないしstd::tr1::shared_ptrを使用しています。
循環参照が生じていないように気をつけてしようしているつもりではありますが、
もし生じていた場合にそれを検出する方法はありませんでしょうか？
(デバッグビルドでだけ検出できれば十分です。リリースビルドで検出できなくても諦めます。)

よろしくお願いいたします。

>>715
丁度話題になっているようだ。
Boost総合スレ part8
http://pc12.2ch.net/test/read.cgi/tech/1251446016/912

>>716
その話題を投稿したのは私です・・・。
boost::shared_ptrの循環参照について調べていて例えが分かりやすい
と思ったのでBoostスレで例のURLを紹介しました。

一方、"循環参照が生じているかどうかを検出する方法"については
boost::shared_ptrに限らずstd::tr1のものも含むという事と、
Boostには"循環参照が生じているかどうかを検出する方法"がない事を私は知っているので、
一般のC++スレで聞くべきと思いこちらで聞きました。

>>715
ここらへんから使えそうなの拾い出してもらえないかい？
http://stackoverflow.com/search?q=shared_ptr+detect+cycle

>>715
これでどう？
http://lists.boost.org/boost-users/2006/11/23527.php

>>718-719
ありがとうございます。
There is an example in libs/smart_ptr/test/collector_test.cpp that shows how
to use libs/smart_ptr/src/sp_collector.cpp to detect (and optionally
reclaim) shared_ptr cycles. You have to #define BOOST_SP_ENABLE_DEBUG_HOOKS
for your project and add sp_collector.cpp to it.
実は既にBoostにあるんですね。
全然分かりませんでした。

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

同じ内容の非constメンバ関数とconstメンバ関数を定義してあるソースを見るんですが何のためなんですか

>>721
非constメンバ関数からもconstメンバ関数からも呼べるように多重定義してある

本当はmutableを使うとconstメンバ関数一個で済むんだけど、mutableは
出来るだけ使わないようにって不文律があるんでな

そうしたければそうしてもいい

>>721
両方あると便利だから。
--
Ex.:
class Foo {
int get() const {return x;}
int get() {return x;}
};
Foo a;
Foo const & b = a;
a.get(); // 非const版が呼ばれる
b.get(); // const版が呼ばれる(非const版は呼べない)

なるほど
ありがとうございました

>>724
おまえ、その説明で満足なんか？

本質には関係無いけど細かい事いうと>>724はコンパイルエラーだ。

class Foo {
MyClass mem;
public :
const MyClass& get_raw_data() const {return mem;}
MyClass& get_raw_data() {return mem;}
};

これで意義が分かるのでは。

>>723
あほかｗｗｗｗ

>723滅多打ちw

void f(std::istream &s)
{
    // ストリームを使って何か処理
}

これって引数がテキストモードなのかバイナリモードなのか判断する方法はありますか？

class BBB : public AAA {} ←この中括弧の意味を教えてください

継承元のクラスを空実装してんじゃね？

>>730

>class BBB : public AAA {
>}

こういう形だと見覚えないかな？

【レポート】GCCに匹敵するコンパイラ?! LLVM - BSDCan2008 | エンタープライズ | マイコミジャーナル
ttp://journal.mycom.co.jp/articles/2008/06/03/bsdcan6/index.html

1/pow(n, x)を高速で計算するにはどうすればいいですか?　
誤差はあってもいいです。実値より大きくずれなければ。

1 <　n　< 3000000 、 0 < x < 1

>>734
>誤差はあってもいいです。実値より大きくずれなければ。

これが難しいんだよ

nの値によってズレ方が変わるからな

条件分けが必要

>>734
例えば２重のループでｎとxを繰り返すなら、ln(n)を配列に保存してexp(ln(n)*x)の式で再利用する。

expとpowは圧倒的に速度差出るんでしょうか?
pow関数はexpに展開するのが標準って事ですか。

>>737
それくらい試せば良いじゃん。

サンクス。最善は>>736ってことでしょうか。
expをマクローリン展開して上位のこうだけ使うのもありげてすが。
実測がいいですね。

>>739
> expをマクローリン展開して上位のこうだけ使うのもありげてすが。
それはexpの実装で既に行なわれていそうな気がしてならないけど。
まあ誤差がどのくらいまで許せるのかってことに大いに依存するよね。

>>739
あとxの絶対値が1未満ってのはマクローリン展開において
すごい収束がよくなりそうだけど、それでもn=3000000は
巨大すぎて誤差がデカめになりそうだ。

まあ実際にやってみてよ！

logやlnを求める漸化式ってあったっけ？あったら前回の計算結果が使えるな。

>>742
どういう数列を想定しているのかしらないけど、普通はないよ。
例えば数列{log(n)|n=1, 2, 3, 4, ・・・}であれば漸化式はない。

しかしながら
　log(2), log(4), log(8), log(16), ・・・
すなわち
　{log(2^n)|n=1, 2, 3, 4, ・・・}
のような数列だったりすれば
log(2^n) = n * log(2)
と変形する事で容易に計算できる。

>>738
こういう奴って馬鹿でしょ？
試さないとわからないのか？

しかも、
FuncA　FuncBを比較したとき
FuncAの実行時間が短かったとしたとしても、今後永続的に
FuncAの実行時間がFuncBの実行時間よりも短いなんてどうしたらいえる？

普通、試してから聞かね？

>>744
同感

具体的にどこでどんなアルゴリズムが使われていて、
それがどのくらい一般的かを示したうえで
定量的な考察を述べるならともかく、
そのへん全然わかんねークルクルパーが態度だけでかいのは許し難いね

直列を前提とした場合に遅いと言われていたアルゴリズムが、
並列もありになったら話が違ってきたとかなら読み応えがあるのに
そういう内容がないよう

オーダーの計算は係数が無視されてるから状況次第でいくらでも優劣が逆転する
結局のところ測るしかないんだよ

実際に使うNの範囲で
無視可能な係数の範囲は分かるけどね

おまえら優しいなスレ違いなのに

splitのデミリタが1文字ではなく文字列の場合はどのようにすればいいでしょうか？
ぐぐっても1文字のデミリタ用のしかでてきませんでした。
boostも試してみましたが1文字分割しかできません。

1時間探してアホらしくなったので自分で作ったら5分でできました。
割と使われそうな内容なのになんでグーグルででてこないんだろう・・・検索の仕方悪いのかな・・・
グーグルで出てくるのは全部find_fist_ofでデミリタ検索してるから"abc"って渡すとaとbとcで区切るんですね。
単にそれをfindにするだけでした。

delimiter
デリミタです＞＜

すいません＞＜

>>735
謝罪の心が感じられるので特別に許してあげる。

>>750
regex_token_iteratorってのがあるみたいだけど、わざわざ正規表現使うのもアレだな

delete instance;と書くと~instance()が呼び出されますが、
~instance()を呼び出すだけじゃダメなの？

だめです

みんなC++やってて具体的な成果残せた？

>>758
ライブラリ自作して満足してるな。
具体的に作りたいものあるけど、毎日気が乗らない。

具体的に作りたいものｋｗｓｋ

>>756
deleteから~instance()が呼び出されるわけであって
~instance()がメモリを開放するわけでもない

>>761,>>757
thx

>>755
boostは遅いからやめておけ
自作したほうがいい

>>758
俺的には HDL のウイザードとジェネレータが最高傑作かな
俺自身がそのコードを触れなくなってしまったのが悲しい

>>764
噴いたｗ

大風呂敷にもほどがあんだろ？ｗ

>>763
十分な速度が出ていると思うが。
自作とか不可能です。

>>766
あの程度の速度で十分なら使えば？

>>767
ああ、いや俺は別人だ。
まあ十分だろ。
boost::xpressiveね。

自作でboostを超えられるヤツは
そう居ないと思うが。

>>769
boostの凄さは速度じゃないぞ
あの、汎用性だぞ

確かに、あそこまで汎用的なクラスライブラリを自作できる奴
少ないだろが、特定の処理だけの速度なら超えれるぞ

超えられるんならboostの開発メンバーのフォーラムに
にここをこうすれば良いッスよってレクチャーしてくださいよ

boost::shared_ptrとかも遅い遅いと言われるけど
実際にそれより速くて色々と安全なスマポを
自作できるやつって少ないんだよね。

Loki Libraryのスマポにすら遅いとか
言うやついるしなぁ。

汎用性犠牲にすれば速く出来るってだけだろ
それぐらいできてもらわないと困るわ

自作できないと、遅いと言っちゃいけないのか？

VISTAが遅いと評判だったが、VISTAを自作できる奴が多いとは
とても思えんが？

Vistaが遅い？

正規表現を利用するのに特化したライブラリ取ってきて使えばいいだけじゃん
俺って頭いいなぁ

>>774
遅いというなら自作ができるのがC++のメリット。自由ね作ればいい。
だけどshared_ptrより速い同等な機能のスマポはまず作れないということ。
機能制限版を作ったとしてもshared_ptrよりわずかに速いだけ。

shared_ptrなんて、使うか？
C++屋なら、どこで破棄されるか分からないのは気持ち悪く感じるはず

そうでないなら、JAVAやC#なんてｵｺﾁｬﾏ言語でも使ってればｗ

GCは気持ち悪いけどスマポは気持ち悪くない

ただの道具にお子様も糞もねえよ

shared_ptrがどこで破棄されるか分からないとか・・・
shared_ptrを何だと思ってるんだろう

>>778
コンテナにポインタ入れてポリモーフィズムやらせたくないの？

>>782
コンテナにﾎﾟｲﾝﾀ入れるのになぜshared_ptr？
お前はまずC++を勉強してからレスしろ

>>783
楽で安全だからだろ？

>>778
shared_ptr 使ったらどこで破棄されるか分からなくなる、などということはない。
実行時に決まるようになるだけ。

うわぁwww

>>778
> C++屋なら、どこで破棄されるか分からないのは気持ち悪く感じるはず
うむ。だからshared_ptrを使うんだけど。

shared_ptrをどんな使い方をしたらどこで破棄されるか分らなくなるの？

>>783が酷い件について
右辺値参照があれば話は変わるが

C++屋ってｗ

ﾍﾝﾃｺな名前の方じゃないですよねｗ

>>783
え？
コンテナに生はいかんでしょ

C++屋ってチャオプラヤみたいだな

>>790
なぜ？

ちょっとテスト書き込みさせてくれ。

あれれー？

だが断る

>>787
循環参照以外の問題ってあるっけ？あれも対策あるし。

それこそいつ破棄するべきかわかわからないでしょ。いちいちこんなこと書くの？
std::vector<int*> v(10);
v[3]=new int(4);
delete v[3]; //更新前に削除しないとね。あーめんどくせ
v[3]=new int(3);
v.clear(); //盛大にリーク
スマポなら
std::vector<shared_ptr<int>> V(10);
v[3]=make_shared<int>(4);
v[3]=make_shared<int>(3);//スマポは更新前の値なんて気にしません。
v.claser();//きれいに削除

>>797
× v.claser();//きれいに削除
○ v.clear();//きれいに削除

我々は釣られたのだ

>>797
JAVAでもやれば

shared_ptrを使えといってるのでは？

boost::ptr_vectorっていうのもあるんだが・・・・
選択肢が広いという利点がある

shared_ptrのコストがどうしても気になるならptr_vectorという選択肢もある。

ptr_vectorはvector<unique_ptr<T>>に集約されそうだね。

vector<unique_ptr<T>>ってソートとか普通にできんの？

>>805
ムーブかスワップでソートを実装すればできるんじゃね？

shared_ptrがいまいちわかってない俺ガイル
自分のコードだけで使うなら勝手に削除してくれるのはわかるんだけど
ライブラリに生ポインタ渡さないといけない場合、まだライブラリが使ってるのに削除しちゃったりしないか考えてると
よくわからなくなってくる

要素の追加すらめんどくさそうだな

ValueSwappable かつ *first が MoveConstructible かつ MoveAssignable でさえあればソートは可能だし、
事実 std::sort などはそう要求している（C++0xで）

>>807
ライブラリを使う時に shared_ptr を複製して、
ライブラリの後始末をする時に破棄すればいい

>>807
ライブラリのドキュメントを読めばすむ問題。

>>810
なるほど
そういうことをするラッパークラスを作るのがいいのかなぁ

用途によると思うが、
std::vector<MyClass> vecと
std::vector<MyClass*> vec
ってどっちがいいの？

そんなのお前にしか分からんだろ

>>813
後者はboost::ptr_vectorに入れた方が何かと都合がいい

>>813
あと前者はそもそもポリモーフィズムできんぞ
コンテナに入れるオブジェクトのサイズは一定でないと

>>816
この手の質問する馬鹿がポリモーフィズムなんて分かるかよ、ボケ

所有権の認識が曖昧なまま生ポインタ使うとか恐ろしすぎる

ばか
ポインタとセックスは生が最高なんだよ

と、童貞が申しております

>>819
> セックスは生が最高
そんなでもないんだぜ、案外

constﾒｿｯﾄﾞのメリットを教えて

>>822
メソッドじゃなくてメンバ関数ね。

メリットも何もないと死ねる。
例えば
int foo(const MyClass& arg)
{
return arg.m_func();
}
でm_func()がconstメンバ関数じゃないとコンパイルエラー。

インスタンスの状態変更のない事が保障されてるからconst参照、constポインタからでも呼べられるし
コピーや変態キャストに伴うメモリ状態同一性が問われる気持ち悪いコードを書いているときも結構諜報する。

>>823
int foo(MyClass& arg)
{
return arg.m_func();
}

とすれば、いいのでは？

>>825
　　　　　　　　　　　　　 　 　 　 　 　 ,､ '";ｨ'
_＿_＿＿___　　　　　　　　　　　　　 ／::::::/l:l
─- ､::::;;;;;;;;;｀ﾞﾞ''‐ ､　 　 __,,,,......,,,,_／:::::::::/: !|　　　　　　　またまたご冗談を
　　. : : : : : : ｀ﾞ'ヽ､:::ﾞヾ´::::::::::::::::::::::｀ﾞﾞﾞ'''‐'､. l|
､､ . : : : : : : : : r'":::::::::::::::::::::::::,r':ぃ::::ヽ::::::::ヽ!　　　　　　　　　　　　　　　　　,､- ､
.ヽ:ﾞヽ; : : : : : :ノ:::::::::::::::::::::;;､-､､ﾞ::: 　 　 rｰ-:'､　　　　　　　　　　　　　 　 ／　　 }¬､
.　＼::ﾞ､: : : :./::::::::::::::;､-''"::::::::::　　　,...,:::,::.,　:::':､　　　　　　　　　　　　_,,/,,　 ,､.,/ 　 }
　　　ヽ:ヽ､ /:::::::::::::::::::::::::　 　 　_　　｀ﾞ''‐''"　 __,,',,,,___　　　　　　　／~　　 ヾ::::ﾂ,､-/
　　　　 ｀ヽ､:::::::::;;;､､--‐‐'''''',,iﾆ-　　　 _|　　､-l､,},,　 ￣""'''¬-, '　 ''‐-､ .,ﾉ'ﾞ,i';;;;ﾂ
　　　_,,,､-‐l'''"´:::::::'　　,､-'" ,.X,_,,､-v'"''ﾞ''yr-ヽ / ﾞﾞ'ヽ､,　　　 ,.'　　　 　 jﾞ,,, ´　7
,､-''"　　 　.l:::::::::::;､-''"　 ,.-'　　ﾞ､""ヾ'r-;;:l　　冫、 　 　 ヽ､ /　 　 __,,.ノ:::::ヽ. /
　　　　　　　l;､-'ﾞ:　　 ,／　　　 　 ゞ=‐'"~ﾞﾞ')　./.　＼　　　　/　　'''"/::::;:::;r-''‐ヽ
　　　　　,､‐ﾞ ヽ:::::..,.r'ﾞ　　　　　　　　 ,,. ,r／ ./　　　 ヽ.　　 ,'　　 　 '､ノ''"　　　ﾉ　　
　　 ,､‐'ﾞ　　 　 ﾝ;"::::::.　　　　　　　"´ 'ﾞ ´　/　　　　　 ﾞ､　,'　　　 　 　 　 　 ／
　　'　　　　　／/:::::::::　　　　　　　　　　　　{.　　　　　 　 V　　 　 　 　 　 ／
　 　 　 　 ／ ./:::::::::::::　　　　　　　　　　　　',　　　　　　 /　　　　　　 　 /
.　　　　／　 /:::::::::::::::::.　　　　　　　　　　　　',.　　　 　 /　　 ,.､　　　　 /

>>825
fooの中で引数に渡したオブジェクトが変更されてたら困るだろ。

COM扱ってるとconst邪魔なんだよね

質問者>>822の「constﾒｿｯﾄﾞのメリットを教えて」に対する回答にconst抜きにすればいいのでは？というのは「またまたご冗談を」

なぜ？（constが邪魔な理由と今更COMを扱っている事に大して）

>>825
一体全体どこの言語ご出身の方かしりませんが、
まあ適当な書籍、『Exceptional C++』とかを熟読して
constの有用性について学んでください。

それで納得できないならC++は使えない。間違いなく。

>>827
それはわかりますが、fooの中では、”オブジェクトの変更をしない”と覚えておけばいいだけでは？

>>832
constが導入されていない時代はまさにそれだった。
それを明示的に示し、違反が合った場合にはコンパイラが自動的にエラーを出せる様にした
システムがconstとconstメソッド。

そのfooの中を作った人間だけが、fooを使うとは限らない。
const 付いていれば、変更されないのが誰にでも理解できるし。

>>832
ちなみにfooにがconstメンバ関数でもnon-constメンバ関数でも、
普通にconst MyClass& argのargから呼び出す事は可能なので、
毎回const版とconstじゃない版を用意する必要はない。

>>832
変更されないことをコンパイラはどうやって知ればいい？
関数の中の処理を全て検査した後に「このポインタ（参照）の先にあるメモリは変更されない」と分かるというのなら、実用性がなさ過ぎて最適化の阻害になる。

”オブジェクトの変更をしない”ということを覚えておいて機械的にチェックする作業をコンパイラに任せるのがconstの目的。
constの目的を理解できないアホでも間違いを起こさないようにするのがconstの意義。
mutableやconst_cast使いまくりでconstの意義を破壊するのが基地外。

もう一回テスト書き込みさせてくれ

>>832
それにfooの中では”オブジェクトの変更をしない”と覚えておいても、
そのfooが呼び出す別のメンバ関数がオブジェクトを変更してしまう可能性も考えられる。
小さなコードなら良いけど、そのすべてを記憶だけでやると危険なことになりかねない。

>>833
そうですか
なぜこのようなことを聞いたというと
例えば、std::vectorでも
iterator begin()
const_iterator begin() const
と２つも実装してるみたいだし、面倒では？
と思ったからです。使う側は面倒ではないですけど。

実装者の労力と使用者の利便性はトレードオフだろうがｶﾞｷ

>>840
面倒依然に、その二つは機能が違う。
非constのbegin関数はコンテナの中を変更することが可能なiteratorを返すが、begin() constはコンテナの中を変更できないわけで。

>>842
いや、だからその変更できないようなiteratorをあえて使う必要があるか？ということです。
変更できるiteratorを取得しても、変更しなければいいだけの話では？

constそのものの説明をしてやらなきゃこいつはだめじゃないか

保守する人が変わっても
未来永劫それが徹底できるならね

保守する人がconstを知らず、constを使わないコードを量産する事も・・・

const参照で引数を受けとればその引数に対して
関数の内部で非constの操作がコンパイルエラーになる
要するにうっかり防止、人間はミスをする前提で考えるのが常識
拳銃についてるセーフティみたいなもんだよ
あとconst参照にしてればテンポラリオブジェクトを渡すのが合法になるがこれも結構大きなメリットになる
iteratorに関しては色々理由があってconst_iteratorを選択するメリットはあまり無いんじゃなかったか？

constを知っていても、const_castで外してしまったらどう保障するのでしょうか？

上のﾚｽをみてると、じゃあ、なぜconst_castなるものが存在するのでしょうか？

選択するも何も、constなコンテナだと
const_iteratorかconst_reverse_iteratorしか選択肢ないだろ

constじゃなくてもsetはconst_iteratorしかない

>>848
constのない、古いコードやバカの書いたコードに渡すため

>>848
自前で用意したクラス、インスタンスなら必要ないかもしれない
けど、他人が用意したものでconstなインスタンスしか参照できないとき
const使わないと何もできないぞ

>>850
あたなのいうところのバカが書いたコードをバカではないあなたが利用する理由は？

const外ししたものに保証なんて無いよ

>>852
会社の自前ライブラリの使用を強制される場合は
そういうことがいくらでもある。

自分じゃ変更できない外部ライブラリにconstがついてない時とかに
const_castを使う
あと、COMを利用するときとか（COMにconstがないので）

constありの関数となしの関数を実装する時に、
const_castを利用して実装をまとめることもある

>>854
ということは、あなたがいうバカが存在する会社と勤務乃至付き合いがある理由は？

釣りはそこまでだ

>>856は逃げに入りました

Fishing is over

test

constを理解しようとしない馬鹿にも理解できそうなconstのメリットを一つ。
あるインスタンスのconst参照を渡す関数の前後でそのインスタンスは同値であることが期待できる。
従って、それ故の最適化が可能。これが非const参照を要求する関数であれば、その最適化はできない。
従って、const参照によるパフォーマンスの向上の可能性がある。
const参照がconstメンバ関数であっても理屈は同じこと。

>>856
論破されたからって関係ない話を持ち出し始めるなよクズ

constのない言語がほとんどだから
なくてもいいんじゃない？と思う人がいるのは分からなくもない

>>848
const外しをした場合の動作が未定義なことくらい知っておけよ

const外し全般が未定義はないわ

const int n = 0;
const_cast<int&>(n) = 1;
は未定義だが

バカバッカだなｗ
結局constの有用性を説明できたのごく小数だったなｗ

>>862
そのままおまえに返すよｗ

論破されたからって関係ない話を持ち出し始めるなよクズ

自分にとって都合の悪いことには答えないんですね。分かります。

折角いい流れだったのに台無しだな

最近、内の会社にもいますよ
二言目には「〜の理由は？」って奴、ｱﾌｫかと
話もしたくない

他のスレでもこういうアホ見かけたな
最後には逃げる奴

>>871
自分自身だったりしてｗ

┐(ﾟ〜ﾟ)┌

面白いテーマの掲示板が出来る。
　↓
面白い人が集まってきて、面白いことをはじめる。
　↓
面白くない人も大勢見に来る。
　↓
面白くない人が面白い人の真似をしはじめる。
　↓
面白くない人がやっても面白くない。
　↓
面白くない人のほうが多いので、面白くないものの比率があがる。
　↓
掲示板が面白くなくなって、面白い人がいなくなる。
　↓
緩やかに過疎。

はい、次のネタどうぞ

上にconst int n = 0;ってあったが、
こういうコンパイル時に決まる静的な値だけで初期化された定数のことを指す用語ってあんの？

>>861
それは無い。

定義時の const であれば別だけど、参照への const の有無だけでは
エイリアスの可能性（最悪グローバル変数経由とか）が消えないので、
コンパイラは変更されていないことを前提にできない。

参照への const の有無で最適化の結果が変わるようなコード、作れる？

>>876
そのまんま。
コンパイル時定数(Compile-time constant)

>>878
そのまんまだな。ありがとう。

constの存在意義を聞いてるのに、あるもんはあるんだから仕方ないだろ、なんて
思考停止じゃ答えになってねーだろ。

>>880
んなこと誰も言ってねーだろ死ねば？

誰もそんな答えしてないだろ。

バカには理解できなかったんだろう

こういうヤツには頼むからC++使って欲しくない
ゆとりでも使える高級言語で満足して帰ってくれ

最近の言語で軒並みconstが採用されないことからも
constはあまり重要なものでないと分かる

constに出来ないんじゃないの

constをつけ始めるとコンパイルエラーが頻発する。
すなわち、今まで危ない橋をいかに多く渡ってきたのが明確になってぞっとする。
そうなるとconst１を丁寧につけて、機械的に検出できる部類のバグはコンパイル時に解決してするありがたさが分かる。

>>885
constもtypedefもないC#はVMの都合のような気がする。もしC#にconstを採用したら、VB.netで悲鳴が上がるんじゃないか？
まあいまさら追加できないだろうけど

Dはconstどころかinvariantとかimmutableとかfinalとか余計に複雑になってる

>>828
わかる

readonlyはあるよね

>>885
最新の言語といってもスクリプトだからな。

スクリプトはconst以前の問題だしな
ああいった言語は安全性より手軽さだからそれでいいけど

>>891
readonlyは参照を変更できないだけで、参照先のオブジェクトを変更できないわけではない。 const T&やconst T*とは意味が異なるので今の議論とは関係ない。

スクリプト言語でもgetterのみのプロパティとかは、意味的にconstに近いだろう。

>>895
const相当のgetterのみの使用に一時的な限定する機構があるならばね。

readonlyのアダプタ使えばええやん

>>897
ｋｗｓｋと言いたいとこだが、C++スレなんで３行でお願い

いやだからwriteメソッド削ったアダプタかませりゃconstない言語でも安心だろ

>>899
constがあればreadメソッドにつけるだけで簡単だろ。

>>900
いや、今は無い言語の話をしてんじゃねーの？

const一つでここまで熱くなれるおまいらが羨ましい

Visual C++って最初から使いこなすのムズいな
いつから使い始めれば良いか、タイミングが難しいけど・・・・いつからやりゃあいいんだ？
最初から他のエディタ使ってると永遠に使わなさそう

hoge(T** ptr)とhoge(T*& ptr)はどっちが一般的？

どこの一般だよ

そもそも使い道が違うし

STL/Boost的に考えるなら後者
WinAPI的に考えるなら前者
じゃね？

関数内部でmemcpyした後にポインタを動かしたいんだけどどっちにするべきかな？と思って

memcpy??
どういうことがしたいんだ

こんな感じ

void hoge(char** dst, char* src, size_t size)
{
memcpy(*dst, src, size);
*dst += size;
}

void hoge(char*& dst, char* src, size_t size)
{
memcpy(dst, src, size);
dst += size;
}

すげー怖いコードだな
vector使おうぜ

>>910 なら参照だろ。ポインタ使って何かいいことでもあるのか？

>>910
たぶん dst をメンバに持つクラスを作ったほうがいい。

dstのサイズが分からないから
いくらオーバーしても我関せずだな

>>911-914
ありがとう
色々試してみる

memcpyってどのコンテナのメソッド？

vector::insert使えばいい

vectorでバッファのアライメント指定できるの？
vector<char>に__attribute__((aligned))付けたら良きに計らってくれるの？

テスト

>>918 そうはいかない。

動的に確保したメモリは最悪の条件でもアラインメントされてるはず
・・・はず

>>920
じゃあやっぱりvectorを本物の配列の代わりに使うなんて無理なんだね

横槍レス。>>922
どうしてそう言う結論になるん？

Visual C++ってコンパイル機能ないのか？
メニュー探してもボタン探してもコンパイル機能らしきものがない

あるよ？

>>924
ビルドメニューの中にコンパイルって無い？

プロジェクトから作ってないとダメなの？
cファイル開いたんだけど

memcpy使わざるを得ないのは分かったが
dstのサイズくらい渡しとけ
バッファオーバーフロー攻撃のいい餌食だ

>>924
2010のeeだったらメニュー項目が隠されている。
ツールのどっかにチェックがる。

>>922
制約が厳しい場面では代わりにならないこともある、というだけのこと。
多くの場面では代わりに使える。無理じゃない。

制約が厳しいっても
バイトストリーム扱う時に全く役に立たないって結構致命傷だと思うんだけど
特にC/C++の得意分野を考えると

ストリームに使うのはストリームクラスじゃないのか

え？iostreamで全部扱えって？
ご冗談でしょう

道具なんだから場合によって使い分ければいいじゃない。

>>931
「バイトストリーム扱う時」というのが何のことかさっぱりわからない。詳しく。

俺が童貞だってconstで定義した奴は出てこいよ！

>>931
vector が使えなくても代わりの手段があるだろ。
なんで vector が使えなかったら致命傷になるんだ？

>>932
stringstreamじゃないの？

>>936
const_castがあるじゃないか

コンパイル時定数のconstをconst_castで外したときの動作は未定義です

ROMに格納されてたらセグフォだな…

>>940
> コンパイル時定数のconstをconst_castで外したときの動作は未定義です
そうなの？外すだけでだめ？

int foo(const MyClass& arg)
{
return const_cast<MyClass&>(arg).m_func_argを変更するメンバ関数();
}
は
MyClass x;//これがconstでないという前提の下で、
foo(x);
としても未定義の動作ではないんだよね。

いや普通はfooの作者を殴りに行く所だけど、文法的な話で。

>>942
"コンパイル時定数"じゃないじゃん

それはxがコンパイル時定数じゃないから未定義動作ではない

分かりやすい例

const int n = 0;

int main() {
　const_cast<int&>(n) = 1;
　std::cout << n << std::endl;
}

1 と出力されるか 0 と出力されるかは規格では定義されていない

>>942
コンパイル時定数の const を外しても書き込んでなければ未定義動作にはならない。
その例の x については書き込んでも未定義動作にはならない。

>>945
その場合は未定義動作だから、 1 と 0 のどちらかが出力されるとも決まっていない。

おおなるほど、ありがとう。
理解。

俺のレスの後半部分はあんま関係ない例だったっぽいな。

そしてコンパイル時定数でもconst_castするだけならOKなのか。
書き込まなければ。

>>945
> 1 と出力されるか 0 と出力されるかは規格では定義されていない
不定？それとも未定義の動作？

>>946
まあそうか

>>948
undefinedだったと思う

>>949
サンクス。undefinedか。じゃあ致命的だな。

そもそも出力以前に、代入の時点でプログラムが落ちてもおかしくはないな

const_castよりもmutableですよ。キャッシュ値を保存するのにmutableは便利。

STLとかBOOSTで使う関数オブジェクトってあるじゃないすか
あれって関数オブジェクトを引数に受け取るときはconst参照じゃなくてオブジェクトの複製になってるのは規格や規則で指定されてるんですか？
自分でファンクタを作るときにどっちを前提で書けばいいのか迷ったので質問しました

ああいうのは純粋関数のはずだから状態を持ってないわけで
それならconstも何もないってことなんじゃないの？

＞ああいうのは純粋関数のはずだから
どういうこと？

>>953 標準ライブラリの話であれば規格で定められているとおり。

>>955
結果が引数のみに依存する関数ってこと
内部状態を持ってる関数だとアルゴリズムに渡したときおかしなことになるから

mutable使った事ない。
便利なのは知っているが、そのシチュエーションに遭遇したことがない。

>>956
thxです

mutableって他で代用出来なくて効果的な使い方なんてあるのか？

複雑な計算をして得られる値を使い回したいけど
最初にその値を取得するconstメンバ関数を読んだ時に初めて計算して欲しい時とか

mutableはC++を学び始めた時に「何に使うんだこれ」と思っていたが、今でも同じ事を思う。

インスタンスの内部キャッシュを作ろうとするとmutableにせざるを得ない。
あとは参照カウントとか。

>>958 こんな使い方
キャッシュなど呼び出し側からはオブジェクトの変更を意識する必要が無い場合とか。
const_castを駆使するより、constでも値を変えることができる事を明示するぐらいのメリット。

class hoge
{
mutable bool cached;
mutable int cachevalue;
public:
hoge()
:cached(false)
{
}
int getValue()const
{
if(!cached)
{
cachevalue=func();//すごい遅いけど同じ値が帰ってくることが分ってる関数。
cached=true;
}
return cachevalue;
}

};

CRITICAL_SECTIONにmutable付けてみた

意外と使いどころあるな
実際そんな使わないけど

>>964
丁寧にありがとう！
ただ、それって単にmutableとメンバ関数のconst指定を消したらダメなのですかい？
・・・あ、それだと
void foo(const hoge&)
に渡せないってことか。

boost::mutexなんかmutableをつけてるぜ俺

http://codepad.org/xASzkIWx

mutableいらなくないっすか？

getValue自体オブジェクトの状態を変更するような関数じゃないからな
constなのが自然

ここらでだれか次スレたのむ

>>969
おまいはいちいちmutable回避のためだけに、普段からそんなコードを書いてるのかと小一時間問い詰めたい。

>>969
mutableだとキーワードひとつで済む上、目的が一目瞭然なのがメリット