そのような質問は必ず環境を書きましょう
半角空白やタブでのインデントはスレに貼ると無くなります
コードを貼れる所
ttp://codepad.org/ ttps://ideone.com/ 前スレ
【初心者歓迎】C/C++室 Ver.101【環境依存OK】
ttps://mevius.5ch.net/test/read.cgi/tech/1500329247/ 乙
{
unsigned long v;
for ( v = 0; *psz && n--; psz++ ) {
if ( ! isdigit( *psz ) ) {
continue;
}
v = 10 * v + ( *psz - '0' );
}
return v;
}
見やすさ
汎用性
コードサイズ
どれかひとつ位は満たさないと
まあそう言うごたくを言うのは一つぐらいは満たしたコードを書いてからでないとね
"12 34 56"(NUL終端なし8byte) を数値の 123456 に変換、
てお題の答案かな。
…と思ったけど、NUL終端文字列が仮定されてるね。
どういう流れで投稿されたんだろう?
""だと不定値返る数値変換なんてゴミ
確かにクソコードだが不定値は返らんぞ
こんな簡単なコードの動作も理解できてないようだし
しかも後付けで言われてもあんまり支持できないなぁ。
せめて最初から「お前らこれ改善してみろよ」とかで出してくれ。
「糞コード」とけなすだけで、具体的な問題点の指摘がないってのも寂しいわ。
のソース、引数のpszが""でも、nが0でも妥当な返り値 0 が返るけど、
実は最初に見たとき n==0 で呼ばれた場合に即時終了しないと騙されたわ。
後置デクリメント評価値、ね。
何のスレか忘れてしまいそう
char a[8] で psz = a, n = 8 を渡すと不定値どころか鼻から悪魔の糞コード
仕様も理解せずに余計なことしてバグを作り込む知ったかの典型
●パフォーマンス
*pszが3回も出てくる
代入して持っておいた方が
チープなコンパイラでは速度が変わる
isdigit
どうせ数字が連続してる前提のコードなんだから
関数を呼ばずに'0' '9'と比較しちゃおう
そうのが速い
関数コールは一般的に遅い
●見やすさ
forループにいくつも入れない
while (n--) か for (size_t i= 0; i < n ; i++)
null文字はbreakで
●仕様
null文字とサイズ、両方で停止は仕様としては問題ない
パフォーマンス最優先であればそれぞれの特別版を作ればいい
文字数もスペースの位置も固定で
パフォーマンス最優先なら
ループアンロールするのが一番
人違い。
> null文字とサイズ、両方で停止は仕様としては問題ない
だからダメだっつーの
知ったかは黙ってろよ
最低限サイズチェックを先にやらないとダメ
判別の順番は問題だ
順番が逆
そもそも相談者の仕様がおかしい
for ( v = 0; n-- && *psz; psz++ ) {
これなら、存在しない指し先のデリファレンスしないし
ただ、
ショートサーキット前提の記述をよしとするかどうかはわからん
{
int v = 0;
while ( n-- ) {
char c = *s++;
if ( c == '0' ) break;
if ( '0' <= c && c <= '9' ) v = v * 10 + ( c - '0' );
}
return v;
}
あとnull文字って初心者が背伸びしてる感じがして微笑ましいな
ってのは居たが
ここって車輪の再発明好きな人多いのかね
本当に配列が最速？
(試したわけではないので配列が最速かもしれない……)
ないない
仮により速くても
{
int v = 0;
while ( n-- ) {
char c = *s++;
switch (c){
case '￥0':
goto brk;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
v = v * 10 + ( c - '0' );
break;
}
}
brk:
return v;
}
って思った人いるんだろうか
ああ、素人はgoto嫌うよな
もちろん必要は無い
テーブルよりは色々な面でマシってだけ
普通に if ( '0' <= c && c <= '9' ) で良い
一目で意味がわかるし高速
とおもってアセンブリ吐かせてみたら、すごかった。
48引いた上で、符号なしで10未満か判定してるので、
余分な条件分岐してなかった。
&& では分岐しなかった。
'0' <= c && c <= '9' を clang で -O3 付きでコンパイルしてみたらこうなった。
addl $-48, %eax
cmpl $10, %eax
setb %al
賢いな！
直後に分岐するなら結果をレジスタに書き込む必要はないから実質的に二命令だ。
'0' を引くんじゃなくて 0x30 と xor を取ってから 10 より小さいか比較するっていうのでもいける。
ただ、最近はビット演算が算術命令より速いとも限らないみたいなんだよね～
まるで昔は速かったかのようだ
Z80 ですら足し算と XOR は 1 クロックだったわ。 スマソ
8086はビット演算の方が速いぞ
> 仕様として「両方で停止は問題ない」よな？
相談者でないとわからん
途中に'\0'があるケースについては書いてないから
> そもそも相談者の仕様がおかしい
それはお前が決める話じゃない
> ショートサーキット前提の記述をよしとするかどうかはわからん
if(p != 0 && *p != '\0')
みたいなのは普通に書かない？
俺は書くけど それを"普通"とまで言い切ってしまって良いという自信はない
わからないならだまってれば
正確な要求仕様がわからない事くらい誰でもわかる
両方でとまる関数は片方で止まる関数の機能を含むので
問題になる場面は普通は考えられない
質問に書いてない、文字列の途中にNULL文字とか
いうアホな事を心配しない限り
こういう思い込みの激しい奴が要らんバグを作り込むんだよな...
環境: Core i7-2600 / gcc 6.4 (-O2)
rund() & 0xff の値で条件分岐して、真ならさらに rand() を呼ぶ、を10億回ループ。
条件式はASCII前提。
数字: 条件式 < int配列ルックアップ < isdigit
英字: 条件式 <= int配列ルックアップ < isalpha
数字英字: int配列ルックアップ < 条件式 < isalnum
ロケールの影響か、isalphaなどはisdigitより遅い。
char配列ルックアップはint配列より遅い。
奇妙なことに、配列ルックアップでも、数字だけより、英字も入ってくると遅くなる。なぜだ。
は演算の依存性が高いので
の方が少し速いかな？
まあコンパイラや環境依存でしょう
x64前提なら、
64bit一気に持ってきて偶数奇数桁に分けて、
LEAで5倍してシフトして足すとか
AVXで乗算してから水平演算とか
色々と考えられるけど
まあ一応このスレのC言語の範囲で
10000*a[0]+10000*a[1]+1000*a[3]+100*a[4]+10*a[6]+a[7]-5333328;
これより速くする方法あるのか
フォーマットは固定と思われる
このままで良い気はする
当然こちらの方が意味が分かりやすい
やっぱりLEAを多用してる
VS2017の64bit Releaseビルドの場合
VPMADFWD xmm0, xmm0, [掛け算テーブル]
VPHADDD xmm0, xmm0, xmm0
VPHADDD xmm0, xmm0, xmm0
メモリが連続してれば複数同時に出来る
連続してなくても複数同時にやった方が速い
10億回ループがいちいちキャッシュクリアされてるのかが気になる
処理次第で可能性が無いことはない
他のキャッシュを汚染する可能性もある
HTTなどでは特に
他に良い方法が有るのにわざわざ面倒なテーブルにする意味がわからない
newするしかないですかね。
vector<char*> に各要素 s の &s[0] を入れて済むなら new は要らなさそう。
まあどうみても内部でnewしてるんだろうけど
クラスは構造体に関数を追加したようなもの。
クラス内部の関数はメソッドと呼ばれる。
メソッドからは、クラスのデータとメソッドを参照できる。
データとメソッドのそれぞれの項目をクラスのメンバーと呼ぶ。
クラスの実体はインスタンスと呼ばれる。メソッドからは、thisポインターにより、クラスのインスタンスを参照できる。
メンバーは、public:、protected:、private:によってアクセスを制御できる。アクセスできないメンバーを参照するとコンパイルエラーになる。
{
int a;
};
と書くとA::aは、privateになる。構造体と同じアクセスにするには
class A
{
public: int a;
};
と書かないといけない。このようにクラスのデフォルトのアクセスはprivateになり、構造体はpublicになるという違いもある。
また、インスタンスが破棄されるときに、デストラクタという特殊なメソッドが呼ばれる。
class A
{
public:
int m_a;
A(int a) {m_a = a + 1; }
};
int main() {
A a(2);
printf("%d\n", a.m_a);
}
class A {
public: int m_a;
A(int a, int b) : m_a(a + b) { }
};
int main() {
A a(2, 3);
printf("%d\n", a.m_a);
}
ちゃんとした説明を読んで理解できないなら掲示板で短い説明読んだってわかりゃしねーよ。
情報が多過ぎて迷子になってるんじゃないか。マニュアル読め、規格票読め、で終わればいいのだが。
こういうアホってどこにでもいるんですね
その理解で8割がたOKだと思うのだが、何が問題なの？
チュートリアルだってたくさんあるじゃん。
クラスがわからんやつにこんな説明しても通じないだろ
原子の集まりだよ。って答えるようなもの
形式的にウソじゃあないんだが
そこじゃないだろっていう
C言語(ベース)でのオブジェクト指向プログラミングをサポートするために言語機能で用意された部品
オブジェクト指向プログラミングにおけるオブジェクト、オブジェクトの状態、
メッセージの送受信、メッセージを受けたときの振る舞いといった概念を具体化した仕組みの一例
他人の真似でなんとなく使ってるけどなぜクラスを使うのかがわからないといったあたりの話だろ
クラスは実用あってこそ
「オブジェクトにメッセージを送る」って言い回しも
C++だと分かりにくいね。
この表現がしっくりくるプログラミング言語というか
環境もあるのだろうけど。
そういうのをベタで実現しているOO言語はないかな…
あれも結局、関数（メソッド）の動的なコールをそう呼ばせてるだけ
同じSmalltalkでもSmalltalk-72までさかのぼるとメッセージ送信と呼べなくもない仕組みにはなっているけど
それでもオブジェクトに（メッセージを）「送る」というよりは（トークン列を）「流し込む」って感じかと
まあ、ともあれC++の「オブジェクト指向」を説明するときには「メッセージを送る」とかはすっかり忘れていいよ
そもそもC++の設計者の提唱するオブジェクト指向は「抽象データ型（端的にはユーザー定義の型）」を
Simulaという言語から拝借した「クラス」という言語機能で実現することが主軸のアイデアなので
ttp://www.stroustrup.com/whatis.pdf 仕組みがどうなっているかから考察するのは無粋だと思うけどなぁ。
まあ C++ は低水準レイヤでの仕組みを意識せざるを得ない、
意味論とメカニズムが不可分なデザインではあるから概念としてのメッセージ指向よりも
メカニズムに意識が引きずられてしまうというのは確かにあるかもしれない。
違いがわからないw
メッセージパッシング言うなら、何かが静的に決定してる時点で興醒めだよ
ttp://wiki.c2.com/?AlanKayOnMessaging C++のポリモーフィックなメソッドは動的ディスパッチだろう
>抽象データ型
これがすべてなのに、どうしてメッセージ駆動の話が今でももちきりなのだろうか？
C++に「動的なものは何もない」という主張ではなく
「静的に決まる何かが一つでもある」時点でそれをメッセージングに例えるのは興醒めという意味
少なくともケイは彼のOOPにおけるメッセージングを「遅延結合の徹底」の目的で提案している
ttp://d.hatena.ne.jp/katzchang/touch/20080807/p2 「私が考えるOOPはメッセージング、状態処理のローカルでの保有・保護・隠蔽、
そして全ての物に対する強力な遅延束縛、これだけだ。
これはSmalltalkとLISPだけが実現できている。他のシステムでも可能かもしれないが、私は知らない。」
つまるところ、これはすなわち、SmalltalkやLispみたいな変態言語でもなければ、
（あるいはアクター機構のように、並列化を意識して本当にメッセージを送るのでもなければ）
無理して「メッセージパッシング」なんてたとえる必要は無いんやで、という話でしかない
まったくもってその通り
int a,b;
long c;
の条件下で、a+b 、a*100+b*100（a*100、b*100のどちらもlong型になる）
がそれぞれlong型の解になるような場合のキャストとしては
1 c=(long)a+b;
2 c=(long)a+(long)b;
3 c=(long)a*100+b*100
4 c=(long)a*100+(long)b*100
とそれぞれ、どの記載が正しいのでしょうか？
intでは表せなくてlongが必要
って意味なら3以外
１と３は似ていますが１はa,bそれぞれキャストされるが
３ではb*100はキャストされずint型で計算されてしまう、ということなのですね
if(a==0){ }
と記述するのにfor文では
for(i=0;1<100;i++){}
と書き、for(i==0;i<100;i++){}
と書かないのはなぜでしょうか？（==の使い方）
代入と比較は違う。
forでも書いてもいい。だが意味がないか低い。
「=」は代入だが「==」は代入でない。
そういうことなのですね。理解できました、いつもありがとうございます！
数学だと代入 (定義) するっていうのと等しいっていうのは区別がはっきりしないので、
そういうメンタルモデルで考えてると混乱しちゃうってのはわからんでもない。
とはいうものの、よっぽど出来の悪い入門書でもそこらへんわからんようなのは無いと思うんだが、
どういう学び方をしてるんだかちょっと疑問。
ネットで優しそうなサイトで進めてます
Pascalみたいに代入が:=なら良かったのに
Cでは多く入力するであろう代入側を 1文字にして そうでない側を 2文字にした
って聞いたことがある
とはいえ、文字数ごときにこだわらずに、:=を採用してくれていたらタラレバ
SunAwt系のソフト内で表示されているテキストを取得したいんだが、尻尾も掴めず困り果て、どうすれば良いか全く分からない状態。
何かヒントを頂けないだろうか。
別のプロセスから取得するって意味？
YES。
別プロセスからテキストを取りたい。
他の例えばIEやハンドルが取れる様なソフト内の文字ならgettextやcom操作で取ったりできるがSun系のソフトは同じ様にはいかず、メモリを読むのかどうすればいいのか、知識が足りなくて検索も上手に出来ず...頭打ち状態。
何か足掛かりになる物を教えて頂きたい。
試したことないけどこれは？
ttp://www.oracle.com/technetwork/articles/javase/index-jsp-136191.html int main(){
int i,num[5];
for(i=0;i<5;i++){
printf("***\n");
scanf("%*c%d"&num[i]);
}
}
実行し、num[]に、10、20,30,40,50と入力すると
num[0]の値は0、num[1]は20、その後50まで代入されてます
num[0]に10が代入されないのは何故なのでしょうか？
"%*c"のせいじゃね
そうでした。ありがとうございました。
入力後、
テストＡ テストＢ テストＣ
０点～１９点 ０人 ０人 ０人
２０点～３９点 ０人 ０人 ０人
４０点～５９点 ２人 ０人 １人
・・・
８０点～１００点 １人 ３人 ２人
と集計する方法に悩んでいます。
どういう考え方が考えられますか？
char_に替わるパーサー書けばいいんじゃないかね
マルチバイトの最初の文字を認識する自作パーサーをmb1、マルチバイト文字のパーサーをmbcharとして
mbchar = (mb1 >> char_) || char_;
とか？
宿題は自分で考えるのが原則。どこまで考えた？
ありがとうございます。
入力された点数を３次元配列に格納するところまでです。
今は、繰り返し分を使い、配列に格納された数字が０でなかったら
その数字をカウントして人数を集計しようとしてるのですが、できていません
なぜ3次元？生徒と教科がインデックスだから2次元では？
あと、表示さえすればいいだけなら、
効率度外視である教科のある得点範囲の人数をカウントするくらいできるでしょ。
効率考えるなら表示用に0で初期化した2次元配列を別に用意する。
ありがとうございます。2次元です。
ten[5][3]で得点を格納したあとが進まないのです
得点範囲の人数のカウントについてもう少し考えてみます
やっぱり4版を買ったほうがいいのかな
そうなのか・・・聞いておいてよかった
ありがとう
昨日はありがとうございました
90行程度と長いプログラムになりましたが
人数をカウントし表示させることができました
カウントは、教科毎にfor文で呼び出し
20以下、20～39、・・・80～99、100とif文で条件指定し
各範囲で人数をカウントし、最後に表示させました
また分からないことがありましたらご指導お願いいたします。
int main(){
int count;
FILE *fp;
if((fp=fopen("log.txt","r"))==NULL){
count=0;
}else{
fscanf(fp,"log.txt",&count);
fclose(fp);
}
if((fp=fopen("log.txt","w"))==NULL){
printf("Error\n");
return -1;
}
count++;
printf("%d回目のプログラムを実行です\n",count);
fprintf(fp,"%d\n",count);
fclose(fp);
}
これを実行するたびに
2752513回目の・・・
3444737回目の・・・
2953217回目の・・・
となってしまい、ファイルを開いた数が記録されません
最初にlog.txtがない状態で実行したときの、一番最初だけ、countに１が代入され
log.txtにも1が記載されるのですが、2回目以降のcountには7桁の乱数みたいのが代入され記載されてしまいます
どうして不具合が出るのか分からなくなっております。よろしくご教授くださいませ
さっそくありがとうございます。fscanf(fp,"%d",&count)と訂正しました。
初歩的なミスで申し訳ありませんでした、そしてありがとうございました。
> fscanf(fp,"log.txt",&count);
二番目の引数を再確認してみ
ありがとうございました。
おかげさまで正常にカウントされるよになりました。
確認不足でご迷惑おかけしました。ありがとうございます。
c言語でGetPixelが動きません
どうすれば直るのか教えてください
COLORREF GetPixel (float 変数x, float 変数y); //指定座標の色取得。
if float GetPixel(float 変数x, float 変数y == RGBCOLOR( 0, 0,255)) ; //指定座標のピクセルが青色ならコード実行
//以下、実行するコード
＞if float GetPixel(float 変数x, float 変数y == RGBCOLOR( 0, 0,255)) ; //指定座標のピクセルが青色ならコード実行
if (GetPixel(x, y) == RGBCOLOR( 0, 0,255)) {
条件が真のとき実行するコード
}
ではどうですか？
氣
するとIOの初期化がそれぞれ違う。しかもチャンネル１を初期化するとチャンネル３
にも影響する場合がある。こういう場合にはどんな風にクラスをつくったらいい？
fp=fopen("out.txt","r");
while(fscanf(fp,"%d",&da2[i])!=EOF){
fscanf(fp,"%d",&da2[i]);
i++;
}
fclose(fp);
これを実行するとテキストファイルに記録されている整数を
一行飛ばしで読みだしてしまいます
どうして飛ばされる行ができてしまうのでしょうか？
friend
fscanf() を二箇所に書いているけれども、それでいいのですか？
whileでのfscanfのあとでiを変更してないから次のfscanfで同じda2[i]に上書きしてる
そういう事だったのですね
ありがとうございました！
int main(){
char ch1,ch2;
printf("二文字入力\n");
scanf("%c",&ch1);
scanf("%c",&ch2);
printf("ch1=[%c]\nch2=[%c]\n",ch1,ch2);
return 0;
}
これを実行すると、２回目のscanfを飛び越えてしまいます。
その理由と回避方法をご指南いただけませんでしょうか？
よろしくお願いいたします。
int main(){
char buf[3], ch1,ch2;
printf("二文字入力\n");
fgets(buf, 3, stdin);
ch1 = buf[0];
ch2 = buf[1];
printf("ch1=[%c]\nch2=[%c]\n",ch1,ch2);
return 0;
}
ありがとうございます
標準入力によって処理し、scanfを使わないということなのですね
文法を覚えて活用できるようにします
何度もありがとうございます
改行文字を次のscanfで読込むから
回避方法は例えば
ttp://blog.unfindable.net/archives/604 ありがとうございます
しっかり理解できるには時間がかかりますが
とりあえず、お礼申し上げます
改行文字を処理しないと次のscanfが改行文字を読んでしまうのですね
とても勉強になりますし、皆様のおかげで前進できます
ありがとうございます
俺みたいなライブラリのインクルードが通せなくて
そもそもコンパイルって何だっけってところから調べるような奴には恐れ多いわ
out,txtに記録されている下記文字に対して
---------------
AAA BB
ababb
099
---------------
ファイルを開いて、文字列を読み出し
配列で一文字一文字を表示させようとしています
i=0;
fp=fopen("out.txt","r");
while(fscanf(fp,"%c",&c)!=EOF){
i++;
}
for(t=0;t<=i;t++){
printf("%c\n",c[t]);
}
これだと18行表示されますが
表示されたのは全く異なるものでした
どこが不適切なのか２日考えても分かりません
いつも申し訳ありません＞＜よろしくご指導願います
c は大きさの十分ある char への配列と想定した前提で
fscanf の引数がおかしい
１文字毎に配列へ順繰りに読み込ますのなら
fscanf(fp,"%c", &c[i]);
こうなってないと
＆が抜けていたのは恥ずかしいです
申し訳ありませんでした
しっかり覚えさせていただきます
プログラムもちゃんと動きました
いつも簡単なことばかりなのに理解が浅くてすみません
とても勉強になりました。ありがとうございました
本当に分かっているのか不安になる返答だが、そのうち慣れてくるだろう。
（文字と文字列の違いと (f)scanf に渡すフォーマットの指示と 変数をどう渡すか
の一連が整理されてないと、また繰り返すだろう）
はい、ありがとうございます。
配列にして直してあります。
fscanf(fp,"%s",c)として読み込んだ後に
c[i]で一文字一文字表示させられると思い込んでいました
先ほどの156のおかげでfscanf(**** &c[i])を覚えられました
ありがとうございます！感謝してます
10人分の点数を入れて表示するプログラムです。
下記のように作成したのですが、main()内から関数を呼び出すところで
parameter names(without typesというエラーがでてしまいます。
どうかよろしくお願いします。
#include<stdio.h>
void da(int ten[10]){
int i;
for(i=0;i<10;i++){
printf("%d input ",i);scanf("%d",&ten[i]);
}
return;
}
void out(int ten[10]){
int i;
for(i=0;i<10;i++){
printf("%d人目 : %d点\n",i,ten[i]);
}
return;
}
int main(){
int ten[10];
void da(ten);
void out(ten);
return 0;
}
#include <stdio.h>
void da(int ten[10]){
int i;
for(i = 0; i < 10; i++){
printf("%d input ", i); scanf("%d",&ten[i]);
}
}
void out(int ten[10]){
int i;
for(i = 0; i < 10; i++){
printf("%d人目 : %d点\n", i + 1, ten[i]);
}
}
int main(void) {
int ten[10];
da(ten);
out(ten);
return 0;
}
他のＣ言語のスレから誘導されたので、こちらで質問していいかと思ったのですが
今後質問は控えます。自力で学習を進めようと思います。
ご迷惑をおかけしてすみませんでした。
片山先生、本日もありがとうございました。感謝です。
struct {
char a;
short b;
int c;
} x;
Cでバイナリデータとかパディング除けに上のような感じに書いて読み書きしたりしますが(例は適当)、
C++ではpragmaを使用せず記述量も少ないスマートな記述方法はあるでしょうか？
pragmaがコンパイラ依存とか書かれてて非常に嫌なんですが慣れます。
...
#include <poppack.h>
そのような構造体で直接読み書きしないのがベスト
make の Makefile を Visual Studio や NetBeans 等の IDE の
プロジェクトファイルに変換するツールはありませんか。
Makefile を CMakeLists.txt に変換するのはありますか？
見つけられたのは、nmake.exe 用の Makefile.mak を *.vsproj に変換する、
Python のスクリプトだけでした。。
ない。
CMake 勉強します。
c++のためのapiデザイン
でも読んでみるといいと思う
ただ名前の先頭だったり、２回連続で使ったりすると
予約語に引っかかることがあるので注意（定数の場合も）
これも参考になりそう
GUIプログラムならC#のほうが圧倒的に簡単だし
C#とは存在するレイヤが違うから、比較条件として用途を挙げるのはちょっと違うかなって
高級アセンブリの用途は？
大規模ゲーム開発
C/C++のような低級な高級言語が適している
組み込み用の小規模マイコンもCがほとんど
<cstdio>は正しくC++だからprintf使っても構わん 味噌 よ
後々になって「iostreamはでかいし あんまりうみゃくいかないエビフリャー」いうことになった きしめん だしね
endlは、改行の無い出力と在る出力を統一的に（フォーマット使わずストリームで）扱うには必要でしょ ひつまぶし?
愛知語は詳しくないけど察し手羽先
重症やな w
「人生を無駄にした」と真顔で後悔してるところだから
エクセルのような操作性の、画像レイアウト印刷アプリなんてどう？
印刷はしたくないです..
そこでC+11の一部が使えるようになったから使いたいと思ってる
ユーザにAPIを公開してるんだけど、ユーザがAPIを使うに際してはコンパイルオプションstdc++0xが必要なことにはしたくない。今までできてたのに、バージョンアップしたらコンパイルできなくなったとかいわれるからね。
ここで質問なんだけど、ユーザに公開しているヘッダファイルにC+11の記述がなければ、ユーザからの使い方は変わらないかな?手元で試してみた感じだと行けそうだって思ったけど、このへん危ないんじゃないのとか気をつけた方がいいよとかあれば意見よろしくです
nmコマンド、試す価値はありそうだありがとう
#include <iostream>
#include <functional>
using namespace std;
struct functor {
int& operator()(int& i) { return ++i; }
};
int main() {
int i = 0;
cout << functor{}(i) << endl; // 関数オブジェクトは問題なし
function<int& (int&)> lambda = [] (int& i) { return ++i; }; // コンパイルエラー
cout << lambda(i) << endl;
return 0;
}
「'main()::<ラムダ(int&)>' から非スカラ型 'std::function<int&(int&)>' への変換が要求されました」
というエラーになるのですが、どうしてでしょうか？
そもそもラムダ式は関数オブジェクトのシンタックシュガー、つまり等価なのではないんでしょうか？
戻り値がintになってる
戻り値の型を後置で書いてやればいいかな
function<int& (int&)> lambda = [] (int& i) -> int& { return ++i; };
ありがとうございます。
戻り値の型を明示してあげないと値渡しになってしまうということですね。
勉強になりました。
typedef int myTypeB;
class Test {
void set(myTypeA a);
void set(myTypeB b);
priate:
int A;
int B;
};
のような事例で、引数に応じて専用のセッターを用意したいのですが、
int型の2種類の引数に対して、上記のように書くとコンパイルエラーになってしまいます。
どのようにするのが良いでしょうか？
struct my_TypeA{ int v;};
structかclassで別の型にしないとダメですね
ありがとうございます！
汎化
f(親型)
ここに、親型の子型であるA型・B型が入っても、正常に動くのが、オブジェクト指向
セットする値の名称にする
例えば三角形を表すオブジェクトで底辺と高さをセットするのであれば、base()とheight()になる
プロパティとして使うのだから、setXXX()みたいに書かなくてもいい
setter単独で存在することはありえないからgetterも設けること
setterって余り必要ない
コンストラクタからの初期化で十分の場合が多い
だぶるでぃすぱっち
そこらへんはコンパイラで最適化されるんですかね
法を2進数にしたときほとんど1かほとんど0なら手間の少ない方法はある。
法が固定で何度も剰余を取るならモンゴメリリダクションがある。
どちらも乗算はそれなりに必要。
ありがとう
ちょっと調べてくる
int g_Val = 0;
int Func( int A, int B )
{
int Val = A * B;
lock_guard<mutex> Lock( g_Mtx );
return g_Val = Val;
}
void ThreadFunc0()
{
}
すみません、途中で送信してしまいました。
int g_Val = 0;
int Func( int A, int B )
{
int Val = A * B;
lock_guard<mutex> Lock( g_Mtx );
return g_Val = Val;
}
void ThreadFunc0()
{
int Val = Func( 2, 3 );
// Valを参照する処理
}
void ThreadFunc1()
{
lock_guard<mutex> Lock( g_Mtx );
// g_Valを参照する処理
}
上記のようなスレッド関数が非同期に実行されるとき、
Func()はスレッドセーフ（g_Val書き換え中に参照されない）でしょうか？
(1)lock_guard<mutex>によるミューテックスロック
(2)g_Valの書き換え
(3)戻り値を読み出し元スレッドにコピー（あるいはムーブ）
(4)lock_guard<mutex>がスコープから外れアンロック
というシーケンスを期待しています。
正：呼び出し元スレッド
void Func1(char a);
下記の型の関数ポインタに代入して呼びたいと思っています。
int*(*p)(int*);
p = (int*(*)(int*))Func1;
p((int*)123);
動作としてはFunc1(123)と呼んだときと同じものを期待しており、
試したところそれっぽく動作しているのですが、
致命的な問題等あります？
"暴走の危険あり"など。
long longとかで無ければ実害は無い
C11の6.3.2.3の8によると、the behavior is undefinedだ。
たとえばcharが4バイトに自動昇格して、ポインタが8バイトだったりすると、
どうなるかわかったもんじゃない。鼻からなんちゃらだ。
C++は知らん。
コンパイラが何をしでかしても文句言えない。
たまたま今の環境で動いても、明日コンパイラを更新したら挙動が変わりうる。
void Func1(char a); を呼び出すラッパ関数を使うのはどうだろ?
int* Func1_wrapper(int *p)
{
uintptr_t arg = (uintptr_t)p;
Func1((char)arg); // 縮小変換が危険
return NULL;
}
int* (*p)(int*);
p = Func1_wrapper;
p((int*)123); // 明らかに不正アラインメントだが
関数ポインタ同士は互換で、お互いにキャストすることは許される。
が、呼ぶときは元の型にキャストしなおしてからじゃないとあかん。
windows.hで一つ一つボタンの位置を設定してハンドルやらコールバックと格闘するもんなんでしょうか
それとも何か気の利いた便利なライブラリとかがあるんでしょうか
というかこの手のライブラリやフレームワーク的なものを探したりしたい場合はどういう場所から情報を集めるものなんでしょうか
それっぽいキーワードでgoogleで検索して探そうとしても上手く情報を見つけられないのですが、根気よくページを確認していくしかないのでしょうか
基本的には win32api を使うことになり、私は C++ からwin32api( ::DefWindowProc() とか)を個別呼び出している
気の利いたライブラリのことはよく知らない
頑張って勉強します
Windowsに特化するなら Win32APIのほかにMFCやWTLや.NET framework(C++/CLIで良ければ)などのライブラリを使う
サードパーティならC++ BuilderのVCLとかあとはクロスプラットホームのQtとかGtk+とかwxWidgetsとか他にもあると思うけど
最近はデスクトップアプリが落ち目なのでこれという定番はなくて目的に応じて分散しているのでは？
自力で情報が集められない程度ならC++でGUIなんて止めとけという気がしないでもない
ボタンの配置などは、リソースエディタでダイアログテンプレートを作ってDialogBox関数を呼べば、細かい調整ができる。
イベント駆動やメッセージ送信などについては、<windowsx.h>で提供されるメッセージクラッカーやマクロを使えば便利になる。
私が複雑なことをする場合は、MZC4という自作のクラスライブラリを使ってる。
私はさらに、HANDLE_MSGの呼び出し先の関数の入力を楽にする自作のMsgCrackというツールを使っている。
ttps://github.com/Microsoft/cppwinrt Windows API を現代的な C++ に合わせて整理したものなので、
C++ 的にある程度まともな感じがする。
昔は仕方がなかったんだろうけど、
今にしてみればメッセージクラッカーっていかにもクソダサい方法だよな～。
tcl/tkが一番手軽
ttp://mevius.5ch.net/test/read.cgi/tech/1510395780/ 次の方どうぞ
↓
どうも
誤差だ、
プログラミングスタイルを曲げてまですることではない
さいですか ありがとうございました
速さを突き詰める為の工夫というより、誤って異常に処理時間のかかるようなプログラムを作らないようにする為にはどのような事を意識すると良いのでしょうか
あまり呼ばれない場合はstaticの方が遅いよね、キャッシュ的に
マルチスレッドで邪魔だし、必要がある時以外は使うもんじゃないよ
メモリアクセスのコストだあ
多分、メモリを毎回確保し直す事や、コンストラクタを何度も呼ぶ事により処理が遅くなると考えたのではないでしょうか
実行速度は推測ではなく測定することが鉄則だから
出来ることは気になったときに正しく測定出来るようにすることくらいだ
ファイルアクセスのような重い処理とか深いループの中の計算処理とかは必要に応じて適切なデータ構造やアルゴリズムをあらかじめ検討しておくけど、頻度が少なく問題にならない箇所は分かりやすさ実装しやすさ優先で無理に速度は追求しないかな。
あとは将来的に性能改善が必要になることもあり得るから基本的には柔軟性のある変更に強い設計を普段から意識しておくとか。
ほんこれ
無駄なループを通らせないとかそういう話でしょ？
そういうのは単に気をつけるしかしゃーない。
発覚したときに直せるような体制にしておけ～
とりあえず注意すべきは線形探索かな
何も考えずに使われると素敵なことになる
（メンバ関数をfriend指定するのはBがAのプライベートメンバにもアクセスできてしまうのでNGです）
passkeyイディオムを使えばいいんですね
言語仕様でサポートしてほしい気もしますが
char* c;
char *c;
この2つは一緒なのですか？
とか
char
*
c
;
も含めて一緒
一緒ですが個人的に後者を推奨します
ありがとうございます
どちらが正しいのか、機能が違うのか、よくわかっていなかったのがスッキリしました
前者だと
char* a, b;
って書いたとaとbの型が変わっちゃうから常に後者方式で
char *a, *b;
みたく書くことをオススメする
char* a;
char* b;
まあ人によって色々やね。
普段から使うには綴りが長い気もするな。
別に自由ではあるけど、前に寄ってるとなんか違和感あるわ
俺は
char *a;
int & ref;
だ。
設計者的にはこれが推しなんやろなて思うたんや。
両方詰めたらどうなるん
これ
それな
前者は誰が流行らしたんだハゲか
ttp://www.libjingu.jp/trans/bs_faq2-j.html#whitespace まあハゲの影響はあると思う
マイクロソフトじゃないか？
リテラルの後ろにも置ける
x[2]は2[x]でも普通に動作するらしい、使ったことはないが
宣言の中の型としての*の位置を問題にしてるのだから、式の中での*が使える位置については別の話でしょ。
見た目とコンパイル速度のどちらを優先するかによる。
インデントやその削除にキーを何度も叩かなきゃならない状態だったらTABがまだ主流だったろう。
初めて知ったw
他にも変な仕組みは色々とあるけど、これはひとつとして使いどころが思いつかんよな。
a[5] と *(a + 5) が同等で + 演算子の交換可能性から *(5 + a) も可、
それなら 5[a] も同じじゃなきゃ片手落ちだよね、って発想というか、
過去のコンパイラの実装とも関係がありそうな気がする。
もちろん、古いCコンパイラとのソース互換性が問題になるほど
みんなが使ってた書き方とは思わないけど。
IOCCC …
なんでi++の方がデファクトスタンダードみたいになってるんでしょう？
ほぼ無視できる程度のメリットしかないとしても、++iと書くデメリットがないと思うのですが
インクリメントの対象が整数しかなかった C からの習慣がなんとなく引き継がれてるだけ。
後インクリメントは気持ち悪いと考える人は少なくはないし、
値を使わないなら前インクリメントにするのは C++ では良い習慣だよ。
なるほど、最初はちゃんと意味があったんですね
納得できました
ありがとうございます
a = *p++; みたいなポインタの使い方で手が慣れたせいもあるかと思う。
C++では性能的な理由で前置が好まれたのは指摘のとおり。
個人的には、どっちでも構わない場面ではCでは後置、C++では前置で書くかな。
特に単純なforで++iと打つと、途端にC++で書いてる気がしてくる。
基本的には更新前のオブジェクトの状態の退避などの処理が必要な後置インクリメントよりコストの少ない前置インクリメントが好まれるのだと思うよ。
ほとんどのコードは壊れないと思うんだけど、そういうルールを言語仕様に追加するのはもう出来ないかなぁ？
ぶっちゃけ、よっぽどシビアに速度を求める訳でないなら前置後置の差なんて気にする必要無いんじゃないかなぁ
記述を変えるって
間違ってる気がする・・
昔はそんな事は当たり前だった
ソフトに対する価値観が変わったからか
速度を気にするというのもあるけど、意味的にも無意味な処理をするってのがダサいだろ？
お前のコードは無駄ばかり
コンパイラも無駄命令を吐く
そもそもCPUの動作自体が無駄ばかり
そのプログラムを作るのも無駄だったり
お前の存在は？
後置の方が保守性が高いとか可読性が高いならともかく、そうじゃないんだから天秤にかける必要さえない
それで見やすくなるなら別にいんじゃね
というか最適化でやるべきことだと思う。
細かいことまでいちいち配慮しなきゃならないのは最適化技術の敗北。
仕様に [[likely]] なんて入ったのは不格好な話だ。
ポインタのと類似性そこまで要らんし
イテレータで *it++ とか書きたくて仕方ない人もそんなに居ないだろ
void型でよかった
高級アセンブラの名残じゃね？
逆じゃないかなぁ。
ポインタをイテレータとしても使えるように一貫性を持たせたら結果的にそうなったって感じじゃないの。
どちらにしても、そこで無理に一貫性を持たせようとしてしまったことが良くなかったとは思うけど。
ちなみに operator++ の返却値を void にすることは出来ます。
inc/dec でフラグが変化しないアーキがあった、というか、それが普通だと思っていたんだが
PDP-11とかのアドレッシングモードにあるオートインクリメントが起源。
間接参照したあとにレジスタが増える。
オートデクリメントは逆にプレデクリメント。
あとinc,decでフラグが変化するのもPDP当時は当然の動作。
PCつかわないから、Ubuntuなんてプログラム環境は大体パッケージで手に入るし
スゲエ良いと思ってたんだけど、エロ動画配信サイトが今時は必ず専用の○○プレーヤーじゃないと
見れないんだな。たとえば、DMMプレーヤーとかそのサイトの専用の奴。なんでもDRMとかいう不正禁止のが
付いてて、普通のプレーヤーじゃ見れないのよ。スゲエ不便だからそれ専用にWindows１０準備しちゃおうかな・・ｗ
俺はプログラム言語でC++が一番すきです。
ググればすぐにわかることだけど、有るよ。
reserve(size_type)はあるのにshrink_to_fit()がないのはなぜですか？
for (int i = 0; str[i] != '\0'; ++i) {
printf("%02X ", (unsigned char)str[i]);
}
cout << endl;
}
↑の文字コードを16進数で表示する関数ですが、なぜ
printf("%02X ", str[i]);
ではなく、
printf("%02X ", (unsigned char)str[i]);
とキャストしているのでしょうか？
その本は窓から投げ捨てろ。
ｰ128～127が正解だ
本にはそうは書かれていませんでした。申し訳ありません。間違っていました。
アスキー文字コードは、0から127までの値しか取らないからOKかなと思ってしまったのですが。
何か不具合が起こる例を教えていただけると助かります。
char ch = 255;
printf("%d\n", ch);
C/C++では、オーバーフローは警告なく普通に起こる。
printf("%c\n", (char)255);
%dね。
そんな事は決まってない
「決まってない」の反論になってないよ
現行品でcharが16bitの環境があるんだけどね
ちょうど今符号無しの環境を使ってるよ
初心者お断り感あるけど、重箱の隅を全力でほじくり返す人がいるからしょうがないね。
以外に遭遇した事無いけどな
の質問に対してcharの符号有無が環境によって異なるというのは本質的な回答であり、ビット数の話は不適切だったというだけで、重箱の隅がどうこうという話では無いだろう。
そもそも初心者歓迎のスレで初心者を除外する要件を設けるのは本末転倒では？
環境を明示しろって言うのはにも書いてあるんだが...
初心者だろうと質問に付随する前提知識は必要
変数知らんデータ型知らん制御文も分からないじゃ説明しようがない事なんていくらでもある
まずそこら辺の知識を理解してもらわん事には説明できないですってのは初心者を除外とは言わんだろう
とか
不都合と言う程の不都合か分からないけど、
単なる char が signed char のコンパイラで、例えば str[i] == -1 の時、
printf("%02X ", (unsigned char)str[i]); なら表示は "FF "
printf("%02X ", str[i]); だと表示は "FFFFFFFF " (intが32bitの環境)
てな具合に表示結果が指定桁数とずれて見苦しい、という現象が起きる。
ただし void DumpCode(const char* str) でASCII文字列しか扱わないなら、
意図せずASCII以外(漢字など)を含んだ文字列を引数に与えたときに
「見苦しい表示結果」のおかげで関数の使い方の間違いに気付きやすい。
よって (unsigined char) のキャストをしない方が好ましい、て考え方もある。
ARM で GCC だと、単なる char は unsigined が普通みたい。
元のCPU設計で符号付8bitが拡張機能だったことと関係あるとかないとか。
まぁ、341の例だと渡されるポインタ配列が文字コードの範囲内ならキャストは要らんね
なんかの理由で文字コード外の数値が入ってきた時に文字揃えがズレる事を嫌って一応キャストしたって感じだとは思うけど
delete[] p;
delete[] p で int 100個分の領域を解放するのだと思いますが、
どうやって、 p が int 100個分の領域を指していると分かるのでしょうか？
p は単なる int 型へのポインタです。
つ -fsigned-char／-funsigned-char
そうですが、なぜ、エラー終了にしないのでしょうか？
良くある実装としては
newが返すアドレスの前にヘッダ情報がある
(すぐに)わからないから
バッファオーバーフローの場合は割り当てたメモリとバッファ境界がミスマッチなら直ぐにエラー検出できないとしても仕方がないけどこれは質問とは別の話
例えばint型配列のfooとint型変数のbarがあったとして、
int n = foo[10000]; と
int n = bar;
の速度は同じですか？
foo[10000] と foo[1] が同じって話だぞ
ありがとうございます
だとすると、同じ添え字に何度もアクセス(読み取りのみ)する場合、一旦変数に待避させてその変数を参照した方がいいですかね？
最適化具合でも全然ちがう
吐き出したコードってどうやって確認するんですか？
ありがとうございました。
そのあたりのことを詳しく書いてある本はありますか？
確かにそうですね
ありがとうございます、やってみます
使っている環境による
機械語一歩前のアセンブラも出力するオプションで出てきたアセンブラとデータシートから推定する
もっと前のアルゴリズムの検討は済んでて、
もはや、枝葉を削ってでも速度を出さなきゃいけないという最終段階の話だよね？
char 型が符号付きであってもなくても格納可能な範囲という意味では 0 ～ 127 であると思って使ってれば間違いないのは確か。
あと、厳密にはマイナスの表現に 1 の補数を使ってる環境は有りうるので
char が符号付きだとしても -127 ～ 127 しか表現できないかもしれない。
言語仕様では文字がアスキーコードとは保証してないんだ。
ほとんどの環境ではアスキーコードかそれと互換な文字コードだろうけど、
EBCDIC とかでも言語仕様には違反しない。
並のOS環境って何だよwww
一般的なMCUのほとんどは
アドレス変換テーブルの仕組みがなく
スタックオーバーフローを検出するハード的仕組みも無い
無知は出てくるな
片方はstd::queueにつんで、もう片方はそれを取る
これで詰まれた瞬間に取るにはどうするのがいいのかな？
簡単に作るなら、無限ループでスリープ挟みながら取り続けることだけど、無駄も多いから積んだのをトリガーに取りたい
環境はg++とVC++です
stackoverflow で、たまたまアクセスしたメモリに、
どんな値が入っているかは、誰にも分からない。
単に前に入っていた値が、入っているだけだから
その値が、たまたまCPU 命令にあれば、CPU を実行するから、
エラーになるのは次の命令以降になる
一方、CPU命令に無ければ、不正な命令となり、即座にエラーとなる
昔汎用メッセージポンプを検討したときのサーベイにstd::condition_variableと書いてある。
注意としてspurious wakeupというのも書いてある。
もうすっかり忘れてしまって何のことだか自分でも思い出せないのだが、「条件変数」というのがキーワードになるようだ。
してる環境もあれはしてない環境もある
ページ単位ではしていることがある。
OS がメモリの割付を管理していて、
足りなければ追加で割り当てたりもする。
割り付けてないメモリ空間に変に触ったら検出できる。
スタックエリアの管理は当然してる
オーバーランの監視は環境次第
ハード的に仕組みがあるものもあし
ソフトで(コストをかけて)やる場合もあるし
全くしない環境もある
セマフォの類を使え
C++は使わないが組み込みだとC++を使いたい。CからC++に変えてみようとおもっってテスト
してみたことがあるが、メモリーを食い過ぎてStringはつかえなかった。
どこまでなら使えるんだろ？ なにか目安はないか？
STLは一切使わないのが普通じゃないか？
例外
ラムダ式
は使わない
もちろん規模によるけど
業務用複合機なんてそこらのパソコンより凝ったハード積んでたりするし
ADSP-21573ぐらい
見ると非常に便利で驚いた。C++のSTLは全然しらなかったがWikiを読んだらなんかかなり魅力
的に見えてきた。
new / delete は使わないリストに入れんのかよ…
どっちの話をしているんだ
あるなら使いたいからご教授ください
min とかあるか
内部でnew/deleteしてるものは当然含まれる
当たり前
そもそもヒープエリア自体無かったりするし
あってもアロケートのみで解放機能が無かったりする
小規模組み込みでメモリを確保出来ないなんてことは想定しないし
確保解放のコストもバカにならない
アドレス変換が無いから隙間だらけで連続領域が取れなくなるなんてことも心配したくない
そりゃ規模による
注意していれば、2重インクルードをせずに済むにもかかわらずなぜ、このような
対策をしなければならないのでしょうか？
人間の注意力なんてクソザコだからだよ。
複数のヘッダで共通のヘッダの定義が必要な場合を考えてみようか
header_2
…
header_n
で共通に必要なヘッダ header_a がある。
header_1
header_2
…
header_n
のそれぞれの中で header_a をインクルードしている。
header_i と header_j （i ≠ j） が必要なファイル file1 がある。
というような状況でしょうか？ 👀
Rock54: Caution(BBR-MD5:0be15ced7fbdb9fdb4d0ce1929c1b82f)
stdlib.hとstdio.hの両方でerrno.hが必要だとします
あなたはstdlib.h stdio.hの中でerrno.hをインクルードしますか？しませんか？
入門書にこう書きます
「studio.h や stdlib.h をインクルードする際には、事前に errno.h をインクルードすること」
どうかなとは思うが実際こういう流儀でヘッダーファイル書く人も見かける
つ FORTRAN77
FORTRAN77は識別子の長さが6文字以下とかの制限があったからそれに倣ったんじゃないかな
プリコンパイルヘッダが汚れたり無駄にでかくなったりするからな
ttps://wandbox.org/permlink/K1TIhC61VQztTbOd map<string, boost::function<base* (int)>> factories;
とするとコンパイルエラーになり、ググって見つけた方法で
map<string, boost::function<base* (int const&)>> factories;
とすると何故かコンパイルが通り、問題なく動作します。
コンストラクタの引数が実際の int ではなぜ駄目なんでしょうか？
実装依存のヘッダファイルの場合とか、ユーザに事前にincludeしろとは言えないケースもあるよ
実際 factory 以外の普通の関数なら問題ないし
先頭6文字だけ見て一意に決まることが条件で、名前の長さ自体に制限はない、
じゃなかったかな。大文字小文字は同一視で。
公式ドキュメントにはさらりと「技術的理由によりfunction objectに渡す引数はlvalueでないと駄目」と書いてあるのみなので、さっぱり理解できませんでした。
そもそもコンストラクタbase (int const&)は定義していないのにコンパイルが通るのが不思議・・・
結局 boost::bind(boost::factory<derived*>(), _1); が何しているのか理解しないと先に進めなそうですね。
引数のある関数の場合はboost::bindを使うのではないでしょうか？
いちおう公式にもその例が書いてあります。
ちなみにどんぴしゃな質問がstackoverflowにあり、Answerには親切にDemoまで付けてくれてて、
速攻で解決したと糠喜びしたんですが見事にコンパイルエラーでした。
ttps://stackoverflow.com/questions/37137117/passing-arguments-in-constructor-with-boost-factory 引数を部分的に何かにbindしたfunctionを作るのがbindなわけで、
(add(a,b) の a だけ1にbindしてadd1を作るとか)
何もbindせず引数の順序も同じなら
factories["derived"] = boost::factory<derived*>();
で良い
確かにbindのそもそもの目的はそれですよね＞(add(a,b) の a だけ1にbindしてadd1を作るとか)
仰る通りの書き方でコンパイルも実行も通りました。
ただ、ググった限り引数のある場合はbindをかます例しか見つからなかったです。
「bindが必要」と明言してる人すらいて、結局よくわからないです・・・
その後、いくらコンパイルも実行も問題ないとはいえ実際のコンストラクタとは違うのを
boost::function<～> に指定するのはなんとも気持ち悪く思い、試行錯誤したところ
boost::forward_adapter を使う方法を見つけました。
ttps://wandbox.org/permlink/D3Q75cgRNR43Nulc ヒントとなったのは以下のサイトでした。
ttps://lists.boost.org/Archives/boost/2017/02/232695.php 正直なぜこれで通るのか完全には理解していませんが、とりあえずの解決とします。
ご助言どうもありがとうございました。
公式にドキュメントがあるだろう。
なんでググりまくるんだ？
公式ドキュメントはこれです。
ttps://www.boost.org/doc/libs/1_66_0/libs/functional/factory/doc/html/index.html ここに以下のような「stringキーｚとコンストラクタのmapにコンストラクタを登録」するという方法が書いてあればよかったのですが・・・
map<string, boost::function<～>> factories;
factories["derived"] = ～
でもboostの公式ドキュメントはこんなものというか、隅から隅まで説明しないわからない素人はお断りってやつですよね。
以下のようなことが書いてあるファイルを読み込んで，
文字列，数値，．．．，数値，数値．．．数値
．．．
str, a[0],...a[n-1],b[0],...b[m-1]
という配列に入れたいです．
nとmは可変の場合，どうすればよいか教えてください．
スッキリとした書き方が知りたいです．
std::string str;
double a[n],b[m];
です．
std::vectorを使えば早かろう
std::vector<double> a, b;
a.resize(n);
b.resize(m);
a[0] = ...
ファイルの記述内容から n, m が確定するのか
今回はstringを見て，nとmを決めます．
str="a"ならn=2,m=3のような感じです．
読み込み方が分かりません．すいません．
Google先生に聞いてこんな感じのプログラムを書いてます．
std::string line;
std::ifstream infile("hoge.dat");
std::getline(infile,line);
sscanf(line.data(),...//どう書くの？
...
}
というような関数内で、 array の const メンバ関数ではないメンバ変数を変更しないメンバ関数を
使っているとコンパイルエラーになりますが、それはなぜでしょうか？
コンパイラーはarrayのメンバ関数がメンバ変数を変更していないことはソースコードから
分かるのではないでしょうか？
そういうチェックをするコンパイラを作るのは難しいからということでしょうか？
ということはどのみちメンバ変数を変更しているかどうかはチェック可能ということですよね？
コンパイル単位を越えたらチェックするのは難しいし言語の壁を越えたら不可能に近いから
中途半端な事をするくらいならconst明示されてるかという線引きの方が分かり易い
難しいというか不可能だからですよ
呼び出す関数はまだコンパイルされてないかもしれないしまだソースコードもないかもしれない
メンバ変数を変更しないなら素直にメンバ関数にconst付けれや
ソースファイルを分けてみればピンと来るかと。
片方をソースなしのオブジェクトやライブラリにしないとダメかな。
戻るようにするにはどうした出来ますか？
COM使えばできるけど、スレタイも読めないお前にできるかどうかはわからん
できるがスレチだからな
C/C++のスレッドに質問を持ち込むより確実で早いと思うよ。
思うが。
戻るようにするにはどうした出来ますか？
判断する訳ねーだろガイジか
CreateProcess() win32API スレへgo
it is conditional on your ability, although its mean applying in the case of a usual Japanese.
ロベールの本のpp.318-319にそのような例が出てきて意味不明です。
main() 関数の中でstatic変数を使う意味といえば、
単純型の初期化の処理時間を回避したいか、
セクション(変数のメモリ配置)の説明のためか、
「staticなインスタンスのコンストラクタはmain()より前に実行される」
ていう話の前フリかなぁ。
ローカル変数に static 変数が付いていた場合は最初に通過したときに初期化されるルール。
(コンストラクタもそのときに走る。)
これは C のときから変わってないよ。
単にスコープをローカルにしたいってのがまず考えられる
横からだけど訂正乙
初心者が読んで間違えて覚えるので、初心者スレでは嘘を書かないように特に気をつける必要ある
mainの中だから意味無い
っつーかstaticは二つの意味があって全然別物
スコープと性的と混ぜるな危険
関数内でstatic変数を使うのは静的変数のスコープを関数ローカルにしたいからでは、
というごく当たり前の文意だろ普通に読むと。
どう読むと
関数内だからファイルローカルの話とか関係ない！勘違いするな！となるんだよ
自分以外は文法もセマンティックもろくに知らないという前提はやめるべき
スコープはmaim( )内にしたいけどスタックは使いたくないってケースかな
ウェブ版をざっと探してみたら main 内で satatic 変数を使ってるのはこれだけだったんだけど、
これのことか？
ttp://www7b.biglobe.ne.jp/~robe/cpphtml/html02/cpp02037.html main()以前でなく、最初にその部分が実行されたときに初期化されるんだっけか。
static なら一律にmain()の前、基本型や単純な構造体のstaticはロード時に初期化、
だと勘違いしていた。
訂正してくれてありがとう。そして間違ったことを書いてすまぬ。
ありがとうございます。本とは内容が違うようです。
int main() {
static const double ARRAY1[] = {1, 2, 3, -1};
static const double ARRAY2[] = {0.5, 1.5, ,-1};
static const double ARRAY3[] = {-1};
static const double* const ARRAY[] = {ARRAY1, ARRAY2, ARRAY3};
…
}
というコードが該当箇所です。
でも、速さがどうとかいうことについては何も書いていないんです。
staticを付けていることについては何の説明もありません。
はきちんとした回答だと思うよ。
配列が大きくなれば顕著になる。
「その本に書かれていないから」と拒絶するのは憲法に基づいて自由だけど
というだけのことでそれ以上の意味はないと思うが
ローディング時間も早くなる
だぶんだけど、 が言おうとしているのは「 だとしたら入門書としては不親切だよね！」って話じゃねーの。
ROMとRAMに別れてる環境、
つまりほとんどの小規模な組み込み環境だと
static const は通常ROMに配置される
要するにRAMの節約
速度は逆にRAMの方が速いのが普通
privateなメンバまで書くのはなぜですか？
必要ないように思います。
みなさん、ありがとうございました。
速度について気にしているのなら、ロベールにはそう書いてほしかったです。
例では、非常に小さな配列ですから速度について気にしていることは読み取りにくい
ように思います。
定数だから const にしたというのなら分かるのですが、なぜstaticをつけるのでしょうか？
private なメンバはむしろ、クラスのメンバ関数を実装する .cpp ファイルに書いた方がいいように思います。
なるほど、ありがとうございました。
pimplイディオムで、クラス詳細を隠蔽できるよ。
あの部分では特別に速度を意識した記述ではなく普通に意識する程度の事だから一々説明されないということではないかな
速度や使用メモリを気にするのはCやC++プログラマの癖または習慣みたいなもので特にロベールみたいな昔の人は体に染み付いているだろうからね
今回はたまたまmainであり、
たまたま小さなデータだったというだけで、
より汎用性の高いコードにするのはプログラミングの基本
staticを付けるメリットは
・データ構造の初期化が1回(ROMだと0回)で済む
・スタックを浪費しない
・関数を抜けてもデータが保持される
・番地が固定
デメリットは
・関数を通らなくても初期化される
・関数外でもメモリを使う
PCプログラムしかやらない人は知らないだろうけど
環境はvc6とstlport521です
void test1(const char* cstr, ...) {
char buf[1024];
va_list args;
va_start(args, cstr);
vsprintf(buf, cstr, args);
va_end(args);
printf(buf);
}
void test2(std::string str, ...) {
const char* cstr = str.c_str();
char buf[1024];
va_list args;
va_start(args, cstr);
vsprintf(buf, cstr, args);
va_end(args);
printf(buf);
}
void main() {
test1("hello1 %d\n", 123);
test2("hello2 %d\n", 123);
}
//結果
//hello1 123
//hello2 1819043176
void test3(std::string& str, ...) {
const char* cstr = str.c_str();
・・・
void test4(std::string* str, ...) {
const char* cstr = str->c_str();
・・・
void main() {
・・・
std::string str3("hello3 %d\n");
test3(str3, 123);
std::string str4("hello4 %d\n");
test4(&str4, 123);
}
//結果
//hello1 123
//hello2 1819043176
//hello3 1819043176
//hello4 1819043176
なんでcstr？
va_startはマクロであってcstrの部分は引数の変数名が指定されなければならないということですかね
ありがとうございました
void test5(std::string str, ...) {
char buf[1024];
va_list args;
va_start(args, str);
vsprintf(buf, str.c_str(), args);
va_end(args);
printf(buf);
}
void main() {
・・・
test5("hello5 %d\n", 123);
}
//結果
//hello1 123
//hello2 1819043176
//hello3 1819043176
//hello4 1819043176
//hello5 123
各 argument に課される制約と同じ制約がある
配列はダメ、参照はダメ、基本型が格上げされる型との互換性が必要、など
最後のはクラスオブジェクトや float はダメということ
仕様として結果が不定なだけで違反してもエラーにはならないし
意図した通りに動くことも多い
詳しくは default argument promotions va_start
で検索
template<class... T>
void test6(std::string str, T... args) {
char buf[1024];
std::sprintf(buf, str.c_str(), args...);
std::printf(buf);
}
アホなの？
なんでbufに一旦書いてるの？
直接printfじゃだめなん？
クソコテがコードサイズ、互換性、実行速度など
全て犠牲にしてもテンプレートを使いたかったみたい
C++ らしく va_start 使わない例を出したんだろ…
と書いてはみたが、
そういう意図が通じるわけないか
通じる人は最初からわかってるもんな
コメント元のにすべきだろ
誰も求めてないwww
オナニーは隠れてやれ
危険性が高いかどうかは重要じゃなくて、話題のテーマに近いかどうかだろ。
本題に関係ないところなんてどうでもいいじゃないの。
アホですね
const double ARRAY[] = { 3, -1 };
の違いを教えてください。
・変数も指し先も書き換えられない
・変数は書き換え可能。 指し先は書き換えられない
のパターンだけど
対象が配列の場合、元々変数の書き換えができないから同じ意味じゃないかと
> const double const ARRAY[] = { 3, -1 };
コンパイルエラーにならないんだっけ？
ありがとうございました。
Visual Studioではコンパイルエラーになりません。
は
const double a[];
と同じ意味
const const double const const a[];
なんて書いてもいいし
double const a[];
と書いてもいい
const typename と typename const と同じ
しかもconstはいくつ書いてもいい
すべて成功したときのみTRUEを返したいのですが
(途中で失敗しても関数自体はすべて呼んでおく)、
BOOL Test()
{
BOOL bResult = TRUE;
bResult &= Api(...);
bResult &= Api(...);
bResult &= Api(...);
return bResult;
}
と書いてとりあえず動くのですが、よく考えたら&=はビット演算だし、
Win32のBOOL関数は成功時にTRUEを返すとは書いていないので、
例えば関数が成功時に2を返すパターンがあったら、
すべて成功しても戻り値はFALSEになるのではと思っています。
この場合、
bResult = Api(...) && bResult;
bResult = Api(...) && bResult;
bResult = Api(...) && bResult;
みたいな書き方をするしかないのでしょうか。
という風に!!を使うのも zero, non zero を false/true に正規化するイディオムだけど、
何にしても見た目は汚いと思う
文字数は増えるがif文を使って
if (!api()) result=false;
の方が可読性高いかもしれない
成功した回数をカウントして呼び出す関数が3つなら3でTRUEにするかな
BOOL Test()
{
int count = 0;
if(Api() != FALSE) count++;
if(Api() != FALSE) count++;
if(Api() != FALSE) count++;
if(count == 3) return TRUE;
}
> bResult = Api(...) && bResult;
> bResult = Api(...) && bResult;
> bResult = Api(...) && bResult;
これでいいと思う
３個位ならいいけどたくさんになると数え間違いとかやらかしそう
1年後の自分がやらかしそうだわｗ
return Api()&Api()&Api()...;
そもそもの質問のキモがわかってないよ
例を簡略化しすぎてしまいましたが、処理は状況によって分かれるため、
常に同じ関数が3回というわけではありませんでした。
失礼しました。
bResult = Api(...) && bResult;
の書き方自体は、そこまで汚いわけではないのですね。
同じような書き方をしているソースも、検索してみたら出てきました。
個人的には、
bResult &&= Api(...);
のような記述ができるとありがたかったです。
こういう手段もあるぞ。
bResult *= Api(...);
一度 0 になったら何をかけても 0 だ。
「返り値が0でなければ成功」の関数で変テコな返り値が来ると
組み合わせでダメになるかも。
256 * 256 == 65536 で オーヴァーフローして0、みたいな感じ。
無駄にトリッキーなコードを書くのはおすすめしない
デバッグ用コードを追加しやすい以下で良い
if (!Api(...)){
bResult = FALSE;
}
...
数が少なく重要じゃなければ で良い
数が多ければ色々と工夫しようか
適当なニ数をかけたら 0 になってしまった、とかはあり得るのでしょうか？
…んー、ないな、何故ないのだろう？
つけてもつけなくてもどちらでもいいという場合はあると思いますが、
つけちゃいけないという場合が考えにくいのですが、そういう場合は
あるのでしょうか？
デフォルトの機能にすればいいのにと思います。
どうでしょうか？
仮想メソッドは、最適化がなければ関数ポインタのように確保されるので、不必要なものはメモリーの無駄になる。
virtualはつけなくてもかまわない場合には付けない方がいいということなんですね。
ありがとうございました。
オーバーフローで0とか
せやな。 普通はないと思うが、無いと言い切ることもできない。
ここまでいろんな案が出てるけど、なんだかんだで が自分で結論出してるのがベストだと思う。
書き方の話なら、マクロでもクラスでも適当なものでラップすれば見栄えはどうとでも出来ることだし。
普通は意識しないでしょうねぇ
0x80000 等掛けたらゼロになるケースを意識しないのはむしろ不自然
ケチケチすんなってｗｗｗｗｗ
ほんとうにバカだなあ
汚い書き方とまでは言わないけど、個人的にはあまりいいやり方だとも思わないかな。
俺もC, C++を覚えた当初はなるべく冗長な記述を省くことが正義であると考えていたけど、
そのうち高々数文字削ることなんかより、素直に可読性や保守性が高い記述をする方が美しいと感じるようになったよ。
補足すると、仮想関数は呼び出しのコストも同じ理由で非仮想のメンバ関数より高い(わずかだけど
あと、仮想関数が一つでもあるクラスは、そのクラスのオブジェクトの先頭に仮想関数テーブルへのポインタが入る
つまり純粋にメンバ変数のデータ通りのメモリイメージになるクラスが作れなくなる
virtualかどうかを選ぶ余地があるってことは選ぶ必要があるということだよ
ネタだろうけど、ほんとにそれが必要としてもよほどメモリーに困ってるのでないならとかでいいだろ
その時代の知識で止まってるの？
cout << a << a++なら21
cout << a++ << aなら12
cout << a++ << a++なら21
と表示されました。
coutはどんな順番で評価されているのでしょうか？
確かに以下は
ttps://ideone.com/sBACG3 21
12
21
と表示される
でも、手元のVC 2017 / Windows 10 では
11
12
11
と表示された
g++ x86_64-posix-seh 7.1.0 / Ubuntu 16.04.3 LTS on Windows 10 では
11
12
12
と表示された
ttp://codepad.org/KVv4KD8O ではコンパイルエラーになった。
cc1plus: warnings being treated as errors
In function 'void test1()':
Line 6: warning: operation on 'a' may be undefined
In function 'void test2()':
Line 12: warning: operation on 'a' may be undefined
In function 'void test3()':
Line 18: warning: operation on 'a' may be undefined
ttp://techtipshoge.blogspot.jp/2012/01/c.html ttp://www.kouno.jp/home/c_faq/c3.html ttp://www.st.rim.or.jp/~phinloda/cqa/cqa7.html こんな書き方をするなってことだね
いくつかの例外を除いて式中の各項が評価される順序は決まっていないので、
評価される順を知りたいのなら実際にコンパイルされた結果のコードや挙動を見て調べるしかない。
同じ順序で評価されない可能性もある、じゃないかな。
実際のところ、コンパイルごとに評価順が変化するとも思えないけど。
いずれにせよ「未定義動作は避けろ」が間違いない方針だわね。
おお、「未定義動作となること」を検出してコンパイルエラーにする環境もあるんだな
public:
void A();
protected
virtual void B();
}
void Base::A() {
B();
}
void Base::B() {
cout << "Base" << endl;
}
class Derived : public Base {
protected
virtual void B();
}
void Derived::B() {
cout << "Derived" << endl;
}
Base b;
b.A(); ⇒ 「Base」が表示される。
Derived d;
d.A(); ⇒ 「Derived」が表示される。
b = d;
b.A() ⇒ 「Base」が表示される。
b.A() ⇒ 「Base」が表示される。
↑で、なぜ、「Derived」が表示されないのでしょうか？
ロベールの本に、
「仮想関数はどんな状況でもそのオブジェクトの本来の型のものが呼ばれる」
と書いてあります。
B();
}
void Base::B() {
cout << "Base" << endl;
}
A() の中で、B() を呼んでいるから
A(), B() は異なる関数なのに、呼ぶなんてあり得ないだろ。
こんなコーディングはしない
よく分かりません。
ポリモーフィズムというのがありますが、その考え方だと
b = d;
b.A() ⇒ 「Derived」が表示される。
のではないかと思ってしまいます。
class Base {
public:
void A();
protected
void B();
};
すると、
Base b;
b.A(); ⇒ 「Base」が表示される。
Derived d;
d.A(); ⇒ 「Base」が表示される。
スッキリわかる Java入門 第2版、2014
最難関のC++ で、オブジェクト指向を学ぶなんて、夢のまた夢w
軽く、数年を無駄にするだけ
C++ なんて、偏差値70以上しか無理やのに
> b = d;
> b.A() ⇒ 「Base」が表示される。
Base bp;
bp = &d;
b->A();
こうやね
間違えた
Base *bp;
bp = &d;
b->A();
ありがとうございました。
C++が難しいというのは、設計が悪いからですか？
C++と同等の機能を持った言語で、C++よりも分かりやすい言語を新たに
設計することは無理ですか？
ありがとうございました。
試してみようと思います。
難しいということになると、利用者にとっては迷惑な話ですね。
さらに、ルールAでは、B, C は除くとか、
1つのルールが、他のルールとからむから、
非常に難しいし、組み合わせ爆発が起こる
膨大な時間を無駄にしても、さほど理解できず、身につかない。
組み込み機器も想定しているから、
どうしてこういうルールが必要なのか、初心者には理解できない。
Rust ですら、初心者には無理だろ
だから、ドワンゴ江添の本を持って、数年山ごもりしろって言われる。
ルールの多さで、廃人になってしまう
初心者には、絶対に無理。
最初から、エベレストを登るようなもの。
まず「スッキリわかる Java入門」とかの、低い山で修行を積むべし
このレベルでは言語どうこうじゃない。
小中高大学まで行くような、研修制度・道筋が大事。
徐々に基礎体力を付けていかないと、何もできない
あくまで、C++ の初心者というだけで、
C++ をやるには、最低でも数言語は知っている必要がある
特に、Java, C, Rust は、絶対に知っていないといけない。
組み込みの知識も必要
C++ の初心者だけど、他の言語はプロ級で、
PC・組み込み・Linux コマンドも知っていて、C++ を始められる
それでも、ほとんどのC プログラマーは、C++ へ進めない
第３版が難読版というのは判る
という理解が必要なんだろうけれどこれ難しいだろうか？
cから来た人なら
struct base b;
b = ...;
で b の型が変わるなんて考えもしないだろうけど
最近の人は c やらないのかな
試してみました。
確かにポインタを使うと期待通りの結果でしたが、参照を使うと期待通りにはいきませんでした。
これはなぜでしょうか？
#include "Derived.h"
int main() {
Base b;
Base& br = b;
br.A();
Derived d;
br = d;
br.A();
Base *bp;
bp = &b;
bp->A();
bp = &d;
bp->A();
}
実行結果は以下です。
Base
Base
Base
Derived
>br = d;
参照先のbに代入してるのと同じこと。
当たり前
br は b の別名なだけだから
b = d;
ってやってるのと同じ
b は Base の領域しかないんだから b.A() で Delived::A() を呼び出した時に Delived にしかないメンバ変数とか参照してたら困るし
Derived d;
Base & b1(d);
b1.A();
ありがとうございました。
下の結果は、
Base
Derived
Derived
になりました。1番目と2番目の違いがよく分かりません。この違いが分かれば、疑問が
解消することになると思うので、理解したいです。
#include "Derived.h"
int main() {
Derived d;
Base b;
Base& br1 = b;
br1 = d;
br1.A();
Base& br2(d);
br2.A();
Base *bp;
bp = &d;
bp->A();
}
Derived
Derived
となりました。
2番目と3番目は同じことの別表現のようですね。
見た感じ、1番目と2番目に違いがあるようには思えません。
Derived d;
Base b;
Base& br1 = b;
br1 = d;
br1.A();
Base& br2 = d;
br2.A();
Base& br3(d);
br3.A();
参照は初期化時に参照先が設定され、以降の操作は参照先に対してなされる。
初期化と代入を区別すること。
Base& br1 = b; // 初期化 br1 は b の参照
br1 = d; // 代入 b = d と同じ動作
Base& br2 = d; // 初期化 br2 は d の参照
ありがとうございました。
＞Base& br1 = b; // 初期化 br1 は b の参照
＞br1 = d; // 代入 b = d と同じ動作
br1 = d としても参照先は変わらないんですね。
ありがとうございました。
C++にC#などのインターフェースはない代わりに多重継承？できるのでそれを使うとのことで、
ttps://ideone.com/k7g2nn ITestAとITestBはインターフェース的なものです。
で、ITestAを実装したCBaseAを作り、CBaseAを継承しITestBを実装したCTestBを
作ったのですが、
CBaseBをnewなど実体化するとITestA::methodAがオーバーライドされておらずCBaseBは
抽象クラスになってて実体化できません。
ITestA::methodAをCBaseBでまた実装しなければいけないんでしょうか？？
というかこういう場合C++ではどうすればいいのでしょうか？
Derived Pointer : 120～139
こういう状況で、Base クラスを指す際、クラスポインターは100 を指している。
100～119 内で、Base クラスの変数・メソッドのアドレスを探す
Derived クラスを指す際、クラスポインターは自動的に、120 に変わる。
120～139 内で、Derived クラスの変数・メソッドのアドレスを探す
単なる文法エラーだからエラーメッセージみてコードを直してください
文法エラー？？
ttps://ideone.com/k7g2nnの今回の部分と関係ないエラーは無視してください。 あくまでイメージ目的でそこらへん適当にやりました。
すみません。
ttps://ideone.com/QxErKY こっちですね。
ttps://ideone.com/8SZhJ7 ならCBaseAとITestBどっちのmethodA呼ぶのかあいまいって怒られる
これならok
ttps://ideone.com/FGHyda の
>ITestA::methodAをCBaseBでまた実装しなければいけないんでしょうか？？
で書いたようにすればとりあえず、コンパイルは通ります。
聞きたいのは、
C#の場合はBaseAの方で一度MethodAを宣言・定義すればいいのですが、
C++の場合は毎回CBaseAの派生クラスでmethodAを宣言して定義しなおさなければいけないのでしょうか？？
それともC++では他の方法があるのでしょうか？
あ、すみません。ちょっと被ってしましましたね。は忘れて下さい。
のコードを見てみます。
そっか。純粋仮想関数じゃなくて仮想関数にするって手もありましたか。
まぁ、インターフェース的なクラスの方をいじくるのが気になりますが。
ありがとうございます。
インターフェース側をいじるのは仕方ない
どっちかになる
ttps://ideone.com/qrd4fN ttps://ideone.com/kVZzRi ATL なんかがこれ式かな
ttps://ideone.com/B7JWER 色々ありがとうございます。がよさそうなのでこれで行こうかなと思います。
たとえば１０００行のテキストからなるファイルの１０００行目だけを読み込んで、配列に
代入したいのですが、ファイルをopenしていきなり１０００行目にアクセスする方法はありますでしょうか？
現在、forループで１０００回廻して１行ずつ増やしてアクセスし１０００回目にfgetsで読み込んで配列に入れているのですが、９９９回のループが無駄なので高速化したいのですが、どなたかご教授いただけないでしょうか？
先頭から読んでいって逐次確認しないと行の区切りが確定しないのでどうしようもないんじゃない？
ファイルサイズ分一気にオンメモリで読んで後から行の切り出しするとかの工夫はあるだろうけど
テキストのフォーマットによっては高速化は可能
例えば1行が固定サイズとか行番号が書いてあるとか
全く自由なフォーマットだと頭から解析するしかない
読み込みスレッドと解析スレッドを分けると速くなることもあるかも
同じファイルが複数回指定されることが多ければ
ファイル名と更新日時と1000行目の位置
のデータベースを持つとか
「1000行目」の定義が先頭から数えて999番目の改行の次、である以上ありません。
1行のバイト数を全て同一にすることができれば(この場合しばしば行ではなくレコードと呼ばれる)
1000番目のバイト位置を計算してそこから読むことができます。
FILE * を用いてシーケンシャルにたくさん読む場合は
setvbuf でバッファサイズを拡大しておくと高速になることも多いので試す価値はあるでしょう
いろんな行に何度もアクセスするなら、
全てメモリに読み込んだ上で各行の先頭位置を配列に記録しておくと良いでしょう。
改行がなければまた戻って、を繰り返すのが現実的。
「そのテキストファイルの各行がファイルの何バイト目から始まるか」
という情報を覚えておく手はあると思うけど、整合を保つのが面倒よね。
の後半部分だな。
私の能力では難しそうですが、いろいろ高速化を試してみます。
\n が現れるまで１文字ずつ戻りながらキューに積んで
最後にキューの中身を逆順にする
scanf("%d",&n);
int array[n]; //読み込んだ値を要素数にするってこういう事？
auto v = vector<int>()だとfor (auto &i : v)でいけるのですが、
newした場合はどうすればいいのでしょうか？
autov = new vector<int>(); for (auto &i : v)だと
begin関数が見つかりませんといってコンパイルできません。
どうすればいいでしょうか？
auto v = new vector<int>(); for (auto &i : *v)
ありがとうございました
CやC++の仕組みのことなので、こちらで質問させていただきます。
複数のスレッドから呼ばれる関数の内部は、
CCriticalSectionを使って排他制御しています。
void Test()
{
static CCriticalSection cs;
cs.Lock();
:
cs.Unlock();
}
関数内のstatic変数は、その関数が初めて呼ばれたときに
実体が作成されると理解しているのですが、
1回目のTest()でCCriticalSectionのコンストラクタを実行している最中に
他のスレッドがTest()を呼んだ場合、このコンストラクタ自体は、
正しく排他制御されるのでしょうか？
コンストラクタが終わるまで、他のスレッドは待ってくれるのでしょうか？
それとも、CCriticalSectionの変数は、
関数の外に置かなくてはいけないものでしょうか？
MFCの内部でも、AFXPlaySystemSound()などで
同じようなことをやっているようなのですが。
ttps://cpprefjp.github.io/lang/cpp11/static_initialization_thread_safely.html ttp://d.hatena.ne.jp/yohhoy/touch/20120309/p1 C++11 でローカルなスタティック変数の初期化はスレッドセーフであると定められた。
(C++03 にはこの規定はなく、実際その頃はmsvcもgccもスレッドセーフではなかった)
msvc では 2015 から。
c言語バージョンの指定のほか、専用のオプションによっても有効化、無効化できる
以下を参照
ttps://docs.microsoft.com/ja-jp/cpp/build/reference/zc-threadsafeinit-thread-safe-local-static-initialization gcc / clang では -fno-threadsafe-statics オプション
エラーの行番号見ても、あってるよーな？よくわからない。
どうすりゃいいの。
ソースとエラー貼って
NDAを結ばないと出せません
コードすら貼らないオツムの足りなさじゃ諦めろ
ありがとうございます。
VSは2015よりも前なので、このやり方はダメってことですね。
関数の外に置くようにします。
MFCの内部ではやっちゃってますが。
ちょっとずつコンパイルしていかねぇとダメじゃん。このクソ言語。
エラーの内容はhファイルの方に"{"が期待されるところに"}"がありますなエラー。
ヘッダファイルと睨めっこしても、{}の数あってるし仕方なくcppファイルの方の実装の中身を全部コメントアウトしたら
コンパイル通った。で、cppファイルの方を数行ずつコメントアウト解除したらエラーわかったわ。
hファイルにエラーがあるとかミスリードしてんじゃねぇよ。
テレパシーは秘密保持違反になるから、このスレッドでは君を助けられないね。
つーか、仕事中にパソコンで５チャンネル閲覧記録は、大きな企業なら会社にチェックされているだろうね。
エラーの内容は
「hファイルの方に"{"が期待されるところに"}"がありますなエラー。」
みたいなエラーでて、この意味ぐらい自分で分かるし。
だから、このエラーの内容だけ張っても君たちが分かるとは思えなかったら張りませんでした。
お手数かけました片山さん。
ありませんでした。
まだ、Visual Studioの「エラー一覧」ウィンドウしかまだ見てないもので。とりあえず、初心者の自分は
頻繁に数行書いたらコンパイルすることにします。
今後のためにそのエラーになる最少構成でやってみ
class A {
B b;
B& get() { return b; }
const B& get() const { return b; }
}
このBがくっそ長くて書くのが面倒な場合、autoで代用するのはまずい習慣ですか？
auto& get() { return b; }
auto& get() const { return b; }
型の別名を定義することについての是非は置くとして、 typedef はオワコン。
using を使うのがモダンな C++ やで。
やはりヘッダーの返り型くらいはちゃんと記述すべきですかね
イタレータとか長くなりがちだけど・・・
auto& get() { return b; }
const auto& get() const { return b; }
と思う
修験者になって、数年山籠もりしたいのなら(笑)、ドワンゴ江添の、
C++11/14 コア言語、江添 亮、2015
ありがとうございます。
Herbert Schildtの本は、ロベールに比べると細かい話がないように思います。
柴田さんの中級という本も細かい話がないように思います。
コピーコンストラクタ、operator=
について一応勉強したのですが、 vector などのクラスでは、
コピーコンストラクタや operator= はどうなっているのでしょうか？
ディープコピーしてるよとしか
読み進めるにはテンプレートの知識が必要かもね。
ありがとうございました。
ディープコピーでしたら、使う上では、何も考えずに関数の引数として渡したり、
関数から返したりしてもかまわないですね。
ありがとうございました。
それはディープコピーのコストがかさむのでおすすめしない
>何も考えず引数で渡しても良いですね
何をもってして「良い」と評価するのかはわかりませんが、
そういうのは拙い知識で独断せずそこら中にある
経験豊富な先人の書いたコードを読んで真似するのがいいですよ
引数は大抵 const 参照で渡しているでしょう
{
TestA() {}
~TestA() {}
};
class TestB
{
TestB() {}
~TestB() {}
TestA getA() { return TestA(); }
};
int main() { TestB b; TestA a = b.getA(); }
TestBクラスの getA() メソッドがこのテストコードで正しく動作しているのですが、TestAの
インスタンスは一体どこで作られてるんでしょうか？
TestA getA() { TestA a; return a; }
としないでいきなり reurn TestA() で良い理由が良く分かりませんでした。
どこのメモリにどう作られているのかという質問だと思うけど、
C や C++ では式の値として構造体やオブジェクトが認められていて、
コンパイラがどこぞにメモリを用意して上手いこと作ってくれることになっている。
式や式の一部の値としてだけ現れて変数に格納されないオブジェクトはテンポラリーオブジェクトとか言うので、
詳細はテンポラリーオブジェクトでぐぐって。
のmain はテンポラリーオブジェクトを使って b を用意せず TestB().getA(); ともかける
ところで今回の質問の、関数の戻り値に関するコンパイラの動作は
「戻り値最適化」なる最適化によって色々複雑なことになっているので
これは自分で戻り値最適化でググって調べて欲しい。
質問が文法的なことについてだとすると、式中の項ととして
TestA()
std::string("foo")
などのように型名にコンストラタの引数を加えて関数呼び出しのように書くと
テンポラリーオブジェクトを生成してそれを値とする頃ということになる。
例
size_t l = std::string("abc").length();
std::string 型のテンポラリーオブジェクト(中身は"abc") が作られ、
それのメンバ関数 length が呼ばれ、l はその値(3)で初期化される。
詳細をありがとうございました。
大変良く解りました。より深くは自分でググってみます。
ttps://seleck.cc/685 ttps://trello.com/ ボードのメニュー → Power-Upsから拡張可能 Slack DropBoxなど
Trello Chrome拡張機能 elegant
ttp://www.kikakulabo.com/service-eft/ trelloのオープンソースあり
共同ツール 2
ttps://www.google.com/intl/ja_jp/sheets/about/ 共同ツール 3
ttps://slack.com/intl/ja-jp ttps://www.dropbox.com/ja/ ttps://bitbucket.org/ ttps://ja.atlassian.com/software/sourcetree ttps://sketchapp.com/extensions/plugins/ ttp://photoshopvip.net/103903 ttps://goodpatch.com/blog/sketch-plugins/ とやると、 i が n + 1 未満かどうかの判定をする際、毎度
n + 1 を計算してそれを i と比較するということになるので
しょうか？
もし、そうなら、
m = n + 1
for (int i = 0; i < m; ++i) {;}
としたほうがよいのでしょうか？
ただの整数の足し算程度なら最適化されることが期待できるのであまり気にしなくていい。
ttp://rosie.5ch.net/test/read.cgi/liveplus/1524621704/l50 ttps://ideone.com/TVzVzF 上記のコードで、read関数を持ったIReadableクラス（基底クラス）があって、そのクラスから派生したCFileReaderクラス、
直接は派生していないけどread関数を持ったCMemoryReaderクラスがあって、その両方を受け取れるvector<IReadable*>を作りたいのですがコンパイルが通りません。
どうしたらいいでしょうか？ どなたか教えてください。。。
いまだに最適化されないコンパイラもあることはある
8bitマイコンとかの話
あと、nがvolatileだと当然毎回計算する
nがSFRだったり複数スレッド共有変数だったりするなら気を付けよう
普通は気にしなくて大丈夫
コンパイラの最適化の基本の基本なので
このループの比較がパフォーマンスに大きく影響するなら
高速化テクニックは色々とある
なんとなく互換性のある read を持つものをエンベロープして IReadable になるエンベロープクラスを用いるのはどう？
ifstream も IReadable じゃないからエンベロープする。
ttps://ideone.com/27yhhu > for (int i = 0; i <= n; ++i) {;}
for (int i =0; i < count-1; ++i ) {...}
と書いてて、
後日に count を int から size_t にしたとき
countが0のケースではまったことがあるなあ
for (int i =0; i + 1 < count; ++i ) {...}
と書けば良いだけなんだけど
それcountが1でも全くループしないというヘンテコ仕様だけど
そんなもの手癖で書くの？
隣り合った2項、例えばv[i] と v[i+1] を用いた処理をするとか
後続のものがある項だけ処理するとか良くある
a を関数に渡して、計算に利用します。
2次元配列 a の要素は変更しないので、
int func(const int **a){ ... }
としました。
main 内には以下のように書きました。
ret = func(a);
すると、 a を int** から const int** に変換できませんというエラーが出てしまいます。
これはなぜでしょうか？
ありがとうございました。
ん？
レアケースを語り出すのか？
そんなにヘンテコでもないと思う
for (size_t count = 0 ; count < 10 ; count++){
for (size_t i = 0 ; i < count - 1 ; i++){
....
}
}
こんなのはありがちかと
レアケースっていうか
nが小数の場合だな
やはり条件の方に+1とか-1とか書くんじゃなくて初期値変える方が素直だろうな。
最適化の下手なコンパイラ対策も含めて。
だからそう言うのをレアケースって言ってるんだが...
よく書くと言うなら多分住む世界が違う
具体的なコードは以下です：
int func(const int **a) {
return 0;
}
int main() {
int n = 10;
int **a = new int*[n];
for (int i = 0; i < n; ++i) {
a[i] = new int[n];
}
func(a);
for (int i = 0; i < n; ++i) {
delete[] a[i];
}
delete[] a;
}
さくらの続編を放送してる今日この頃、レイアースの第三章もワンチャン有るかもな！
そんな事言ったら
countが0でループだってレアケースだぞ
const付きに変換出来るのは
ポインタの先がconstに変わる場合
int finc(int * const * a) なら大丈夫
const についてよくわからないのですが、
func の中で、
a[i][j] = 1;
みたいなことをできないようにしたいのですが、どうすればいいでしょうか？
ありがとうございます。その方法で取りあえずの目的は果たせそうなのですが、ほかの方法はないでしょうか？
というのも、他のクラスでラッピングしたりキャストしたりせずにifstreamを食わせたいのです。
たとえば、STLの各種関数はポインタでもvector等のコンテナでも大体OKですよね？
あれと同様に関数ポインタでもクラスのインスタンスへのポインタでもread()を持つものなら何でも突っ込めるようにしてforでぶん回したいのです。
標準のコンテナや自作クラス等の違いを吸収できるような構造にしたいのです。条件が後出しになってしまって申し訳ありません。
が一番コストが少ないと思う
関数の中で
delete [] a[i];
a[i] = new int[10];
は出来ても良いの？
ありがとうございます。
ちょっと回答が理解できないため、質問を代えさせてください
以下のプログラムの func はNGなのに func2 はOKなのはなぜでしょうか？
return 0;
}
int func2(const int *b) {
return 0;
}
int main() {
int n = 10;
int **a = new int*[n];
for (int i = 0; i < n; ++i) {
a[i] = new int[n];
}
func(a);
int *b = new int[n];
func2(b);
for (int i = 0; i < n; ++i) {
delete[] a[i];
}
delete[] a;
delete[] b;
}
それは c / c++ の欠点の１つで、
T * は const T * に文句も言わず変換してくれるが
T ** は const T ** に変換してくれないという問題
T は const T と定数性以外 compatible だよね、という判断を 1 段階しかしてくれない。
キャストが必要
const_cast<const int**>(a) など
皆が言っているのは質問の内容とはちょっと違うけど、
func の中で a[0] = 0; などを禁止するために内側のポインタ自体も const にして
const int * const * にした方がいいよということ
func(int * const * )にすればコンパイル通るのか…
T * const * ==> const T * const * という変換は暗黙でokなのか
自分がバカでした
欠点なの？
T ** を const T ** に勝手に変換されると困るんだが。
ちょっと興味があるので困るコードを教えて
慌ててたのかこのレス書き間違ってた
func(const int * const * )にすればコンパイル通る、
T ** ==> const T * const * という変換は暗黙でok、
と書きたかった(全然違うな)
int** ipp;
const int ci=0;
const int ** cipp;
cipp = ipp;
*cipp= &ci;
**ipp = 3;
int** ipp;
const int ci=0;
const int ** cipp;
int *ip;
ipp = &ip;
cipp = ipp;
*cipp= &ci;
**ipp = 3;
ios::out | ios::trunc
が意味がないと書いてあります。
既存のファイルを破棄してから書き込むということだとすると意味があるように思います。
ios::in | ios::out | ios::trunc とした場合のみ意味があると書いてあります。
どういう意味なのでしょうか？
これは、読み書き両用時に使える機能
ファイルを読み込んで、ファイルサイズを縮小して書き込む
ファイルの書き込みでは、使えない。
書き込みでは、ファイルサイズ0で開くから、前のファイルが消える
なるほどね。
T ** => cont T ** は許すとcont T を操作できてしまうから禁止されていて、
T * => const T *
T ** => const T * const *
...(以下略)
にはその問題が無いから許可されているわけか
は buf のサイズ分だけ読み込めということだと思います。
ファイルの最後の部分を読み込むとき、サイズが WIDTH 未満の場合にはどうなるのでしょうか？
fstream file;
file.open("hello.txt", ios::in | ios::binary);
do {
unsigned char buf[WIDTH];
file.read((char*)buf, sizeof buf);
for (int i = 0, size = file.gcount(); i < size; ++i) {
printf("%02X ", buf[i]);
}
cout << endl;
} while (!file.eof());
file.close(); 👀
Rock54: Caution(BBR-MD5:1341adc37120578f18dba9451e6c8c3b)
ttps://cpprefjp.github.io/reference/istream/basic_istream/read.html ありがとうございました。
あともう一つ質問させてください：
ロベールの本なのですが、
int n = 0x41424344;
file.write((const char*)&n, sizeof n);
というコードがあるページにあります。
その少し後ろのページには、以下のコードがあります。
char buf[BUF_SIZE];
dst.write(buf, src.gcount());
ここで、なぜ
dst.write((const char*)buf, src.gcount());
としていないのでしょうか？
ttp://rosie.5ch.net/test/read.cgi/liveplus/1525483483/l50 char *はconst char *に互換だから。constは書き換えないという意味で、constなしはconstありに対して互換性がある。
またロベールの本なんですが、以下のコードが書いてあります。
ファイルから入力中にエラーが起きたときの対処法です。
if(src.fail()) {
ではなく、
if(src.fail() && ! src.eof()) {
と書いてあります。その理由として、
「読み込みの場合はファイルの終端に到達した際も fail メンバ関数が
真となるため、 eof メンバ関数が真になる場合は除外しておきます。」
と書いてあります。
そこで質問です。
ファイルの終端の直前の部分を読み込む最後の読み込みの際に何等かのエラーが起こった場合、
src.fail() == true かつ src.eof() == true となります。
そのため、
src.fail() && ! src.eof() == false となってしまいます。
この場合、読み込みエラーが起こったにもかかわらず、その対処ができないことになりはしないでしょうか？
それともロベールさんのコードはOKなコードなんでしょうか？
…
char buf[BUF_SIZE];
src.read(buf, sizeof buf);
if(src.fail() && ! src.eof()) {
error = true;
break;
}
ありがとうございます。
つまりどちらもエラーにはならないということですね。
ですが、記述が統一していない理由というのは何か考えられるでしょうか？
int n = 0x41424344;
file.write((const char*)&n, sizeof n);
に const がついているのは、 n は int 型だから write に渡すときには絶対に
キャストしなければならない。(char *) でもいいが、どうせなら const もつけて
しまおうということですかね？
一方、
char buf[BUF_SIZE];
dst.write(buf, src.gcount());
の方は、キャストの必要がないからわざわざ (const char*) とキャストすることも
ないかなという感じですかね？
疑問を持って読んでいくと次から次へと疑問が生まれてきて読み進むのが大変です。
再読のこと
訂正。
× reinterpret_cast<const char *>(&n)
○ reinterpret_cast<char *>(&n)
そのCスタイルのキャストは
const_cast<const char *>(reinterpret_cast<char *>(&n))と同じ。
下手なキャストはバグのもと。キャストは最小限に。
ここでconstをわざわざ付けるのは、型で書き換えないことを確認するためだが、
このCスタイルのキャストは強力すぎて、行儀が悪い。reinterpret_castとconst_castに分けるべきだと考える。
そういうことするなら fstream じゃなくて basic_fstream<int> を使った方がよくなくなくない？
他人に強要しなけりゃそれ使ってもいいんじゃないの
初心者が入門書で学習している段階で、途中の過程をすっ飛ばしてこっちの方がいいからこれ使えなんて進めるのはかえって理解を妨げるんでないの？
こっちの手段もアリだよね？ っていう別の質問。
競技プログラミングが流行る前には、宿題請負スレが隆盛を誇り、私もそれに便乗していろいろやっていましたが、
競プロをやりたいとは思わないなあ…
buf という配列ですが、 for 文の中で宣言されています。
PAGE_HEIGHT 回、配列 buf が作られるのでしょうか？
何か非効率的な気がします。
for (int h = 0; h < PAGE_HEIGHT; ++h) {
unsigned char buf[PAGE_WIDTH];
m_file.read((char*)buf, sizeof buf);
for (int w = 0, size = m_file.gcount(); w < size; ++w) {
printf("%02X ", buf[w]);
}
cout << endl;
}
これによる時間はゼロと思って良い
そういうのを分かるようんなるにはどうすればいいのでしょうか？
C++の本だけ読んでいても分からないような気がします。
printfをなんとかすべき
コードを書いたときに具体的にどんな処理が行われるか
を地道に学んで行くしかない
アセンブラを見てもいいし本で学んでも良いし
時間を測っても良い
C言語の方が簡単なのでC言語にある機能から
ありがとうございました。
毎ループその buf が作られるかという質問について言えば
関数に入るときに確保された領域が毎ループ使い回されるだけ
ありがとうございます。
newした場合にはもちろん毎回別の領域が確保されるわけですよね。
文法だけからでは分からないことだと思うので、そのような部分を解説した本が
あればよいのですが。。。
基本型はループの外においやらている可能性が高い
まぁ使ってるコンパイラの最適化次第というのはある
文法/規格だけで解決しない自由な部分は
実際に使ってるコンパイラの吐き出すコードをみるなり
実測して違いが出るか確認いてみたり……
初心の「それ無駄だろうという直感」は最適化で瑣末ごとになることが多い？かな？
ありがとうございました。
C++ スタック ヒープで検索すると解説しているページは山ほどヒットするけどいい本ってあるのかな。
CPUとメモリの動作とか簡単に学んでおくといい気がする。
スタックに収まらないような大きな領域をスタックに取ってはいけないとか
実践的に必要な知識でもあるんだよね。
個人的には、はじめて読むシリーズがコンパクトで良かった。
はじめて読む8086
はじめて読むPentium
はじめて読むMASM
はじめて読む486
486は結構ボリュームがある
Mystr Mystr::operator=(Mystr &obj){
//左辺に右辺を代入
return *this
}
こうすると代入のたびに戻り値を返すためにコピーコンストラクタとデストラクタがわざわざ呼ばれてるみたいなんですが
関数の戻り値をvoidにする以外でなくす方法はありませんか？
一応コード全文
ttps://ideone.com/A1iQ3Y ＞Mystr Mystr::operator=(Mystr &obj){
一般的にはこうする
Mystr & Mystr::operator=(Mystr &obj){
戻り値にも参照が使えることを知りませんでした
おそらくわかっていると思うけど、ローカル変数や
テンポラリーオブジェクトの参照は返しちゃダメなので注意
ダメな例
T& f() { T a; .....; return a;}
string& g() { string a, b; .....; return a+b;}
はじめて読む 486 は良書だけれでも、今、これを実際のマシンで試してみることはできなくなりましたね…
機械語の並びをコンパイルして最適化された μop にするみたいなことが CPU の中で起こってて、
機械の気持ちを理解するには機械語はまだまだ外側の方って感じ。
動かすための情報を集約しようとしてはしてるよ。
ある程度は動く。
ttps://github.com/tkmc/486 これなんかも、動くかもしれません
ttp://takeda-toshiya.my.coocan.jp スタックなる仕組みでローカルな記憶域をほぼコストゼロで確保してんのかー
と言うことがわかれば十分な気がする
これの上の３冊は薄くてすぐ読めるから、もやもやとした状態でいるよりはいい気がする。
ただ、486以外は古本でしか手に入らなそうだけど。
まずは変数がどこにどのように確保されるかとか
どのように初期化されるかとか
そっちの方が先だろ
スタティック、スタック、ヒープ
をまず理解する
C++であればvirtual関数が呼ばれる仕組みとかも
知ってた方が良い
例外の仕組みは機種依存が大きいのでもうちょっと先で
つ
ttp://zob.club/zob/2018/04/16/同人誌-advanced-assembler-386-上ノ巻/ そう。
でもスタックを理解するにはメモリという概念モデルの理解が必要
だけど皆が勧めてるようなx86の解説書はやめたほうが良いと思う
セグメントレジスタとか原理を学ぶには邪魔なノイズが多過ぎる
ベースポインタというほぼ専用のレジスタが出てくるからなぁ。
そういえば昔、Cが全然分からない頃にMASMの本を読んだら、
Z80や6502のアセンブラではついぞ出てこないディレクティブが色々あって
まったく意味が分からなかったのを思い出した。
高級言語のコンパイラを作ったり、ライブラリとして呼べるマシン語の
サブルーチンを作るための機能なんだと後になって腑に落ちたけど。
「C は PDP-11 エミュレータ」なんて揶揄してるのをどこかで見たことがあるな。
仮想マシンの中間コードを触るのは疑問
8bitは8bitで面白い
理解すると言っても何を勉強して理解するのか？
という話だと思ったんだけど。
アセンブリやCPU関連の本以外で具体的に分かるものがあるというのがよく分からないな。
コールスタックって何？スタックフレームってなに？
って人は読んでおくといいと思う。
Cを学習する上で避けられない割に、C視点側からの詳しい学習書って無いよなー。
環境依存部分だから、言語学習書に適さないってのもわかるんだが…何とかできないものかと常々思ってる。
(思ってる「だけ」で実行には移さないのだけれどもw
ならないと思う。
クヌース先生の本を読む上での決まり事を、先生が定義しただけに過ぎない、と理解してる。
役に立つかもしれません
グーグルで検索するといいかも『ネットで稼ぐ方法 モニアレフヌノ』
AA6VB
たしかに、そこをつく本を書けば売れるかもしれない
そんな本に書くべきことは、他に何があるだろうか？
・qsort() の説明
・アセンブリ言語とのリンク
・PEフォーマット
…etc
江添氏が C++ の入門書で、言語以外の周辺事情もある程度カバーしたものを書こうとしてるみたいだぞ。
今は二の補数を説明すべきかどうかとか TWITTER でグダグダ言ってるから、
当たり前みたいで、しかし説明を省略されがちなことも含まれると思う。
ソースファイルからオブジェクトファイルに変換したときに
どんな情報が残ってどんな情報が消えるか。
オブジェクトファイル群をリンクした段階でまだ確定せずに
実行時のロードで配置されるアドレスのこと、あたり。
二の補数はあたりまえに書いてもいいとおもうけれども、二の補数以外のものがあることを陽に記述する必要はないんじゃないかな…
Mac はお高いからな…
17"でお手頃価格なWindowsなNoteが他に無くてね
HPとかDELLだと2.5kgとか
ありがとうございます。
使い勝手がいいとかそういうことはないですか？
MSのセミナーとかもmac+windows多かったよ
ヘッダーファイル内で、 ostream というのを使っているのですが、
#include <iostream>をヘッダーファイル内に記述していません。
エラーが出るだろうと思いつつ、ビルドしてみたらエラーが出ませんでした。
これはどういうからくりでしょうか？
他のヘッダファイルで include してて間接的に読み込んでいることになってるってのが、一番ありそうかなぁ。
ありがとうございました。
↓のファイルをビルドするとエラーが出るのですが、何が原因かよく分かりません。
フレンド関数関連だと思います。フレンド関数については全く知らないので、真似して
作っただけです。
Vec.h
ttp://codepad.org/3ROYH1yq Vec.cpp
ttp://codepad.org/f3eSheBS ありがとうございました。
もしかしてヘッダーファイルのみをビルドしてもオブジェクトファイルはできないんですか？
ある本に書いてあるコードでは、 Vec.h と Vec.cpp のようには分かれていないため、
自分で分けたのですが、エラーになってしまいました。
Vec.h
ttp://codepad.org/3ROYH1yq 上のVec.hの最初の方の
#include <iostream>
#include <cassert>
削除してもビルドエラーが出ません。
プロジェクトにはVec.hしかない状態でビルドしました。
テンプレートのエラーはテンプレートが実体化するときに出ると思うよ。
だから、テンプレートを使ってないなら、エラーがあってもコンパイル自体は出来たりする。
ありがとうございました。
あともう一つ質問なのですが、ロベールの本に、
「関数を実体化するには呼び出したところからその実装が見える必要があります。」
「つまり、関数テンプレートは宣言と実装をヘッダファイルとソースファイルに分離して
書くことはできず、すべてヘッダファイルで実装する必要があるのです。」
と書いてあります。
クラステンプレートについては同様の記述がないのですが、
クラステンプレートについても宣言と実装をヘッダファイルとソースファイルに分離して
書くことはできず、すべてヘッダファイルで実装する必要がありますか？
このへんの問題かな?
ttps://ja.wikibooks.org/wiki/More_C%2B%2B_Idioms/friend_%E9%96%A2%E6%95%B0%E3%81%AE%E7%94%9F%E6%88%90(Making_New_Friends) Yes。 テンプレートはヘッダファイルに書く必要がある。
同じ実体 (テンプレート引数も同じなテンプレート) はリンク時に統合されるので、
最終的な実行ファイルに複数の実体があったりはしない。
ありがとうございました。
ちょっと理解できないと思うので、あきらめて
ttp://codepad.org/ABfo8I3a としたところビルドできました。
ありがとうございました。
ありがとうございました。
assert() が使いたいため、「List2.h」内に、以下のように書いたとします。
#pragma once
#include "List.h"
#include <cassert>
実は、「List.h」内にも#include <cassert>が書いてあります。
ヘッダファイルにはすべて#pragma onceを書いているので多重インクルードについて
問題はないと思います。
そこで質問なのですが、「List2.h」内で assert() を使っているため、自分としては、
必要ありませんが、「List2.h」内にも#include <cassert>を書いた方が分かりやす
いのではないかと思いました。
既にインクルードされていてもあえて、#include <> を書くという人はいるのでしょうか？
それとも、既にインクルードされていることに気付いている場合には、できるだけ
#include <> は書かないほうがいいのでしょうか？
すでにインクルードされているかどうかは書いているときにはわからない、から書いとく
ただヘッダは分割コンパイルにおいて共用するデータだけを書いておくものだから
ヘッダ List.h に #include <cassert> が含まれているのは、一見、疑問だと思った
しかしテンプレート関数に assert() が入る場合があるのだから、こういったこともあり得るのかもしれないが、まだ私は体験していない…
ありがとうございます。
＞ただヘッダは分割コンパイルにおいて共用するデータだけを書いておくものだから
＞ヘッダ List.h に #include <cassert> が含まれているのは、一見、疑問だと思った
ここのところがよく理解できないのですが、
List.h にテンプレートクラス List<T> が書いてあって、
List2.h には List<T> を継承したクラス List2<T> が書いてあります。
そして、List.h, List2.h の両方で assert() を使っています。
うんうん、なるほど
テンプレートに assert() が含まれているのならば、ヘッダに #include <cassert> が入るのも止むを得ないです
ありがとうございました。
また質問で申し訳ないのですが、今度は、全く違う質問になります。
一方向リスト用のセルである Cell<T> というクラスを作りました。
Cell<T> のメンバ変数は、
T data
Cell<T> *next
です。
List<T> には、一方向リストの先頭のセルを指すメンバ変数 Cell<T> *head およびリストに挿入したり、
リストから削除したり、リストのサイズを返したりする様々なメンバ関数があります。
List<T> は一方向リストでしたが、List2<T> は双方向リストにしたいとします。
オブジェクト指向プログラミングでは再利用が重要ということなので、
新たに、双方向リスト用のセルを作るのではなく、 Cell<T> を継承して Cell2<T> というクラスを作ることにします。
Cell2<T> には新たにメンバ変数 Cell<T> *prev を追加します。
List2<T> のほうも List<T> と共通で使えるメンバ関数があるため、再利用したいとします。その場合、気持ちとしては、
List<T> のメンバ変数 Cell<T> *head は無効にして、新たに、 Cell2<T> *head と Cell2<T> *tail をメンバ変数に
したいです。
そして、Cell2<T> に対しても使えるメンバ関数はそのまま使い、双方向リストにしたことにより、より効率的に実装できる
メンバ関数については、オーバーライドしたいです。
上記のようなことをどうやって実現したらよいのか分からないのですが、可能でしょうか？
可能だとして、こういうやり方は非推奨でしょうか？
繰り返しを表す、C++ iterator みたいな、
抽象クラス・インターフェースでも使っているのだろう
一から好きなように双方向リストを作れ
>オブジェクト指向プログラミングでは再利用が重要
は幻想
この場合で言ったらまったく逆で
もともと何か双方向リストがあって、継承して機能制限をして一方向リストに仕立て上げるなら分かるが
一方向リストを継承して双方向リストにするなどイカれてる
一方向リストと双方向リストでどれ程共通的な処理があるのか知らんけどCellBase<T>に共通的な処理を定義してそれからCell<T>とCell2<T>を継承させるのが普通じゃね？
総合的な判断が必要という前提はあるけども、
継承が妥当なときの基準のひとつに「is a 関係であるか？」ってのがあるよね。
XはYの一種であると言えるときはXはYを継承していい。
双方向リストは一方向リストの一種であるかというと、まあ Yes って呼んでいいんじゃないの。
ただ、それで楽に使いまわしが出来るかというとそうでもないこともあるので、楽なように作ればいいよ。
練習でやるのなら、使いまわしは置いてそれぞれを作ってみた上で、
共通な部分を探してデザインしなおしてみるというのもいいんじゃないかな。
クラス定義自体は継承関係を持たずにトレイトの方で性質を定義したりとかいったことも今どきはよくやるし、
将来的にコンセプトが入ったらそっちが主流になるかもしれん。
もともと何か一方向リストがあって、継承して機能追加をして双方向リストに仕立て上げる
これはダメなん？継承は機能追加ダメなん？
ありがとうございました。
本を見ると再利用が重要と強調されているので、拘ってしまいました。
ありがとうございました。
ありがとうございました。
ありがとうございました。
はだいぶイカれてるから触らないで
単方向リストから双方向リストを派生させると、内部構造が違うから相違を埋めるのに面倒臭い事になる
派生した双方向リストから単方向リスト内部のノード列にアクセスできたとしても
単方向リストの状態は単方向でノードが繋がっているのだから双方向リストからどうこうはできない
結局の所、双方向用のノードを単方向用ノードにアップキャストしないと格納できないし、取り出すにはダウンキャストしないといけない
もし何とかして単方向リストに双方向用のノードを双方向に数珠繋ぎ出来たら、そのリストはもう双方向リストだよ
あと、insert()の問題もある、std::forward_listの持つinsert_after()が何故そうなのかは構造的に一目瞭然でしょ
厳密に言えば、std::forward_listはコンテナ要件を満たしていないしな
単方向も双方向もLinked Listとして構造的に似ているが効率的に見ても構造的に見ても別のデータ構造だよ
is-aの関係ですら無いし、再利用ってのはhas-aの関係を考えるべきで、継承は再利用するためのものではないよ
例えば、皆、std::stringをhas-aで利用するよね、std::stackはstd::vectorやstd::listなどのアダプタだよね
「やっぱ普通に作った方が簡単にできたな」って経験をするのもいいと思う
よく「オブジェクト指向はこうだから」って言葉にこだわって面倒くさいことしてる人いるけど
プログラムの基本としては「わかりやすさ」「シンプルさ」こそこだわった方がいいと思うから
将来拡張予定がないプログラムなんかだと無駄な継承しない方がいい
構成の仕方の流行はだいぶん変わってて、
コンセプトが入ったら一気に再編されるかもしれない。
クラスの継承ってそんなに万能じゃないよ。
単方向リストを継承して双方向リストにするのは悪手
やってみるまでもなくわかるだろJK
結局ほぼすべてのメソッドを上書きしないといけないから意味ない
しかも一から双方向リストを書いた方が分かりやすいし速い
大は小を兼ねるの考えで、双方向リストのみを作って
単方向リストを使う場面でも双方向リストを使えばよい
それがベストだろうというアンサーがちらついてるからこそ、余計に
単方向リストを継承して双方向リストってのが悪手に見えるんよなぁ
余談だけどC++には std::list っていう双方向リストがあるけど単方向リストは提供されてないし
単方向リストなどその程度の扱い、必要ない
>余談だけどC++には std::list っていう双方向リストがあるけど単方向リストは提供されてないし
std::forward_list など無かった
いやあ、単方向リストはそれはそれで使い道はあると思うよ
大体、キャッシュに載り易くメモリ効率も良いstd::vectorで十分だけど
挿入操作を多用するならstd::listやstd::forward_listの方が良いよね
std::forward_listは、std::listよりも要素N個 x ポインタサイズ分のメモリ消費量を抑えられるし
イテレータを使ってO(1)で連続してpush_back()みたいなことも出来る、pop_back()みたいなことはO(1)で出来ないけどね
必要性を問うよりも、その特徴を理解して適切に効率的に使うことが大事なんじゃないかな
まあ、std::mapやstd::setは使うのを躊躇するけどな
O(log n)で値を取り出せて、イテレータでソートされた要素に順次アクセス可能を売りとするけど、メモリ効率が悪すぎる
他の言語のそれらが大体ハッシュテーブルで実装されているのを見るに連想コンテナはunordered系で十分な気もする
俺もリンクリストを使うことは有るけど、大概切迫していてカリカリカスタマイズしたいときに使うものだから
汎用のテンプレートのリンクリストを使ったためしがない
一方向リストなら、なおのこと使わない
ゼロコストの原則の視点に立つと、単方向リストを実装に流用して、双方向リストを作成するのもあり。
O(1)で10個挿入したら、O(1)*10なんだから、結局O(N)じゃないの？
std::forward_listとそのイテレータだけでFIFOのQueueを実装できたりするよ
イテレータを介したinsert_after()になるから要素を入れるコストはイテレータのコピー分、std::queueよりも高くなると思うけど
std::queueはstd::dequeかstd::listを利用するから、std::forward_listで実装した方がメモリ使用量は少ない
単方向リストを使用して独自実装した方が低コストに抑えられると思うけどね
まあ、再利用も良し悪しって事だね
ごめん書き方が悪かった、1つの要素の挿入にO(1)って意味ね
Linked Listは、挿入場所への移動にO(n)かかり、挿入にO(1)かかるから
最後の要素を指し示すイテレータを保持してたらpush_back()みたいなことも出来るよって話ね
arrayは通常 array<int, 固定値>のように宣言してから使うと思うのですが、
empty()メソッドの戻り値は <int, 0> 以外は全てfalseでした。
つまり通常<int,(0より大きい整数)>で宣言して使う場合empty()はfalseしか返ってこない
気がするのですが、このメソッドは意味があるのでしょうか？
テンプレートを使って異なる種類のコンテナに共通に使える処理を書くときに、他のコンテナ達と共通の関数を備えていると都合がいいからかなと思う。
そのメンバの存在意味の有無に関わらず、コンテナ要件の1つだからね
他のオブジェクト指向言語でのインターフェイスや抽象クラスを用意していないだけで
コンテナとして共通の要件（インターフェイス）が設けられている
例えば、size()、empty()、begin()、end()など
本来、動的なポリモーフィズムをするためにインターフェイスや抽象クラスを設けるけど
vtableは高コストだから、ゼロオーバーヘッドの原則に則り使用していないのよ
まあ、コンテナ自体STLの1つだからオブジェクト指向的な機能は意識していなかったと思うけどね
余談だが、聞いた所によるとテンプレートって最初マクロで実現しようとしてたらしいね
ttp://ja.cppreference.com/w/cpp/concept/Container クラスに求める要求を表現するための機能「コンセプト」は C++ の悲願としてずっと前から温められているのだけれど、
なかなか仕様に入らずに先送りされてるという状況。
それがJPEGファイルなのか、PNGファイルなのか、などを判定したいのですが、
どの程度の判定をすればよいものなのでしょうか。
例えばJPEGファイルなら、先頭3バイトを{0xFF, 0xD8, 0xFF}とmemcmp()で十分なのでしょうか。
処理スピードを優先するなら、memcmpで十分。
他の形式の正常なファイルも拾ってしまわないかということです。
JPEGの場合、先頭の3バイトを判定すれば、他の正常なファイルが引っかかることはないのでしょうか。
ファイルを最後までパースして、JPEGデータとして読み込めるかどうかチェックするのが確実だが
POSIX には file コマンドがあってファイルの種類を判定できるけど、その実装はヒューリスティックだよ。
参考になるとは思うから読んでみるのもいいんじゃない？
ライセンス的に OK ならそのまま流用してもいいかも。
どの程度の精度で判定すべきかは状況によるので総合的に考えてとしか言えない。
例えば、 jpg ではないファイルが多数ある中から jpg を探すというような状況だったら、
先頭をちょっとだけ読んで jpg っぽかったら全部を読んで詳細に判定するというのでもいい。
ほとんどが jpg なのだったら、いちいち詳細に判定するのは速度的に遅くなるけど、それが許容できるのか、
許容できないのであればどの程度まで緩い判定にしていいのか、バランスの問題。
速度とかとのバランスだって書いてあるつもりだけど、わかり難かった？
ヘッダですぐにわかるので
jpgではあるんだけど
非対応フォーマットとか一部化けてて表示出来ないとか
そういう判断が難しい
えっ？ だからまずは先頭をちょっとだけ読んでみる (この判定だと false positive はあっても false negative はない) という話なんだけど。
言いようがないんじゃないか?
極端な話、行儀の良いファイルだけなら拡張子で判定しても大丈夫。
(拡張子が間違ってるけど)一般的なファイルばかりなら先頭の何バイトかで判定。
悪意を持って偽装ヘッダや追加情報エリアまで利用してる可能性を気にすれば
JPEGの規格に準拠してるファイルでさえ危険、というレベルまであるかも。
実運用上はJFIFとEXIF以外は対象外でも良いのかも
Yes
それが仮想関数であろうとも、
オブジェクトへのアクセスがポインタ経由でないならば
どの関数を呼び出すのかコンパイル時に確定可能なので、
仮想関数テーブルにアクセスする必要はない。
(はずだと思うが言語仕様での保証はないだろうし、
実態がどうなってるか確かめたことはないんで、
誰かやってみてくれんかな。)
ファイル判別の一般論じゃなくてjpgの判別ですよ
jpgの判別方法を語ればいいんです
文字コードと違ってあやしいとかはなくて
APPnの中数バイト見れば簡単にわかるんですよ
文字でJFIFとかExifとか書いてあるわけなんで
偽装が無いならこれで十分
あとは
対応フォーマットであるのか
正しいフォーマットであるのか
実際にデコード出来るのかどうか
などを判別する必要があるかどうかでその先が決まる
baka?
ありがとうございます
何言ってんの？
その偽装があるかもしれん (ということも想定に入れるかどうは場合による) という話なんだけど。
日本語が読めないの？
なるほど、偽装に騙されるのは脆弱性の内 (で、それはないという前提が提示された) という解釈？
判定を誤りうる (データを作れる) のとセキュリティ的な欠陥をなんとなく区別してたけど、
質問者の感じからすると、確かに偽装で騙されるのは脆弱性の内かな。
JPEGの規格書を読んだ事が無いだろう
JPEG以外で先頭3byteが {0xFF, 0xD8, 0xFF} のファイル形式が存在するか、
普通に出回ってるか? という問題じゃないのかな。
ロベールの本ですが、
「
Hoge Two() {
Hoge n(2);
return n;
}
int main() {
Hoge hoge(1);
hoge = Two();
とした場合、基本的には n のコピーがいったん作られて、それが hoge に
代入される形になります。このコピーこそが、テンポラリオブジェクトになる
わけです。
」
と書かれていますが、なぜわざわざ n のコピーを作るのでしょうか？
n は Two() 関数を抜けたら消えてしまいますが、これを消さずに、
返した方が効率的な気がします。
・代入により、 hoge に テンポラリオブジェクトがコピーされる。
これはなんか非常に無駄なことをやっているように思ってしまいます。
hoge に 捨てずにとっておいた n を参照させれば十分のように思います。
話が難しい方向に進んでしまってすいません。
勉強させていただきます。
元々の疑問はの言われるとおりで、
他の形式の画像をJPEGだと誤判定してしまわないか、
さらに言うと、先頭が{0xFF, 0xD8, 0xFF}以外のJPEGファイルも存在していて、
JPEGファイルを見逃してしまうことがあるのか、ということでした。
そういう時こそ右辺値参照ですよ
hoge = std::move(Two());
でもこんな事をしなくても大抵戻り値最適化(RVOやNRVO)でコピーコンストラクタは呼び出されない
明示的にムーブコンストラクタを無効にするとコンパイルエラーが発生するはず
Hoge(Hoge&&) = delete;
Hoge& operator=(const Hoge& hoge) {
std::cout << "assign operator called." << std::endl;
return *this;
}
Two()内の変数nは自動変数だからスタックに作られる
とっとけないじゃん
それヤバくね？関数を抜けた途端消える存在を参照するとか
昔ながらの方法
SqlConnectionやDataSetのDispose()がインテリセンスでは候補に上がるのに、コンパイルで「メンバーではありません」とエラーになります。
スコープを抜けると破棄されるので何もしなくてよいという認識でよいのでしょうか？
また、この理屈で、c#の勝手に破棄してくれるusing相当の機能はない、と言うか、必要ないのでしょうか？
IDisposable使ってる？
スコープ抜けてもGCによって回収されるタイミングは保証できない
どうしてもすぐにGCしたいなら
GC.Collect();
をする。
多分ジェネレーション0だろうから
GC.Collect(0);
でいいのでは
レスをござます。
作ってるクラスがIDisposableを継承しないとダメってことですか？
作ってるのはインスタンス作らなくてもいいstaticクラスなんですけど。
GCは効果の程を確認できないですが、やってみます。
レスありがとうございます。です。
ttps://qiita.com/haniwo820/items/ba0ab725c25673c20338 こんなのとか
staticクラスだとファイナライザーを書けないから内部で他のクラスをnewした場合が問題
それとメンバ変数もstaticでなければならない
となると普通はアプリケーションが破棄されるまで残る
IDisposableをstaticクラスが継承するとエラーになる
というかstaticクラスはインターフェイスを継承できない
むしろusingを使えない理由が分からない
ttp://ufcpp.net/study/csharp/oo_dispose.html こういうのだとstaticクラス風にファイナライザーを走らせられる
それかStreamみたいのでClose()したいのならClose()メソッドを書けばいい
SqlConnectionやDataSetはいちいちClose()する必要があるのかな？
ここの記述を信じるなら、全部Yesってことになるのかな。
ttp://mag.autumn.org/Content.modf?id=20050506023118 VS2013 c++のCLRコンソールアプリを新規作成したやつです。
include "stdafx.h"
using namespace System;
using namespace System::Data;
using namespace System::Data::SqlClient;
int main(array<System::String ^> ^args)
{
Console::WriteLine(L"Hello World");
String ^constr = "xxxxx";
SqlConnection ^connection = gcnew SqlConnection(constr);
connection->Open();
connection->Close();
connection->Dispose();
return 0;
}
この Disposeでエラーになります。
ここには書いてませんがDataSetも
Disposeでエラーになります。
上記コードの場合 Dispose抜きで問題ないのでしょうか？
まさにこれを読みました。c#のusingがc++にはない認識です。
この理由がこの通りならDisposeなしで心配ないのですが。
ttps://seleck.cc/685 ttps://trello.com/ ボードのメニュー → Power-Upsから拡張可能 Slack DropBoxなど
Trello Chrome拡張機能 elegant
ttp://www.kikakulabo.com/service-eft/ trelloのオープンソースあり
共同ツール 2
ttps://www.google.com/intl/ja_jp/sheets/about/ 共同ツール 3
ttps://slack.com/intl/ja-jp ttps://www.dropbox.com/ja/ ttps://bitbucket.org/ ttps://ja.atlassian.com/software/sourcetree ttps://www.sketchapp.com/ ttp://photoshopvip.net/103903 ttps://goodpatch.com/blog/sketch-plugins/ Trello Chrome拡張機能プラグイン集
ttps://chrome.google.com/webstore/search/trello?_category=extensions Slackプラグイン集
ttps://slack.com/apps Sketchプラグイン集
ttps://sketchapp.com/extensions/plugins/ ttps://supernova.studio/ と書いてあるように見える。(手元に環境がないので未確認)
SqlConnection connection(constr);
connection.Open();
connection.Close();
そのコードでconnection->Dispose();を消すだけだとDisposeは呼ばれない。
C++/CLIでDisposeを呼びたい場合「delete connection;」と書く。
C#のusing相当のことをしたい場合は
詳細は↓を参照。
ttps://loafer.jp/mixi/diary/class.xsp?2007-09-07-23-55 自作のIDisposableを継承したクラスを作って確認したところ delete で Disposeが通る事を確認できました。
不慣れで詰まらない質問してしまってすみませんでした。
参考にさせていただきます。
ところで、
Cとアセンブリ言語で学ぶ計算機プログラミングの基礎概念 - プログラムはプロセッサ上でどのように実行されるのか
角川 裕次
ttps://www.amazon.co.jp/dp/4627848315/ この本を読んだ人はいますか？
かなり自分にとって理想的な本のようですので、買ってみようと思います。
こういう本を読めば、少しは言語の設計者の気持ちが分かるようになるのではないかと期待します。
つまりこれはC++を頑張って覚えればその分見返りも大きいということではなかろうか。なにしろ人の嫌がること高いスキルが必要なことはそれだけ報酬も高いはずで
さらに輪をかけてゲロゲロになっていて、どうしようもないゴミが
簡単に生産されるようになってる。正直いって、C を選ぶ理由が C++ プログラマーを
追っぱらうため *だけ* だったとしても、それ自体、C を使う強力な理由になりうる。
C++ はトンでもなく悪い設計の元になりうる。どうせこの言語ではいつも STL やら
Boost やら、その他ゲロゲロベロベロの「素敵な」ライブラリの機能を使って、
それがあんたのプログラムに「役立つ」んだろうが、以下のことが起きる:
- うまく動かないときにもたらされる際限のない苦痛 (あと STL とか、特に Boost が
安定してるとか移植性があるとかいう奴は、どいつもこいつも大ウソつきで、
もはや笑えるレベルを超えている)
- 非効率な抽象プログラミングモデルで、2年たった後にこれらが実はそんなに
効率的じゃなかったことに気づくケース。でもそのときにはすでに全部の
コードがその素晴らしいオブジェクトモデルに依存していて、直すためには
アプリ全体を書き直さなきゃなんない。
言いかえれば、唯一まともで、効率がよくて、システムレベルで使えて、移植性がある
C++ ってのは、基本的に C で使える機能だけに限ったときなんだ。そして C だけに
限定するってことは、他の人がそれをめちゃくちゃにしないってことで、
ついでに沢山のプログラマが実際に低水準の問題を理解することができて、アホらしい
「オブジェクト・モデル」のたわごとを持ちこまないってことだ。
linus は昔から C++ を批判していたが、git 開発に関する 2009 年のこれが、最も効果的な批判になっていますね
これを読むと C++er は一瞬自分がわからなくなりゲシュタルト崩壊に陥りますね、もう c++11 over を追いかける気力も失せてしまいました…
もSTLやboostの使い方が理解できない、良い抽象モデルが作れない人が愚痴ってるだけにしか読めんが
パフォーマンスとか使用リソースとか工数を軽視する人が実務経験の浅い人に多い
ってのが問題であって
言語自体には罪はない
＞良い抽象モデル
が役に立つとは限らないのでは？
抽象化を目的とするあまりに YAGNI を忘れてしまうのでは、これは重大な思考的欠陥なのでは？
あれほどもてはやされていた GoF は、すくなくとも C++界では、もうみるかげもなく凋落の一途をたどっているのは、どうみるのでしょうか？
だとすると、なぜ、デザインパターンは流行り、そして廃れたのでしょうか？
一度は流行ったということは確かに役に立つものだったのではないでしょうか？
一度は役に立つと認められたものがなぜ、否定されたのでしょうか？
デザインパターンってのは典型的なパターン (に名前を付けたもの) ってだけだよ。
基礎として押さえておくと便利だし、価値が失われたわけではないけど、
何もかもが既存のパターンに当てはまるわけではないという当たり前の話。
抽象化とYAGNIは関係ありません
こういう意見が出てくるあたりが良いモデリングを理解してない証拠ですね
別に廃れたわけではなく、使われるものは当たり前に使われてて取り立てて言われなくなっただけ。
たとえば、iostream をどう思う？これは良い抽象化の例ですか？
ツールバーを作ると、ボタンを押すとペコってへこんで、また押すとまた戻りますが、見づらいので
押したときと戻ったときとで色を付けたいのですが、どこかにサンプルはないでしょうか
また、私は未だに6.0でやっていてこれで十分にプログラムできるので特にこれで不満はないのですが
もしバージョンを上げれば出来るのであればバージョンアップも考えたいと思っています
最新のバージョンで出来るのなら、そのサンプルも教えて頂けるとありがたいです
OwnerDraw
CToolbarには、DrawItemがないようなのですが
ステータスバーにはあります
最新のバージョンのVC+でも出来ないのかな。結構そういう要望はあると思うけど
ノードは以下のクラスです：
template <typename T> class BinNode {
private:
T data;
BinNode<T> *left, *right;
BinNode(T d, BinNode<T> *l = NULL, BinNode<T> *r = NULL);
friend class BinarySearchTree;
};
2分探索木のクラス BinarySearchTree 内のメンバ関数 insert の引数としてノードを渡すのですが、
なぜ、
BinNode<int>* tree
ではなく
BinNode<int>*& tree
となっているのかが分かりません。本の説明によると、木構造の変形を可能にするためにそうしているとのことです。
bool BinarySearchTree::insert(int data, BinNode<int>*& tree) {
…
}
ありがとうございました。
一時は、もてはやされすぎたということですね。
if (tree == NULL) {
if (tree == NULL) {
tree = new BinNode<int>(data);
…
}
というコードがありましたが、これのことでしょうか？
あ、そのようですね。
void f(int *a) {
static int s_i = 0;
a = &s_i;
}
int main(void) {
int i = 3;
int *p = &i;
f(p);
printf("%d\n", *p);
return 0;
}
ありがとうございました。
3のままですね。
これは C の課題ですね。
適当な二分木ないし二分探索木に対して、ノード（節）を追加したり削除したりする関数を書く場合、
C ならば add_node(node **root, ...) と書きます。①
これを C++ ならば add_node(node *&root, ...) と書くこともあります。node *&root は「ポインタ変数の参照」です。②
①と②とではプログラムの表現もかわります。
これは一度、白紙の状態から自分の手で書くのが、理解するのに一番です。お試しあれ。
1,38400
2,19200
3,9600
こういう関係がある時に配列を作れば１から38400はダイレクトに求められるが
検索を使わずに38400からダイレクトに１を求める方法はないだろうか？
でも4個なら素直に検索した方が速い
元質問は検索使うなって条件なので、まぁ
数値からRS232Cのボーレート設定を想定しちゃうけど、
それなら検索を嫌うようなもんでもないし… な…
a2 : b2
a から、b への辞書と、
b から、a への辞書の、両方を作る
たまたま同じ発想になっただけ
浮動小数数に直すってのもある
LSB側から数えて1になるビット位置を返す命令があるのでそれとシフトを使う
115200は(900, 7)
38400は(300, 7)
19200は(300, 6)
9600は(300, 5)
RS-232Cだと300x2^nと900x2^nしか普通は使わないから
オーディオのサンプリング周波数にも同じような方法が使える
入力を検証する手間を考えたらテーブル逆引きと大差ないけど
メモリアクセス速度を考えてもの方が速くて簡単
なんかおかしかった
115200は(225, 9)
38400は(75, 9)
19200は(75, 8)
9600は(75, 7)
ビットスキャン命令とシフトとテーブル
変換しなきゃならないデータが多量にあって
パフォーマンスが非常に重要ならこれを使うかな
それ以上で、ジャンプテーブル・switch-case
ただのテーブル逆変換だぞ
なんでジャンプテーブル？
なんでswitch case？
リニア検索で問題なら2分検索
それでも遅ければハッシュその他のテーブル
簡単な演算を併用出来るものはする
じゃないか普通
if 文を8個以上書くと、ジャンプテーブルに変換されるってこと
ありがとうございました。
クラスコンストラクタでconst char *mes[] を｛"abc","def"}のように
初期化するにはどうやるの？
constexpr auto str1 = {"abc", "def"};
これがエラーするんだがなんでなの？
constexpr string str1[] = {"abc", "def"}; コンパイルエラー
クッ、、、どうしてもうごかない。
vector<int> dat(100,3); //ok
vector<string> str2("aaa",4); //error
こういうのもうごかない。
検索をしても例がなかなか出てこないので、Effectiv Modern C++という本
をamazonで買ってみたんだが、届いたので今見ているところだが、ここでも
string配列の記述を巧みに避けている。皆目出てこない。
string配列の扱い方ってどうやるの？
{"a","b","c","d","e","f","g"}みたいな？
定数式じゃないから。
string は constexpr に非対応のはず。 現時点では。
new が constexpr 的に扱いが難しいので、
内部的にヒープを使うようなクラスはほとんど constexpr 非対応だと思う。
ただ、制限を緩和する提案は出ているので将来的にはなんとかなるかもしれない。
string に一文字づつ入れたいってこと？
std::vector<std::string> str2 = {"a", "a", "a"};
でいけるよ。
>vector<string> str2("aaa",4); //error
「vector<string> str2(4,"aaa");」の誤りじゃね?
vector<int> dat(100,3); //ok
//vector<string> str2("aaa",4); //error
// string str1[] = {"abc", "def"}; //error
// const std::vector<std::string> str3 = {"abc", "def"}; //error
// constexpr char *mes1 = "abc"; //error
const char *mes1 = "abc"; //ok
// vector<char *> ch(10,mes1);//error
vector<string> ch(10,str1);//ok
ここまで確認できた。ただしコンパイルが通っただけだから、動くかどうかは不明。
class clsA
{
private:
const char *m_name[];
}
//clsA::clsA(char *name[]) : m_name(["mike","tetu"]){};//だめ
//clsA::clsA(char *name[]) : m_name("mike","tetu"){};//これもだめ
//clsA::clsA(char *name[]) : m_name({"mike","tetu"}){};//これもだめ
constexpr char *mes1 = "abc"; //error
これもだめですね。ヒープは必要ないとおもいますが、、、
コンストラクトする時点でサイズは確定していますが、、、
class clsA
{
private:
const char *m_name[];
clsA(char *name[]);
};
//clsA::clsA(char *name[]) : m_name(["Bike","tetu"]){};
/*だめだが可能性がありそう。 Invalidはでていない。
--error message--
#29 expected an expression
*/
//clsA::clsA(char *name[]) : m_name("mike","tetu"){};//これもだめ invalid
/*
Multiple markers at this line
- #2125 invalid initializer for array member
"clsA::m_name"
- #18 expected a ")"
*/
//clsA::clsA(char *name[]) : m_name({"mike","tetu"}){};//これもだめ
/*
* Multiple markers at this line
以下省略
*/
string str1[] = {"abc", "def"}; //error
とか
constexpr char *mes1 = "abc"; //error
とかの話。
試しに文字列を２つ引数に入れても、第一引数しか出力しないみたいですが
↓です
string readFile(const char *filename)
{
ifstream ifs(filename);
return string(istreambuf_iterator<char>(ifs),
istreambuf_iterator<char>());
}
ttps://www.miraclelinux.com/tech-blog/1n4hgx string str2[] = {"abc", "def"}; //okでした。
constexpr 文字列は諦めました。多分相当難しい。
でおもうのだが、結局は普通の人は誰もconst char *配列の初期化について解らない。
というか、ファーム開発にC++を使う場合には文字列の配列はかなり重要でしかも
Ramが少ないのでこれをRom配置できないと致命的だ。ということでファーム開発
ではconst char *mes[] = {"zzz","aaa"}; こういう処理が必要になる。
しかしファーム開発をやらない人にとってはconstである理由はないので、この重要さ
には無関心なのだろう。
もちろん分かる人もいるが教えるのは恐ろしくめんどくさいか、非常に苦労して
マスターしたので簡単には教えたくない。
それほどC++において const char *配列 のクラスでの初期化は難しいのだろうと思う。
いやそもそもできないのかもしれないが、、、（そんなはずはないだろう）。しかし
できないとすると、クラス内で初期化するのは諦めてCで初期化してるのだろうか？
多くのファーム開発者は諦めてCで初期化してるのだろうな。
の最後の行の()はずせば通るけどたぶん環境依存じゃないかな
意図してる動作がname使ってm_nameの初期化ならめんどくさそう
{
private:
const char *m_name;
clsA();
};
clsA::clsA() : m_name("Bike"){};
これはOK、しかし配列はできない。
{
public:
const char* name[]; ここで非標準だなんだの警告でる
a():name{ "aaa","bbb" }
{
}
};
vsだとこれでコンパイルは通るしぱっと見正常だけどそのまま使うとたぶんどっかでメモリ壊すんじゃないかな
配列の数指定しといたほうが無難な気がするけど
コンストラクト時にわかってるじゃないか、って話もあったけど
中身の配列数が変わったらそれは違う型になる
つまりテンプレートが必要になる
配列の要素数を推定させるのは、C++17で入ったクラステンプレートの引数推定を使えば一応出来るけど
class clsA
{
private:
const char *m_name[2];
clsA():m_name{"aaa","bbbb"}{}
};
これでもエラーします。
class clsA
{
private:
char *m_name[10];
clsA();
void init();
};
clsA::clsA() : m_name{"Bike","bbb"}{}; //エラーする。
/*
Multiple markers at this line
- #66 expected a ";"
- #171 expected a
declaration
- #126 expected a "("
- #176-D expression has
no effect
*/
constexprはC++11の機能なので、そのコンバイラでは使えないか、
使えたとしても標準とは異なる動作をする可能性があります。
あっ、そうなの？ ごめん、それはうっかりしていた。今年の2月にインストール
した最近のコンパイラなので当然C＋＋１１以上だとおもっていた。
一寸調べてみる。
対応していてもデフォルトでは C++11 の挙動にならない (オプション指定すると対応する) ようなものも有りうる。
おお、ありがとう。全然気が付かなかった。これは一つ前のバージョンでプロパティを
みてもC11＋＋がない。
最新のバージョンはC++14をサポートしてるみたいなのでUPDATEしてみる。
ttps://ideone.com/Zm8LO5 凄い！！。まさにそれです。こちらでもコンパイル通りました。
難しいなー。
もうコンストラクタでの初期化はすっかり諦めて代替案を作っていたところだけ
ど、それを丁重に拝借いたします。ありがとう。
もらい受けたいところだけども、意味が理解できるかどうか？ あなたは意味が
わかりますか？
clsA() : clsA((const char* const []){"mike","tetu",nullptr}) {};
(const char* const []){"mike","tetu",nullptr}
これは何を意味してるの？
void func2(int a, int b) { printf("%d,%d\n", a, b);}
template<?????>
class Test
{
public:
void method(void) { (templateの引数で func1(int a) か func2(int a, in b)を呼ぶ) }
private:
int a;
in b;
};
のような事をしたいのですが、引数が1つか2つの関数をそれぞれ名前でtemplate引数にして
記述したいのですが、うまくいきません。どうすれば良いでしょうか？
例えば template < void F(int)> とすると Test<func1>() でいけるのですが、func2の場合が
表現出来ません。
private: int m_a;
public:
class1(int a) : m_a(a) {}
class1(class1 const& rhs) { m_a = rhs.m_a; }
void method(void) { printf("%d\n", m_a); }
};
class class2 {
private: int m_a;
int m_b;
public:
class2(int a, int b) : m_a(a), m_b(b) {}
class2(class2 const& rhs) { m_a = rhs.m_a; m_b = rhs.m_b; }
void method(void) { printf("%d,%d\n", m_a, m_b); }
};
template<class _Myclass> class Test {
private: _Myclass m_myClass;
public:
Test(_Myclass myClass) : m_myClass(myClass) {}
void method(void) { m_myClass.method(); }
};
int main() {
Test<class1> x(class1(1));
Test<class2> y(class2(2, 3));
x.method();
y.method();
}
意味があるのか分からないがとりあえずｺﾚで
もしくはTest::methodを可変引数にしてprintfにその可変引数を渡すしかない
まずなにがやりたいのか分からないからﾃｷﾄｰに書いてやったぞ
clsA(const char* const name[]) : m_name(name) {};
これはまあ何となく意味が解る。m_name ＜－－nameってことだよね。
clsA() : clsA((const char* const []){"mike","tetu",nullptr}) {};
しかしこれはどういう意味だろうか？
clsA ＜－－ (const char* const []){"mike","tetu",nullptr}
ラムダ関数？かとおもったが、前半はcastだろうか？
m_name ＜－－name
clsA ＜－－ {"mike","tetu",nullptr}
この二つがセットで意味を持つんだろうな。
const char *[] の初期化が３つくらいあったらどうするんだろうね。
まるでクイズを解いてるみたいだよ。
いくらなんでも言語仕様としてやはり不味いよね。
clsA ＜－－ {"mike","tetu",nullptr}
そしてm_nameは一つしかないから、m_name＝ {"mike","tetu",nullptr}となる。
引数を持つ場合は
clsA(const char* const name[]) : m_name(name) {};
m_name <-- name;
になる。
じゃあconstのメンバ変数が二つある場合はどうするんだろうか？
clsA:clsA( {"xxx"}),clsA({"yyy"})
{}
とは書けない。変数を明示しないといけないから、、、
clsA:m_name1( {"xxx","abc"}), m_name2({"yyy","def"}){}
必然的にとなる。
じゃあ最初から
clsA:m_name1( {"xxx","abc"}){}
こう書いていた方が分かりやすいし、これが成り立たないと論理破綻する。
private:
const char* const* m_name1;
const char* const* m_name2;
public:
clsA() : m_name1((const char* const []){"mike","tetu",nullptr}), m_name2((const char* const []){"mike2","tetu2",nullptr}) {};
clsA(const char* const name[]) : m_name1(name) {};
void put(){
for(const char* const * p=m_name1; *p!=nullptr ;++p ) {
printf(*p);
}
};
virtual ~clsA() {};
};
実験したみたが、コンパイルは通った。
環境依存で動作が変わるようなソースコードを参考にしてはいけない。
