ポインタを上手に例えてみよう

名言求ム

　　　　　　　　　　　　立
　　　　　　　　　初　　て
　　　　　　　　　め　　て
　　　　　　　　　て　　み
　　　　　　駄　 わ　　て
　　　　　　ス 　 か
　　　　　　レ 　 る
　　　　　　か
　　　圖　 な


　 Λ＿Λ
　（　´∀｀）
　（　　　　）

＋ 激しくsage ＋

ぽいんたあ
　じじいと共に
　　投げ捨てろ！

変にたとえるから分かりにくくなる。

ポインタと
　イテレータは
　　違うのよ
おじいさん

おにゃん子クラブで例えようとしたけど
会員番号１番の人が解らず沈没。

しかも配列の説明にしかならない事になって鬱。

sage

さげ

普通に緯度経度じゃだめかねえ。
新しい単語教えるときは繰り返しが大事だから毎度
「ポインタ、メモリの中の座標の事ね」を連呼。

新人にポンと渡しとけば、手前で勝手にポインタを理解しといてくれる
ような便利な本は無いのかえ？

>>11
新人が優秀なら･･･どうせかってに自分で理解する
新人がアホなら･･･どうせ数年後に実務で苦労するまで理解しない

もし御社の新人にポインタ研修させて頂けたら
ギャラいくらくらい貰えますか？

と聞いてみるテスト

「ねぇ・・・あの子さ・・・」
「ぽいんだなぁ」

>>14
こんなのが面白く感じる自分に鬱。
moudamepointer

>11
銀の弾丸は存在しない（w

まず、ポインタってそんなに難しいのか？と。
単純にメモリへのアドレスだろ。どこが難しいんだ？と
小一時間問い詰めたい。

>>17
変数とメモリの関係

>>17
禿げ銅。

ポインタがどうたらこうたら言う奴にロクなのはいない。
うざいだけ。めざわり。息してなくて吉。


こういうことにこだわってみせるのって、文系プルグラマが多いな。

>こういうことにこだわってみせるのって、文系プルグラマが多いな。
俺の後輩がまさにそう。

ポインタは、使い方よりも宣言の仕方の方が難しい。
整数の配列へのポインタを返す関数へのポインタをメンバに持つ構造体、とか。、

>>21
ゼンゼン難しくないぞ。
配列へのポインタって言い方するからややこしくなるんじゃないか。
正確には「配列の先頭要素へのポインタ」だから、普通の整数ポインタと同じだよ。

>>22
配列へのポインタはちゃんとある。
配列の先頭要素へのポインタとは別物だ。
実行してみろ。
int main()
{
int (*p10)[10];
int *p;

int buf[10];
p = buf;
p10 = &buf;

printf( "%d,%p,%d,%p,%d,%p",sizeof(*p10), p10, sizeof(*p), p, sizeof(buf[0]),buf );
}

型は配列なのにsizeof演算子や単項&演算子などの被演算数となるとき
以外はポインタに成り下がるとか。今では当たり前のように分かってても
初学者に易しいとは思えないな。

わざわざ例えようとするから、混乱する。

そういえば変数を「箱」って教えてた大学あったなぁ。

ポインタ？
ああ、あの時代遅れの概念ね。

とある大学の情報処理の講義プリントより

コンピュータはいくつもの入れ物を持っています。
これらの入れ物はあらかじめ入れられるものが決まっています。（最初に宣言します）
入れ物には単一の入れ物や複数並んだ入れ物、別の種類の入れ物が集まった入れ物などがあります。
：
：

アホかぁ！ヽ(`Д´)ﾉ

つーかポインタなんて中学・高校でコンピュータの基礎を勉強する時嫌でもやんだろ？
なんで歳よりは偉そうに教えてんだかわかんない。

>>28
中学高校で基礎を勉強するかはおいといて…
年寄りは何においても偉そうだよ。

>整数の配列へのポインタを返す関数へのポインタをメンバに持つ構造体、とか。

たいして難しくはないが、、こういうコードは書くなよ。
ちなみに、C++でやれば、ぜんぜんポインタを使わんですみそうだ。

整数の配列へのポインタを返す関数へのポインタをメンバに持つ構造体へのポインタを持つクラスとか

整数の配列へのポインタを返す関数へのポインタをメンバに持つ構造体へのポインタを持つクラスへのポインタを返す関数へのポインタを持つ共用体とか

ポインタは
Windowsのショートカットファイルや
インターネットのリンクと同じ。

そして、リンク先の種類(http,ftp,gopher,file...)と
どこを示すかという情報だけを持っている。

リンク切れが赤しいたけ発生の原因。

以上！！

無視されてるな。マジレスなんだがな。

typedef void (*hoge)(void);
hoge foo(void);

↑の関数をtypedefしたやつを使わないで書く方法どういうのでしたっけ。
最近、どこかのスレで見た気がするんですが忘れちゃいました。

void (*foo)(void);

>hoge foo(void);
hoge foo;

>>25

> そういえば変数を「箱」って教えてた大学あったなぁ。

それ、学校だけじゃない。企業研修（プログラミング初級編）でも。
中卒程度の数学の知識と理解があれば、こんな譬えは要らないはずなんだけどなあ・・・。

ポインタは住所

>33
すこく分かりやすい説明だと思います。

すません。説明不足でした。

hoge foo(void);

関数ポインタを返す関数なんですが、この関数のプロトタイプを
hogeをtypedefで定義せずに書く方法です。
自分で書くときはtypedefしますけどちょっと気になったんで。

スレ（ポインタの例え）と関係ないし、
激しくどうでもよくなってきたのでやっぱ無視してください。

こうか。void (*(*foo)(void))(void);

うーむ、変数を箱と喩えるのが、何がイケナイのか分からん。
単に数学で言う変数と同じですよ的な説明だと、aliasと混乱するかもしれないし。

なじぇ?

ポインタというだけで特殊な物だと思って、ただの変数だってことに
気付いてない人もときどき見かける

ポインタをお題にしたネタスレと思ったら、真面目なスレなのね。つまらん。

C/C++なら単に「ポインタ=アドレス」でいいんじゃないの。
漏れは一時期「ポインタ=参照だ!」的な思想にかぶれていたけど、
ポインタに対する演算やらキャストやらを説明するには、やっぱりアドレスとして
説明するのが一番分かりが早い。

ポインタは難しいってよく言うけど、どんな香具師でも
「自分では使いこなせないが、意味は理解できた」というところまでは到達できる。
後は使えるようになるまでひたすら練習問題解くべし。

そういやポインタだけで本一冊書いた香具師いたなあ。。。(嘆息)

>>47　はげど。

しかし、「ポインタがわからない」って何だろうと思ってたけど、
>>41や>>43に敵意はないけど、関数ポインタを返す関数のプロトタイプ
とかが難しいって話なの。そんなのtypedefでいいじゃん。

そんなんで悩んでるんなら、人生の浪費だよ。
そんなひまあったら、コード書けや。

> >>41や>>43に敵意はないけど、関数ポインタを返す関数のプロトタイプ
> とかが難しいって話なの。
いつからそんな話しになったの？

ポインタは宝の地図。
アドレス島に埋まっている宝のありかをバッテンでしめした地図
それがポインタなのぢゃ。

って私は覚えました。

迷信というかなんというか
みんなポインタは難しいとか色々吹き込むから、そう思いこんでしまうんじゃ

T型へのポインタ t のインクリメントが、
t++;
ではなく
t += sizeof( T );
であれば、初学者にとっては、
より理解しやすくなったのではなかろうか。

ポインタは月を指す指である　


ってどっかのサイトで言ってた

要するにポインタってオリエンテーリングみたいなもんなんだな

>>53
おをっ！名言臭い！

---- 以下、揚げ足取り ------
指をインクリメントすると、次の月を指すわけですな。

本当にポインタがわからない奴は変数とメモリとアドレスの関係がわかってないんだよ。

変数を値としてとる変数

>>55
そのサイト　ここですた
ttp://www.mashimo.com/c4.html
ttp://www.mashimo.com/pointer.html

>>43
それはもしかしてG評のM氏の本でつか？欝だ…

>>47ですた。

定義は
　　(ある型のデータを持てる)変数、
　　の、場所をあらわすデータ(＝アドレス？)、
　　を、持てる変数(＝ポインタ)。
とかだよね。

「何らかの犬(＝データ)、
を、飼っている家(＝変数)、
の、住所(＝アドレス)、
を、書く欄(＝ポインタ)」

で、どうだ！

>>61を称して
「犬へのポインタ」あるいは
「犬型変数へのポインタ」

「>>」みたいなもんだ。

お前らが例えで言っているポインタはほとんど参照。

そうか、ひょっとすると・・・
　　(ある型のデータを持てる)変数、
　　の、場所をあらわすデータ(＝ポインタ？)、
　　を、持てる変数(＝ポインタ変数？)。
とかかもしれないわけ？

このスレのほとんどの奴は参照と勘違いしてるのか？
あるアドレスのデータを型にはめて相対アクセス可能にするって事だな。
相対アクセスって言葉が今まで出てこなかったのが笑える。

>>66
分かりやすくしようとしてるのに難しい言葉出してどうするよ。

>>66
（・∀・）ｿﾚﾀﾞ

体操あくせく

>>66
やっぱlispやってる人ってレベル高いのかな
>>&7
どこが難しいんだろう？

>>70
相対アクセスってなんですか？

ポインタなんて知る必要あるのか？

言っておくが俺が知らんわけじゃないぞ。そう聞き返されるのが落ちだということだ。

>>71
ある地点を0と見なして、+-いくつでアクセスする方法だよー
そんなことも知らないのー？

>>71
は知らなかったに一票（藁

>>75
も知らなかったに三票(藁

>>74-75
>>73を読んでいないレスだよね。

>>74
ポインタはある地点を0と見なしているのか？(藁

つまり、相対アクセスと言う言葉を知らない人に説明する場合には。
「あるアドレスのデータを型にはめて、+-いくつでアクセスする方法を可能にするって事」
ということか。 これでわかってくれると思う？

>>56
ポインタが理解できない人は、そもそもメモリや
アドレスについて理解していない。

>>79
分かってる人には分かるけど分かってない人には分からない説明だね。

相対アクセスを知っててポインタを知らない人･･･？

PC相対アドレッシングでコード書換えてあぼーん

ボインタンを上手に例えてみよう

>>84
ボインタンとはボン・キュッ・ボン。

おまいら「相対アクセス」なんて怪しい言葉もらって喜んでるけど、
普通は「相対アドレッシング」「間接アドレッシング」とかいうだろう。
変だぞ、変。

Googleでの検索結果

相対アクセス 230件
相対アドレッシング 136件

>>86
ポインタと組にして検索すると

相対アクセス 12件
相対アドレッシング 73件

>>86
「相対アクセス」で引っかかるのはほとんどがURLに対する用語なので、はずれ。
ていうか「サイト相対アクセス向上理論」などという訳のわからん用語が
156件分引っかかってる…。

相対アクセスって言ってもなあ。
Cのポインタって引き算しちゃ駄目だしなあ。

>>89
ﾊｧ?
かけ算やわり算と勘違いしてねーか？

>>89
いや、出来ると思うんだけど。

できないのはかけ算やわり算、それにポインタ同士の加算だろ？

ポインタってのは
>>1 ←のこと？ ちょっと違うか。

>>93
違う。野球選手の目をつぶすためのあれ。

>>93
ポインタってのはな、ちょっと俺にはわからないから>>96に聞いてくれってやつ。
ちなみに辞書ひいてる時にやられるとマジでムカつく。
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　by Programming Perl

>>93-95
馬鹿

>>96
洒落の分からない阿呆

自分自身を指すポインタか。なんか哲学的。

>>95
お前高水準すぎ。
あと単なる基礎も理解してないのアフォすぎ。

アセンブラを使ってると、ラベルと間接アドレスをごちゃ混ぜにしたみたいで気持ち悪いです

１００げとおめでとう>>100

ポインタ使ってみますた。

自分自身を指すポインタか。なんか哲学的。

自我を持つポインタか。なんか哲学的。

人間になりたいと思っているポインタか。なんか哲学的。

うめぼし・・・？

*をお尻の穴にたとえて教えてください

ポインタはCとC++にしかないんですか？

C++とアセンブラに辛うじて残ってます。

じゃあポインタのある言語は時代遅れの言語だと思ってもいいですか？

昔触った Pascal にもあったような。

>>108
正確には ポインタ"しかない"言語は時代遅れ でしょう。

>>110
どういうこと？
参照があればOKとか？

参照はポインタですか？

ポインタとポインタ変数

>>112
すくなくともC++は別扱い。

ポインタって何ですか？

>>115
そんなことも分からないのですか? :)

>>115
ある凄腕２ちゃんねらが言った。
ポインタはティムティムだと。
つまり指したりするらしい。

>>117
出したり…

犬だよ犬。俺はレトリバーのが好きだ。

>>59
あの本買っちまった過去がある。●ソだったよ。鬱。

>>108
C#にもポインタはあるぞ。なぜか「unsafeコード」という括りにされているがな(W

Javaにもポインタあるぞ。
「Javaにはポインタはない！」と宣言した奴の書いたコードがNullPointerException起こしてた。

>>122
「Java謎+落とし穴 徹底解明」の著者はこう言ってます
＞Javaはポインタの言語だ　―Javaにはポインタ「しか」ない

>>123
そりゃ、おだぶつだ。

Javaにポインタがあることにすると、ポインタのない言語なんて存在しないこ
とにならない？

>>125
COBOL

>>123
そうそう、ひでーナンセンス本だよな。
後輩が持ってたのをちらっと見ただけだから、よく覚えとらんが、
クソミソにけなしてやって泣かしてやった覚えが。

>>127 かわいそうに。

漏れも後輩が>>59持っているのみて仰天したが、
ニコニコと嬉しそうな後輩の姿見て、何もいえなかった…。

>>123
文脈にもよるなあ。
ポインタ値を明示的にいじれないところがJavaの特徴だと思うので、
そういう話の流れに持っていっているのならいい本なんじゃない?

ポインタ変数は
winのショートカット、
macのエイリアス、
unix系のシンボリックリンク
と、いう理解であってますか？

>>120
やっぱそうなんすか。昨日買いますた。鬱。

誰かアフォな私めに巧みにポインタをたとえて…

>>130
だからそれは参照だって。

>>132
それが参照ならJavaのポインタも参照というくくりになってしまう。
「参照」と言い切れるのはハードリンクぐらいでは。
「エイリアス」というのは怪しげだけど、よく知らん。

>>131-133
Javaのポインタ＝参照といってもあながち間違いではない
そもそも参照とポインタを区別する言語仕様に依存しない明確な基準など無い。

言語仕様書にポインタと書いてあればその言語ではポインタと呼ばれるし
参照と書いてあれば参照と呼ばれる。

>>134
ポインタと参照の両方が存在する言語の場合はどうするんだ？

>>134
2行目以降はいただけない。ここのスレの流れ上は、
・ポインタ=ポインタ値またはそれを保持するポインタ変数
・参照=何かを指すもの全般。ただしポインタ値による実装は除き、
　ポインタに対する演算等は不可。
みたいなローカルルールができてると思うけど。

この意味ではJavaはポインタ系の言語だが、
それが隠されている為あたかも参照系に見える、という説明が正しげ。

というわけで名言大賞は「相対アクセス」ということで。

>>136
２箇所訂正
×：ここのスレの流れ上は、
○：君の考えは

×：名言大賞は「相対アクセス」
○：名言大賞は「ローカルルール」

勉強してた頃、Z-80でいうところのインデックスレジスタ
みたいなもんかと思ってそれ以降そのまんまなんだけど、
認識間違ってる？

ポインタ＝簡単に変なメモリを参照できるもの。
参照＝そうでないもの。
という定義はダメか？ ダメなら理由もお願い。

アホばっかだな

>>140 ｵﾏｴﾓﾅｰ

公認定義のない言葉の定義に夢中になれる君たちってほんとにプログラマ？

「愛って何」みたいな議論だよな。

( ´_ゝ`)ﾌｰﾝ

ロックって何？とか流行ったな

「ポインタ」って名前が悪いんだよ、
もっと、こう、グッときて、ブワァーってなる、なんか洒落た名前にしろよ。

「ポインタ」の訳語は？
いつものノリだと、「指示子」とかそんな感じか？

「ポインたかどう？
「ポインタカードで〜す！
「すき

>>142
スレッドストッパーごくろんさん。

実物のりんごをみて、
「それ」を「りんご」だとか「apple」だとかいったりするとき
「それ」、「りんご」、「apple」はポインタじゃないかな。

また、「俺の昼御飯」なんてのもポインタじゃないかな。
文脈上いろんな実体を指し示すという意味で。

ポインタとは乳首だ。
乳首はおっぱいを指し示している。

裸の女がずらっと寝転がっている。
0番目のポインタをタッチ。あ〜ん。
1番目のポインタをタッチ。う〜ん。
　：
これがポインタの演算だ。
途中で飽きても、次の女を手前に引き寄せることはしない。
女と女の間が境界になってる。アラインメントの調整が必要なわけだ。

ちなみに最初の女は塗れてるんだ。
だから、塗るポインタ。

pointer
: '*'
| '*' type_qualifier_list
| '*' pointer
| '*' type_qualifier_list pointer
;

・ポインタ
ある変数を指し示す変数。
この値を変更すると別の物を指す（変数を指すとは限らないが）

・参照
ある変数の別称。
よって増減できない
＃そもそも”別称”なので増減という概念がない

という理解は間違ってますか？識者解説ｷﾎﾞﾝ

＞乳首はおっぱいを指し示している。

陥没乳頭なのか

ありかを。

>>153
J字型なのかも。

ポインタの説明の時に
メモリブロックの確保、解放のメカニズムとかも
教えといてほしいな。
ユーザープログラムからは見えない
管理情報（サイズとか）がどこかに書いてあるんでしょ？

pointer→指し示すもの
・メモリのアドレスそのもの

参照→reference
・メモリ上のオブジェクトへの参照方法を示すもの

別称はaliasだろうね。

>>157
＞参照→reference
＞別称はaliasだろうね。
あぁ…そうですね。
でも何か意味的に参照を別称と言い換えた方が分かりやすい気がするのは漏れだけかなあ…？
というか参照を教える時にはいつも「ある変数の別名のことだ」って言ってるんだけど、これって罪？
これだと「参照がnullを参照しない（ややこしいな…）」ことについての説明もうまくいくんだけど。

概念は違うでしょうね。
pointerとreferenceは

http://education.yahoo.com/reference/dictionary/
pointer
6. Computer Science A variable that holds the address of a core storage location.

まあ、実際には「ポインタの値を渡す」を「ポインタを渡す」とも
言っちゃうから、言葉に惑わされずに正確な意味を捉えてさえいれば
ｲﾝｼﾞｬﾈｰﾉ

ポインタはfusianasan

pointer=アドレスという定義は厳密には間違い。
ハンドルとして実装された処理系だって考えられる。
譬えとしてなら良い説明だと思うけどね。

アドレスってのはメモリアドレスとは限らないんじゃないの。
アクセスするための手がかり一般をアドレスだって風な、抽象的な解釈も化膿姉妹

嫌な姉妹だな。

値をアクセスするだけではなく、値の保存領域（メディア）をアクセスできる
ってのがミソだな。

格助詞が違うかな。を→に

Javaで＜配列要素の位置＞を参照でズバリ表せないのがつらいって
思ったことないかい

↑そんなプログラミングは糞

>>168　わしもそー思ったが、最初は戸惑ったりして

クソスレだと思ってたのが何時の間にか良スレ気味に・・・（w

ASCII'85 11月号P207でKnuthがいいこと言った!

>>170
そうか? どいつもこいつも特定言語に片寄っててうんざりだが。
ポインタの定義ならfjかJHで久野ｾｿｾｲがやっていたような。参考になるかも。

じゃあ、「Cポインタ」とか「Java参照」とか言語指定の方向で

「ポインタとは矢印です」ってオブジェクトへ矢印引いて説明するのはどお?
Javaのポインタのあいまいな立場を感覚的に表してるぽげ。

さて、nullはどうしようか。。。

刺さっているﾁﾑｺと自由なﾁﾑｺの違いでどうだ

てゆーか、このスレでさえ「ポインタ」と「ポインタ変数」をごっちゃにしてるし、
C++の参照を他の言語の参照と同列に扱ってるし。

>>176
ポインタ変数のことを単にポインタと言ってるのがほとんどじゃないかな。
2行目に関しては同意

>>1
ぽいんた

>>6
Cの感じだと、たぶん「アドレス」というデータが「ポインタ」という変数に
入ってるとかいう感じではないかと。だって、
int i = 123;
int *p = &i;
で、
123＝値、i＝変数、&i＝アドレス、p＝ポインタ
って言いそう

だからCにおいては、
ポインタ＝アドレス変数
かな。で、アドレスに基づいた低レベルなアクセス方法が提供されていると

想像なんだけど、K&Rでは、ポインタはもともと「アドレス変数」という
意味だったんじゃないかな。

ところが、mallocとか「アドレスを返す関数」があって、そのアドレスを
即ポインタに格納して使うような場合があって、それを、
「この関数はポインタに入れる値を返す」というのを
「この関数はポインタを返す」と言ったんじゃないのかな。

これは英語では普通の発想だと思う。
変数と中身、型と値をときどき厳密に区別しないで書いてある
ことが多いから。

Cの世界でも、↓こういうダブルスタンダードがありそうな感じがする
建前：　ポインタ＝アドレス変数
慣用：　ポインタ＝(参照先の型を指定された、微妙に高級な)アドレス

>>181 >>182 同意

特に、↓これ。
>これは英語では普通の発想だと思う。
厳密には「これはA型のオブジェクト」というのを「これはA」と言ったりする
のと似てる。
そんなもんだと思う。

今更だが、、s/>>6/>>176/。鬱氏

「ぽいんた」とひらがなで書くと卑猥ですね。

ここはひどい淫太根っ子ですね

どうしてそんなにポインタにこだわるのですか？
嫌な思い出でも？

　　　　　　　　　　　　　　　 　|＼
┌──────────┘- ＼
│　　　　　　　　　　　　　　　　　　 ＼
│　こんな感じでしょうか　　　　　　　>
│　　　　　　　　　　　　　　 　 　 　 ／
└──────────┐- ／
　　　 　 ヽ(´ー｀).ﾉ　　　　 　 |／
　 　 　　 　(　 へ)
　 　 　 　　く
　　　　　　　　↑ ﾎﾟｲﾝﾀさん

　　　　　　　　　　　　 　 　 　- = ≡三　　　　　　 　 　 　 　 　 　　 |＼
　　　　　　　　　　　　 　 - = ≡三　　┌──────────┘- ＼
　　　　 　 　 　 　 　 ＿ = ≡三　　　 │　　　　　　　　　　　　　 　 　　 　 ＼
　　　　　　　　　　　　　　　　　　　　　│　こんな感じでしょうか　　　　　　　 >
　　　　 　 　 　 　 　 ￣ = ≡三　　　 │ 　　　　　　　　　　　　　　　　　　 ／
　　　　　　　　　　　　 　 - = ≡三　　└──────────┐- ／
　　　　　 　 (´ー｀) 　 　 　 　- = ≡三　　　 　　 　 　 　 　 　 　 　 |／
　　　　　　( ヽ ヽ)
　 　 　 　／　　>
　　　　　　　↑ ﾎﾟｲﾝﾀ

ポインタは永遠の飯のタネです。
これがあるかぎり、1年に何冊も本が出せるのです。
あんまり種明かしをしないように。

確かに、謎めかせおくことと、理解できないとドキュ扱いされて
大変という雰囲気を維持しておくのは、商売的に重要そうだね。

ポインタ本書いてる奴って．．．、あいつか？

void kuso(int* a)
{
　printf("%d\n", a[3]);
}

int b = {1,2,3,4};

kuso(b);

↑がわかりません。

>>191
int b = {1,2,3,4};
とは？

>>192
int b[] = {1,2,3,4};

のつもりなんじゃない？

ポインタ話は、誰が厨かを判定するのにいいぽ

話に加わったら厨。

俺の近所では、ポインタ話をし出すやつが厨。
実務になんの関係もないから。

煽りじゃないつもりなんだけど、ポインタが分からないって言ってる香具師は
一体何に悩んでるんだ？
>>191だって（>>193が正しいとすると）どこに疑問を持つのかが分からん。

あげ

>>191
main関数は？
int b[]=〜？
アドレス渡しと値渡しの違いは？
など、小１時間問い詰めたい・・・。

*---------------------------*
char *kiriban; /* 文字型ポインタ */
win = &number; /* number：レス番号 */

printf("%c get\n",kiriban);
*-------------------------------*

出力結果:
200 get

>>197
同意

まあアレだな。
「ポインタは難しい」と洗脳されてるから、
本来は単純なはずのポインタを
難しく考え過ぎるんだろうな。

そいえば
「関数ポインタを返す」に比べて
「関数アドレスを返す」ってあんまり言わない気がするが、
フォーマルにはアドレスと言ったほうがよさそう。

ExcelにINDIRECTという関数がありますが、これの引数が
Ｃで云うポインタと考えていいのでしょうか？

ﾎﾟｲﾝﾀ教えろ、ﾎﾟｲﾝﾀ解説ｽﾚは糞で、お前等は蝿

int *a;
*は単なるそばかす

>>204　そうね。
でも、もし INDIRECT("A1") というふうに定数などでもで書けるならば、
それはポインタ的じゃないよ。つまり間接アドレッシングっぽくない。

>>207
なんで？定数へのポインタは駄目なの？

char *c="hoge";
駄目じゃあないぞ。

え、ちがう？

話がずれてきているスレはここですか？

セル A1＝"これはA1の値です。"
セル B1＝"A1"

とすると、対応はこう↓なると思う。

A1 ... string a
B1 (= "A1") ... string *p (= &a) ★これがポインタ
INDIRECT(B1) ... *p (= a)
INDIRECT("A1") ... *(&a) (= a)

エクセルで喩えるのは、さすがに無理が。

20年前にも、アセンブリ言語知らなければプログラムはわからない、
なんていっていた馬鹿がいた。
今時Cとかポインタとかいうのはその残党だろ。消えろ！

ん、なんかアホが乱入してきたな・・・

>>212
ポインタを知らないプログラマーがいても俺はいいと思うが、
低レベルなことを理解することで性能のよいプログラムが作れるようになる可能性がある。

キチガイは相手にせんほーがええでぇ

ポインター
　今も爺と
　　共にある。

俺は職業的プログラマではないし、その道の人が何を使おうと
口をはさむつもりはない。
でもね、プログラミングは構造化とかオブジェクト指向で
明らかに進化したよね。俺にとってはどうでもいいんだけど、
ポインタを使わなずにプログラムできるようになったのは
進化といえないのかね？
（もちろん、ドライバなんか書いている人は別でしょうね）

ここは「ポインタを上手に例えてみよう」だよ
そんなに、批判したけりゃ「オブジェクト指向は戦場では必要なし�G 」にでも逝けばぁ

>>218
表現が悪かったかもしれない。
C++は構造化もオブジェクト指向も入っているけどポインタ依存
が残っているから（残念ながら）腐っている、といいたかったんだ。

>>219
ポインタわからないなら、そう言いなよ。誰も責めないからさ。
そして、もう来ないでね。

>>220
もうこないけど。
ポインタわかっても将来何の意味もないと思う。
いまから覚える価値はないよ。
（俺もCのポインタは使えるけど）。

>>221
ハイハイ、貴方が「自分は C のポインタが使える」と思っていることは
良くわかりましたから、もう二度と来ないでね。

　　　　　　　　　　　大笑い。
　　　　　　　　　　　　 ↓

　大笑い。　→　　>>212　　←　大笑い。

　　　　　　　　　　　　 ↑
　　　　　　　　　　　大笑い。

ポインタをそんな大袈裟に捉えてどうする・・・。

>>224
ポインタだけで本書くような厨ライターがいるのが悪いな。
やつら職業ライターで、実務経験はないんだろうな。

>>225
君が書いてくれないか

>>226
よし書いてやろう。

あ、でも、ポインタだけじゃ、せえぜえ2ページにしかなんねーや。
俺には、厨ライターの才能はないな。
>>226は「ポインタだけで」という形容詞をちゃんと読んだのか？（ﾌﾟ

形容句を形容詞と間違うようでは確かにライターにはなれぬであろうｗ

副詞句。

ちっﾊﾞﾚﾀｶ

ちっﾊﾞｶﾀﾚ

>>231
ﾅｾﾞｶﾜﾛﾀ

ポインタの概念ごときが分からない糞プログラマが増えたのは困りもんだな。
ポインタと言う概念が分からない阿呆は痛い。

ポインタがわからない人が何故分からないのか分からない。
ポインタは、メモリ上にあるデータを、メモリ上のアドレスとしてみる、ってだけだろ？
っていうか、本当にポインタがわからないプログラマっているの？

>>234
てか、分かったつもりでいる奴もｲﾊﾟｰｲいるよ。

ポインタは短縮ダイアルです。
以上

>>234
> ポインタは、メモリ上にあるデータを、メモリ上のアドレスとしてみる、ってだけだろ？

ﾌﾟ

>>237
「メモリ上のアドレス」で良いと思うぞ。
ただ、それ一辺倒だとそのうちvtblがどうとかエラいことになりそうだけど。

>>237は神です。ありがとう。

でも
＞ポインタは、メモリ上にあるデータを、メモリ上のアドレスとしてみる、ってだけだろ？
これで分かってると思ってるなら、まずい気がする・・・。
まあこんな所で演説ぶるのも嫌だから、簡潔(？)に書いたのかもしれんけど。

ポインタ って、あるものをさし示すモノ ってことでいいんじゃない?

>>241
それは単なる和訳

ポインタとは、ただの整数
命令語とは、ただの整数
データとは、ただの整数
ノイマンばんざぁい

ポインタの参照の違いは、整数として計算ができるかどうかの違いだね。
参照は比較(それが指す実体じゃないよ)できることもあるが、比較できないこともある。
足すことができることもあるが、できないこともある。
ポインタはあらゆる四則演算、比較が可能。
ただ、それをやることに意味がなかったり判かりにくくなったりするので、通常言語機構で制限が加えてある。
アセンブラになると、それが素の状態になる。ＣやＣ＋＋だとキャストでなんとかできる。
判りやすさと引き換えに自由度を手に入れることができるのがポインタ。
というのはどう？

凡庸に＿"番地、住所"＿
よってポインタの計算とは

日本・大阪・高槻
日本・東京・三軒茶屋
の構造を利用して
青森の住所を算出するようなもん。

ポインタは中間管理職

>>246
せつねぇ〜

>>245
>の構造を利用して
>青森の住所を算出するようなもん。

できるか！（笑
日本の幅は家一軒分しんかないんけ！

>>246
仕事の苦労が外部にわからないとこはあってる。

ポインタとはアドレスバス幅？

char *hunga[10];
とか書いてあると、もうわけわからん。
これのせいでプログラミング作法が読めない。

>>251
ポインタの配列

使うときのイメージで逆にたどっていけばいいでしょ。
(char) *(hunga[i])
(char pointer) hunga[i]
(char pointer array) hunga

* と [ ] の優先順位さえ解っていればいい

>>251 それはポインタが悪いんじゃなくて
Ｃのポインタ宣言の文法が腐ってるだけ。

>>255
別に腐ってないよ。簡潔に表現できる分にはあれで正解。
優先順位知ってれば混乱しない。

腐ってるとすれば、それは>>255の脳内。

しかし正直、関数ポインタが絡むと。。

syntax rotten

ポインタ配列（ダブルポインタ）
なんだけど、自分の場合文字列配列を
使うことが多いので、こんな感じで
ポインタを使ってデータにアクセスしてるのだけど、
この認識でいいかな? >>識者

int main(void){
　char a[10][1];
　char *pa[1];
　unsigned long int *ppa;

　pa[0] = &(a[10][0]);
　pa[1] = &(a[10][1]);
　pa[0] = "aaaa";
　pa[1] = "bbbb";
　ppa = (unsigned long int *)pa;

　printf("%s\n",(char *)*ppa);
　printf("%s\n",(char *)*(ppa + 1));
}

>>260
>　ppa = (unsigned long int *)pa;
何したいのさ

>>260
std::vector使えと

>>261
ppa=pa
だと
paは char型へのポインタだから
一応ppaと型を合わせてキャストしただけ。
特にやらなくてもいいのかな。
となると、
pa[0] = (char *)&(a[10][0]);
pa[1] = (char *)&(a[10][1]);
としておくべきだったかな。

ゴメソ
>paは char型へのポインタだから
paは char型へのポインタのポインタだから
キャストは必要ないね。
逝ってきます。

識者じゃないけど
char a[10][2];
char *pa[2];
char **ppa;
こうでない？

>>265
多次元配列間違ってました。
後の指摘もそうっすね。
調べて今書こうと思ってました。
もう一回書きます。
int main(void){
　char a[1][10];
　char *pa[1];
　char **ppa;

　pa[0] = (char *)&(a[0][10]);
　pa[1] = (char *)&(a[1][10]);
　pa[0] = "aaaa";
　pa[1] = "bbbb";
　ppa = pa;

　printf("%s\n",(char *)*ppa);
　printf("%s\n",(char *)*(ppa + 1));
}

ふざけてるんですよね

「ポインタとは」だけじゃいまや明確な定義は出来ないでしょう。
何におけるポインタの話をしたいのか言わない1は釣りしてるだけだよね。

>>266
C++,C,(もしくはjava)
やり直しましょう…
入門書に書いてあると思います…

pa[0] = (char *)&(a[0][10]);
// ↓ たぶんこうしたいかと…
pa[0] = (char *)&(a[0][0]);

ppa = pa;
// ↓ たぶんこうしたいかと…
ppa = &pa;

printf("%s\n",(char *)*ppa);
printf("%s\n",(char *)*(ppa + 1));
// ↓こうしたほうが簡潔かと…
printf("%s\n", *ppa) );
printf("%s\n", *(ppa+1)) );

あと２，３箇所は
もっと突っ込んであげたほうがいいところはありますが…
そこまで善人では僕はありません。
…基礎からやり直しましょう…

さすが基礎の出来ている人は
漏れと違ってすごいですね。。
そういうなら
pa[0] = (char *)&(a[0][0]);
pa[1] = (char *)&(a[1][0]);
こっちの方が正しいのでは。

しかし、
pa[0] = (char *)&(a[0][10]);
pa[1] = (char *)&(a[1][10]);
でも269の
pa[0] = (char *)&(a[0][0]);
pa[1] = (char *)&(a[1][10]);
でも
きちんと
aaaa
bbbb

と表示できた。
基礎の出来ているなら何故
だか分かるのですよね？

あと、いくら何でもppa = &pa
ないでしょう。
コンパイラにも怒られましたよ。

　pa[0] = &(a[10][0]);
　pa[1] = &(a[10][1]);
　pa[0] = "aaaa";
　pa[1] = "bbbb";
上書きしてどうするの？っていうかネタでしょ。

ひょっとして、こう↓したかった？

int main(void){
char a[2][10] = {"aaaa","bbbb"};
char *pa[2] = {a[0], a[1]};
char **ppa = pa;
printf("%s\n",ppa[0]);
printf("%s\n",ppa[1]);
}

けっこう多次元配列とかわかってない人いるんだね

上書きってか、
pa[0] = (char *)&(a[0][0]);
pa[1] = (char *)&(a[1][0]);
でポインタとデータ部をリンクさせ、
pa[0] = "aaaa";
pa[1] = "bbbb";
そこに文字列代入しているんじゃないの？

>>273
多次元配列なんて使ったことないから問題ない

>>274
いつからアドレス操作が strcpy の代わりになるようになったのか小一時間

そうか、なるほど。
pa[0] = a[0];
pa[1] = a[1];
strcpy (pa[0],"aaaa");
strcpy (pa[1],"bbbb");
ってやりたかったんだな。

>>274
ﾌﾟ

>>270
ppa = &pa
// ↓こうだった…これはミスでした…
ppa = &pa[0];

pa[0] = (char *)&(a[0][0]);
// ↓これは省略したんです（同じロジック何回も書くの嫌でしょう？）
pa[0] = &(a[0][0]);
pa[1] = &(a[0][1]);

んじゃまあ、他のミスの件を…
１：データ領域の指定おかしい（確保していない領域も計算対象としている）
char a[1][10];
↑１０個の配列を１個作成＞１０個の配列を２個の作成が正しいよって下記が正しい↓
char a[2][10];

char *pa[1];
↑１個の配列を作成＞２個の配列を作成が正しいよって下記が正しい↓
char pa[2];

データ領域を指定した以上に使っているので…
このような小規模のプログラムでは問題ないでしょうが
ソフトウェアを作ろうと思えば、動作に不具合を発生させます。

２：なぜ表示されたのか？
pa[0] = "aaaa";
pa[1] = "bbbb";
↑ここで非明示のデータ領域に
指定されたデータを格納し
そのポインターのみを取得して
そのポインターを参照してデータを出力しているからです。

ですので、ためしに↓を実行してごらんなさい。
printf("%c\n",a[0][0]);printf("%c\n",a[0][1]);
printf("%c\n",a[1][0]);printf("%c\n",a[1][1]);

ちなみに、
pa[0] = a[0];
pa[1] = a[1];
と、
pa[0] = &a[0][0];
pa[1] = &a[1][0];
は同じ。

↓これなら、少しはおもしろい。
#include <string.h>
main () {
char a[2][10];
//char *pa[2] = {a[0], a[1]};
char *pa[2] = {&a[0][0], &a[1][0]};
char **ppa = pa;
strcpy (ppa[0], "aaaa");
strcpy (ppa[1], "bbbb");
printf ("%s\n", a[0]);
printf ("%s\n", a[1]);
}

>>278
誤植したので修正します

pa[0] = (char *)&(a[0][0]);
// ↓これは省略したんです（同じロジック何回も書くの嫌でしょう？）
pa[0] = &(a[0][0]);
pa[1] = &(a[1][0]);

whileって人もかなり　あ　や　し　い

>>280
それはその書き方が僕の好みだから…。

別の例：
#include <string.h>
main () {
char a[2][10];
char (*p)[][10] = &a; // 多次元配列へのポインタ
strcpy ((*p)[0], "aaaa");
strcpy ((*p)[1], "bbbb");
printf ("%s\n", a[0]);
printf ("%s\n", a[1]);
}

ポインタが難しいんじゃなくてC言語とかのポインタの文法と仕様がダメなんでしょ。

>>286
それは言えてるようで、言えてないようで。。。
教えられ方が下手なんだと思う。

そうか、この変数名がおかしいのか。
char **ppa = pa;
↓
char **pp = pa; // pa = char pointer array, pp = char pointer pointer

>>276-277
char *a;
a="aaa"
ができるのに
char *pa[1]
pa[0] = "aaa"
ができないということに
なるけど何故？
と思ったら、最初に宣言した配列
とは別のアドレス参照してしまう
ということですね。
上書きとはアドレスの上書き
だったのですね。

ネタにマジレスしてるよ…
２ちゃんねらーじゃないね〜whileってひと。
っていうかネタってわかれよ（藁

>>289
たぶんあってる。Cで文字列を扱うときは考え方を改めなければイケナイ

>>289
はぁ？

結論：whileっていう人＋αが　釣　れ　た

>>289
そうです。

>>290
…悪かったです…反省してます…

↓この冒頭の一発を見逃した香具師は要注意

260 ：デフォルトの名無しさん ：02/09/11 15:31
ポインタ配列（ダブルポインタ）
なんだけど、…

正確には
char *a;a="aaa";も
char *pa[1]; pa[0] = "aaa";も
できます。

↓これは正しい。
＞上書きとはアドレスの上書き
＞だったのですね。

こんなのも作ってみた。
#include <stdio.h>
#include <string.h>

int main(void){
　int i;
　char *a[1];
　char **pa;
　for(i = 0; i <= 1; i++)
　　a[i] = (char *)malloc( 10 * sizeof(char) );
　strcpy(a[0],"aaaa");
　strcpy(a[1],"bbbb");

　pa = &a[0];
　printf("%s\n",*pa);
　printf("%s\n",*(pa + 1));
//　for(i = 0; i <= 1; i++)
//　　free(a[i]);
}
最後、freeしといた方がいいと思ったけど
コメントを外すと
aaaa
bbbb
の後セグメンテーションエラーが出る。

ポインタはギターでいうFコードみたいなやつ。
弾ける人には訳ないが、弾けない人には悩みの種。

sizeof(char)は無意味です

ちうか
>char *a[1];
>　for(i = 0; i <= 1; i++)
>　　a[i] = (char *)malloc( 10 * sizeof(char) );
>　strcpy(a[0],"aaaa");
>　strcpy(a[1],"bbbb");
逝って良し

>297
こうでしょう…
#include <stdio.h>
#include <string.h>

void main( void ){
　int i;
　char *a[2];
　char **pa;
　for( i = 0; i < 2; i++ )
　　a[i] = (char *)malloc( 10 * sizeof(char) );
　strcpy(a[0],"aaaa");
　strcpy(a[1],"bbbb");
　pa = &a[0];
　printf("%s\n",*pa);
　printf("%s\n",*(pa + 1));
　for( i = 0; i < 2; i++ )
　　free(a[i]);
}

こんな間違いするのはVB厨だけ。
VB厨逝って良し。

そうね、charはどの環境でも
1バイトだね。

>>301
malloc…つかわないなぁ…new使います。

>>304　唐突にC++か、おめでてーな

わけわからん。
ポインタって、「メモリ上のアドレスを参照する」という以外の解釈のされ方があるのか？
ポインタ変数の値は確かに演算可能だけど、この場合、その値は「ポインタ」としてはコンピュータが判断してないわけだろ？
演算するんだから、ポインタ変数に入っている値はポインタではない、っていえるんじゃない？
そもそも、コンピュータで扱うデータは、全て解釈の違いがあるだけだろ？
その解釈を分けて「整数」とか「浮動少数」とか言ってるんだから、
そういう解釈をすることを前提にして「ポインタ」も名づけてるんじゃないの？

VB全く知らないんだけど
VBだと a[1] で要素2個の配列ということになるの？

>>307
なるよ。

>>306
>ポインタ変数の値は確かに演算可能だけど、
>この場合、その値は「ポインタ」としてはコンピュータが判断してないわけだろ？
そんなことはないですよ。
コンピュータは演算されていてもポインタとして扱います。

>>307
そうかもしれませんね…。
3年はBASIC読んでないので憶えていませんが。

あっそうか。
宣言は要素数なのか。

ttp://www.rakuten.co.jp/starkids/454773/484020/

>>309
そういう意味じゃあなくて、ポインタかどうかは、コンピュータがそれをどう扱ったか（判断したか）ではないのか？ということ。

そもそも、人間の思考能力や記憶力には限界があるから、変数に型があって、コンピュータに判断をまかせてるんじゃないの？
メモリ上では、そこに入っている値が何であるかなんて判断されないわけだし、そこにあるデータが「プログラム」なのか「データ」なのかも区別がないんだから。

つまり、コンピュータがそれを「どう判断したか」によって、ポインタなり整数なりが、定義されると考えたほうがいいんじゃないか？ッてことをいいたかった。

っていうか、俺が間違ってました、ごめんなさい。

>>309
必ずしもそうは言い切れないのでは。
int aaa (int p)
{
return p + 1;
}
char * aaa (char *p)
{
return p + 1;
}
.globl _aaa
.def_aaa;.scl2;.type32;.endef
_aaa:
movl 4(%esp),%eax
incl %eax
ret
どっちも同じコードになってるけど。

char *a;a + 1;
ではアドレスは1バイト進むし
intが4バイトなら
int *a;a + 1;
は*aは4バイト進む。

ポインタの実体はアドレス値だけど
型情報をもったアドレス値
という認識でいいのでは。

結論＝whileは　知　っ　た　か　ぶ　り

間違い->
char *a;だと
*(a+1）は*aの1バイト先の値を参照するし
intが4バイトなら
int *a;a + 1;
*(a+1)は*aの4バイト先の値を参照する。

>>314
それ自体は型情報をもっていなくて、コンパイルした時点で+1が+4に置き換わっているとか、
コンピュータがそう判断して+1を+4と置き換えながら実行しているのでは？
っていうか、やっぱり、「コンピュータがそれをどう判断するか」だと思うンだけど、意見くれよ（；´Д｀）

>>314
それは↓かと
char *a;a++;
int *a;a++;

>>317
ネタ？
自分でコンパイルして確かめてみなよ。

>>317
データであるかぎり
型情報はもっているとおもいますよ。

例え：void*のポインターであっても、
ポインターであるという点において

>>313
たとえば、
ポインターを計算に用いて、
新しいポインターを生成したとします。
（その時点で演算している）

そのポインターはポインターといて扱われます。

>>317
char *とか
int *
といった時点で型情報を持った
アドレス値として扱うのでは。
ただ単にアドレスなら、
char a;unsigned long ad;ad=&a;
でいいのでは？

メモリは数バイト単位で区切られてて、同時に情報をもっているとはいえないのでは？
型情報は別の場所にあるんじゃないの？

>>318
説明するには
どっちでもいいじゃん。

>>322
それを型情報をもったアドレス値として扱うのは「誰」？

コンパイル時の型情報と、実行時の型情報だけは区別してほしいこのごろ

>>323
型情報は記憶装置にではなく、宣言やキャストで
この型として扱えと命令しているのではないのかな。

>>323
> 型情報は別の場所にあるんじゃないの？

ネタだよな ?

アセンブルとＣ 1/2

int aaa (int p){return p + 1;}
push ebp
mov ebp,esp
mov eax,dword ptr [p]
add eax,1
pop ebp
ret

char * aaa (char *p){return p + 1;}
push ebp
mov ebp,esp
mov eax,dword ptr [p]
add eax,1
pop ebp
ret

>>328
おまえが、だろ？

cでは、ポインタの型情報はコードに落とすときコンパイラが
必要とするだけで実行時は型情報なんて存在しないんじゃないの。

アセンブルとＣ 2/2

int aaa(int p){return p++;}
push ebp
mov ebp,esp
mov eax,dword ptr [p]
mov ecx,dword ptr [p]
add ecx,1
mov dword ptr [p],ecx
pop ebp
ret

char* aaa( char* p ){return p++;}
push ebp
mov ebp,esp
mov eax,dword ptr [p]
mov ecx,dword ptr [p]
add ecx,1
mov dword ptr [p],ecx
pop ebp
ret

>>327
「プログラム」自体がメモリ上に存在してるから、実行時には、全てデータとしてしか存在してないはず。
すると、実行時には宣言とか型情報っていうのはメモリ上にあることなんない？
っていうか、「誰が」それを見て語っているのかに食い違いがあるような……

>>313
う…ん
これで理解してくれませんか？

>>329
>>332

ポインタの型の謎が解けました。さんくす

あと、ご飯を食べにいくによって…
しばらくレスできません。
ご理解下さい…

アセンブラは解りません……
機械語なら、仕様書があれば解ると思います。

３１３だけど
>>329と>>332って>>313
と同じことやって同じ結果（どっちも同じコードに落ちる）
になってるということでしょ？

>>330
ぷっ。何が、ネタかもわからんのか...。

>>333
そうなると型情報はプログラムが
メモリに読み込まれた時点であるかも
しれないね。
100バイトのメモリを確保するコードの
プログラムは、実行時には
100バイト+プログラム実行領域があり、
その実行領域に存在するのかな？

妄想だけで話すなと言われそうだけど。。。

>>340
妄想だけで話すな。

>>340
正確には型情報っていうよりも、それをどう扱うかの「処理手順」が入ってるんだと思う。
それを「浮動少数」って（便宜上）コンピュータが解釈したなら、「計算するときに丸め込み処理を行う」「上位何ビットは指数をしめす」とか。

そんで、結果として、人間がそれを浮動少数として解釈できるような値がでてくる、ってなもんだと思ってたけど、なんか違うみたいね。

中でどうなってようと関係ないけどね

>>339
おまえが、だろ？（ｗ
別の場所＝ソースコードってのはどうだ。（ｗ

>>338
>>338
（ええい、飯は抜きだー！！）
p+1,では単純に整数として計算されます。
ポインタとして演算（いいのか?この表現）するには
p++,じゃないといけないんですよ。

それにいざとなったら
機械語やアセンブラのソースを組み込む事も出来ますが、
それでもvoid*,int*,はポインターのデータ領域なんです。
つまりシステム的には、
＞コンピュータは演算されていてもポインタとして扱います
の通りなんです。
>>309

>>346
>それでもvoid*,int*,はポインターのデータ領域なんです。
くわしくお願い（；´Д｀）

お前ら専門家or専門家予備軍だったら、
こーいう話で「コンピュータ」を動作主(主語)にしないでくれよ。
「コンパイラは〜をあくまでもポインタとして扱う」とかなら許せるが、
それじゃ「コンピュータに相性を占ってもらった」とかと同じレベルだぞ

>>347
↓ここできかれるといいかも（怠け者）
http://pc3.2ch.net/test/read.cgi/tech/1031340950/l50

>>348
便宜上って断ってるジャン（ノД｀）

>>346
ん？
ポインタでも
p+1はあるんでないの？
p++;a=*pと
a=*(p + 1);
での値を取得するとき
前者のpの値
は変わるけど、
後者は変わらないんでないの？

>>345
はいはい、俺が悪かった。お前が、必死なのはわかったし、話の流れが読めない
奴と言うことも良くわかった。

>>348
ぐぅ…反省します。

>>352
ﾌﾟ
流れ読んで煽れるかアフォ！

>>346
>p+1,では単純に整数として計算されます。
>ポインタとして演算（いいのか?この表現）するには
>p++,じゃないといけないんですよ。

ネタか？

>>351

下記のコードは違うでしょう？
>>329
>>332

while＝ネタ
でした。ボクが作った人工無能ちゃんです。
今後とも可愛がってあげてください。

>>346
あえてマジレスすると
char *aaa (char *p) {return ++p;}
も
char *aaa (char *p) {return p + 1;}
も同じ結果↓になるけど。
_aaa:
movl 4(%esp),%eax
incl %eax
ret
私が悪かったです。ごめんなさい。

>>348
コンピュータって言う言葉が、あいまいと言うことか ? それなら納得する
が、プロセッサを主語にするなというなら納得できないぞ。

コンパイラは、〜をポインタとして扱い、コードを生成する。プロセッサ
は、生成されたコードに従い単に実行するだけだ。

と言う風に使ってるからな。

内部的にはビットがたってるかたってないかだろ？
さっきからいってるけど、ポインタは、「その値をどう解釈するか」と見た場合に定義されるものじゃないか？
その値とは、ポインタのことじゃなくて、メモリの読み込み位置のビットのことね。

>>358
じゃあ、環境の違いです…
って…こんなレスをすることになるとは…

いろんな環境を考えていませんでした。
ごめんなさい。

ごめん。
>>360がつまり、俺の視点であり、主張。

>>348はwhileに言ったの。反省してるからよし

>>356
ゴメソ、アセンブラコードで違うから
とそうだという説明じゃ
分かんない。

本当にポインタ演算はインクリメントしか
ないの？
漏れの書いた*(p+1)はポインタ演算とは
呼ばない？

>>364
p,qがポインタなら
p+1 p-qもポインタ演算
*(p+1)も逆参照というポインタ演算
つーか適当な本読めよ

int *i = NULL;
int p = 0;

i = (int *)(p + 398);
とか書いてみる。

>>364
環境の違いで細かい違いが出るんですよ。
（もちろん、exe型は関係ないですが）

…ずっと前に勉強したんですが、
まさかと思い、考慮してませんでした。
(つかっていない記憶でしたので使うのが
＿怖かったというのもあります。)

>>367
もうおまえ、死ね！

>>365
>>346でそう書いてあったからだよ。

>>369
whileの書いた事なんて信用すんなよ。

>>367
環境の違いもクソも無い

機械語を直接プログラムを打つとき、ポインタ型は明示的に定義されてるの？

＞環境の違いで細かい違いが出るんですよ。
ネタ？

>>364

>>365
さんのいうとおり
適当な本を読まれたほうが確実です。
（僕と貴方のような環境の違い
＿についても書かれています）

今の僕に聞いても、そこらへんはうろおぼえでしょうし。

>>374
そんなに生き恥さらして何になるんだ？

>>374
＿（アンダーバー）は、VBでのレイアウトを整えるための記号？

>>374
も　し　か　し　て

　　＊　＊　＊　育　っ　た　環　境　の　違　い　＊　＊　＊

で　す　か　？

好意的に解釈すると、

while
↓
一身上の都合(両親の離婚、等)で中学中退
↓
（学力低下）
↓
「(ボクが理解できないのは育った)環境の違いです。（みなさん中学卒業できるなんてうらやましい）」

って事でいい？

俺は、俺の疑問に答えてもらえればそれでいい。

>>378
ｿﾚﾃﾞ（・∀・）ｲｲ!

>>376
一応マジレスしとくと、「継続行」を表す記号です。

>>354
ぷぷっ。煽りのつもりだったのか...、まあ本人がそう言うんだから良いか。

どう見ても、荒らしにしか見えないけどね。

(ﾟДﾟ)ﾊｧ?
痛いところつかれて反論のしようがなくて
脂汗流して全身から湯気を立ち上らせて
ﾌﾞﾊｧﾌﾞﾊｧ言いながら悔しがってるくせに
「環境の違いです」などと冷静を装いつつも
やっぱり頭が悪いから
全然意味不明で的はずれの文章しか書けない君は
さらに嘲笑されて悔しさのあまり
トンカチでバスの乗客に襲いかかる前に
職場のベルトコンベアに巻き込まれて
汚い汁と脂をまき散らしつつ
同僚の冷たい視線を浴びながら他界すればぁ？

おいおい、なんだかんだで今日は100レスよゆーで超えてるぞ。

↓元々はこういうスレなんだけどな

61 ：デフォルトの名無しさん ：02/09/03 08:22
定義は
　　(ある型のデータを持てる)変数、
　　の、場所をあらわすデータ(＝アドレス？)、
　　を、持てる変数(＝ポインタ)。
とかだよね。

「何らかの犬(＝データ)、
を、飼っている家(＝変数)、
の、住所(＝アドレス)、
を、書く欄(＝ポインタ)」

で、どうだ！

うちのシステムにバグ発見
return(p++); // ！p++ が実行されない！

p++
return p; // p++ が実行される

ポインタ演算については
p++; も p=p+1; も等価
環境に左右されない

以上
…うろ覚えの知識がないように基礎を復習します。
すいませんでした。現在まで調査作業してました。

>>386

p++
return p; // p++ が実行される


コンパイルできたら確かにバグだ。

>>386
多分実行されていると思うぞ。
p++はpを返してからpに1足すからな。
とりあえずpをstaticにして次回呼び出し時に値を見てみな。

>>387
その上の行でですよ

正しいこと言ってても >>383 には友達いないんだろうな...。

こりゃネタだな〜。

>>386
return (++p);
にしたら？
インクリメントされる前に戻されてしまうのでは？

>>388
本当だ…しらなかった。
ありがとうございます！
やった！赤っ恥かいたけど知識が増えたー！

もし単にpに1足した値を返せばよいだけなら、俺はreturn p+1;とするな。

なんかポインタって、しくみよりも文法で躓く人多いと思うんだけど。

＊ｐってのはｐを宣言しているのだと１００回言っても＊ｐだと思ってやがる。
コンパイルエラーが出たら適当に＊をとったり＆をつけたり・・・逝ってくれー

>>392
↓こうかけばいいんですねー
return ++p;

ちゃんと通りました！

ズッコケコテハン増員断固反対
ズッコケコテハン増員断固反対
ズッコケコテハン増員断固反対

>>395
int *という型のpを定義しているんだと言ってやれ。

>>392
お前も逝って吉

これならどうだ

#define __ptr *

int i, __ptr j;
char __ptr str;

>>399
ハァ？

>>395
long *p
↑よりも↓を使わせるようにしたらどうでしょうか？
long* p

>>388
実行されているかは、状況によるよ。最適化すると、ローカル変数なら
普通は '++' の分は無駄だから削除されちゃうよ。(static もしくは、
グローバル変数なら >>388 が言う通り。)

で、これとポインタってなんか関係あるの ? int でも、同じだと思う
が...。

>>402
それいいかも。
個人的にはlong *pが好きなんだけど(笑)

>>398
それはまずい。
「じゃあ int *p[10]; の p の型は？」
って聞かれる

ちなみに前置インクリメントをつかうのは
生まれてはじめてです…。

例：++c;

>>403
まあ最適化したらね。

ｽﾏｿ、勘違いだ。当然 global とか関数内の static の事かと思ってた。。。

とりあえず、
return には 前置インクリメント を使うようにします！

>>409
インクリメントせずに素直に+を使えよ。どうせ自動変数なんだろ？

>>409
お前はそんな知識で物知り顔してたのかと半万年

>>405
素直に、int * の配列って答えりゃいいと思うが..。

>>411
うっ…だってソフトウェアを組む際にいらないんですもん…
それにいままで僕が答えたのは全部基礎知識の範囲内です。
高度な事は答えてません。
…ぶっちぁけ、僕の取り掛かっている事で高度な事なんて
自分の作っているプログラムの処理アルゴリズムくらいです。

自然に

自分が作っているプログラムの処分アルゴリズム

に見えた

>>410
だね。ソース見てて、return ++p; なんかあったら、そのソース見る気が
激しく失せるよ。

基本的に、インクリメント＆デクリメントなんぞ使わない方がいい。

int twice (int x) {
  return (x *= 2);
}

>>416
＞return (x *= 2);
オマエモナー

whileって職業プログラマ？
もしそうなら、書き込んでる内容はネタだよね？

マジなら日本のソフトウェア産業の状況はこんなにもお寒いのか。

>>418
今年入社したのかもしれないじゃん。
未経験OKのところなんていくらでもあるし・・・

つーかこんなやつ居たら、

俺　が　辞　め　さ　せ　て　や　る

>>414
>>420
統一性があって書いた人が特定できるから
書式は変えたほうがいいですよ

ローカル変数として初期化された物なら、
そこに入っている情報は保持できないから。
毎回、その関数に入った時に、初期化されるからね。

そ、それくらいはわかりますぅ（泣）

それくらいもわからないのかとおもいましたぁ(泣)

>>422
いや、問題は、無用に使わなくなる変数を更新するという不自然さを、
短く書けるから、とかの萎える理由で正当化してるところだ

>>425
return ++p;
return p+1;

文字数なら同じだぞ(笑)

>>426
俺も書いてから気付いた。。。俺なら "p + 1" と書くから錯覚したらしい。

>>399
誰だろう？
浮いてる・・・

>>427
スペースをいれるくせをつけておくと *x/*y とかやった時にはまる可能性がなくなるらしいな(ﾜﾗ
まあ文字色を変えてくれるエディタを使っていれば問題はないんだけど。

>>428
そうか ? >>399 には、>>401 って言うレス ? が付いてるぞ。
どっちかって言うと、>>397 の方が浮いてる気が...。

>>428　どきっ
>>430　どきどきっ

>>425の前半に胴衣
レス一連を見ると自動変数を返しているだけで
それ以上なにもないのに、そのことで
なぜ深刻なバグがあるのだ？
関数内でmallocしていて
関数の呼出後freeする処理というのなら
まだわかるが、でもポインタののインクリメント
も必要ないだろうし、mallocもしてなさそうだし。

まあ、好意的に見ればだ、コンパイラの挙動を調べるのに夢中になって
異常なコードを書いてみたっていう感じか

>>433
なるへそ、433のことを踏まえて
もう一回読むと>>386のいうシステム
とは作成したプログラムのことではなく、
OSとかコンパイラのことか。

>>260-くらいから
面白いスレになってきたみたいだな。
なんか初心者やポインタにつまずいている
香具師の頭の中が見えてきたみたいだ。
以外と良スレになってきた。
やっぱコード等、具体的な材料（燃料？）がないと
いくら例えても分からないだろうな。
ただ、whileの言動は注意しないとな。

>>260
なんでポインタ配列がダブルポインタ(そもそもそんな言葉があるかどうか知らないが)なんだ？
ポインタへのポインタ(**)をダブルポインタと言うのならわかるけど。

>>260はよく推敲されたネタだろう。(ネタのような本当の話ってのもあるが)
ポインタと配列に関するほとんどの勘違いが盛り込まれているからな。

そしてその直後、while登場。このタイミングはあやしいが、
今の所ただ単に釣られただけのような気がする。

予想だが、ポインタ配列を扱うポインタだから
ポインタへのポインタと思ったの
じゃないのか？

ネタに1票
Cやポインタ知らないで、ここまで
書けるのはあやしい。
本当だとしても、燃料またはスレの
イメージ改善としての役割は十分
果たしたように思える。

ということはネタにマジレスしてしまったのか。
鬱だ飛び降りよう。

まだやってたの

くだらねっ

>>260は間違いだらけなのに、出力結果が（一般的な環境では）整っている、
という所がいかにも巧妙だ

>>260
long intと略さずに書く珍しい人なのね。

>>444
それをいうなら
unsigned long
の方がいいのでは。（アドレス値だから）

木構造を組み込もうとして始めはvectorの自己参照ポインタを
使おうと思ったのですが、できないので
class foo
{
...
foo *pParent;
foo **pChild;
...
};
としたんですが、vectorだと何でできんのですか？

age

>>446　ここはポインタの質問スレじゃないよ

　　　「ポインタ」

　　　それは

　　　「ストーカー」

　　　である。

ポインタはティムポ。
基本的には、オブジェクトを指しているものだが、何もさしていない場合もある。
それをブラブラティムポという。

ポインタのポインタという合わせ技もある
人はそれをtwin timtimと呼ぶ。

ポインタはマンポ
基本的には、オブジェクトを入れているものだが、何も入れてない場合もある。
それをガバガバマンポという。

type (*p)[];なら分かるが、
type *(p[]);だと意味不明
つーかpでないの？

>>452
それは、普通の変数の説明だと思われ。

>>453
type *(p[]);
↓
type* p[];

「ポインタ」
それは
「C言語最大の汚点」
である。

ポインタはプログラムそのもの
大抵うまくいくが、たまに(しょっちゅう？)バグる

>>456
「ポインタ周りの設計」でなくて？

>>457
滅多にﾊﾞｸﾞらねぇよ…。

ポインタは諸刃の剣

「ポインタは、それなりの機構用意しとけばバグ皆無」
なんかスローガンみたいだけど。

C的には、アドレスの先を要素でなく配列とみなすことができるってのがｲﾀｲ
せめて、「先を要素とみなすポインタ」と「先を配列とみなすポインタ」を
言語の上で区別すればバグが減る気がする。気がするだけだが

>>462
int array[10];

int* p = &array[5];

な時はどうします？
配列へのポインタと見なすか，変数へのポインタと見なすか。

>>461
そうなの？

>>463
んー書き方悪かった
「単独の変数へのポインタ」
「配列の要素(or 配列の先頭要素)へのポインタ」
というレベルの区別はできるんではないかという話

というより、隣接の領域への相対アクセスを許すか、許さないかという違い

char s[] = "abc";
char *p = &s[1];
char just *jp = &s[1];

... *p ... // アリ
... p[1] ... // アリ
... *jp ... // アリ
... jp[1] ... // ナシ

みたいな

>>466
justってのがそのためのキーワード?

そう。なんかそれくらいの修飾はあってもいいような気が・・・と

そりゃちょっとポインタの機能を弱くするような……

long a = 0xFF00FF00; // sizeof(long)==4

char* p = (char*)&a;
cout << p[0] << endl; // 1バイトずつ処理
cout << p[1] << endl; // 1バイトずつ処理
cout << p[2] << endl; // 1バイトずつ処理
cout << p[3] << endl; // 1バイトずつ処理


↑の例は「例えば」だよ。


でも，仮にjustが有ったとしても”Cだと”配列のインデックスを超えてアクセスしてしまう罠

おっと，取り敢えず”Cの”ポインタ変数の実装は糞ということでよろしいか？

お世辞にも良いとは言えないですな。

まあ、必ずアクセス禁止にできるわけはないけど、
APIの裏に隠蔽されたようなオブジェクトは結構守れると思う。

あと、バイト列の切り分けについては、別のシンプルで安全な方法を提供
するってのもいいのでないかと

おっと472＝462

つーかそれ参照じゃん>>466

>>474
あ。。。

*******************************終了[][][][][][][][][][][][][][][][]

Cの間接参照演算子 * が後置だったらよかったのに。の巻。

aa[2][3] : char; // 2次元配列
pa[3]* : char; // ポインタの配列
aa*[3] : char; // 配列(or 2次元配列の先頭配列)へのポインタ

void (*signal (int sig, void (*func) (int))) (int);
↓
signal (sig : int, func* (int) : void)* (int) : void;

signal // 関数
signal (..) // 引数をつけて呼ぶ
signal (..)* // 帰ってきたアドレスを参照する
signal (..)* (...) // それがまた関数なので呼ぶ
signal (..)* (...) : void // 戻り値はなし

・・・わかりやすい。(事にしてほしい)

流れに沿って代入も逆に。
void (*p) (int) = signal (...);
↓
signal (...) =: p* (int) : void;
気持ち悪いｗ

そうかこっちが自然かも
signal(...) =: p : *(int)void; // 参照・適用すると戻り値なし、という変数 p

まとめ
aa : [2][3]char; // 2次元配列
pa : [3]*char; // ポインタの配列
aa =: ap : *[3]char; // 配列(or 2次元配列の先頭配列)へのポインタ
signal : (sig : int, func : *(int)void)*(int)void;
signal(...) =: p : *(int)void; // 戻り値なくintをとる関数へのポインタ

命名「C flat」

Cのポインタに慣れた者にとっては激しく読みにくい…

(HL)

main : (argc : int,argv : **char)int {
  println ("Hello, C* world!");
  return 0;
}

ポインタ
　如きで偉そう
　　40代

main : (argc : int, argv : ** char) int { // 空白補正
  println ("Hello, C* world!");
  return 0;
}

int main (int argc, char argv**) { // 型名の後置はやりすぎか。これでいいか
  println ("Hello, C* world!");
  return 0;
}

>>486
argvの型が分かりにくい。

argvはcharポインタへのポインタなので

char** argv; // type identifer

と書く方が自然に見える。

char argv[]*
argv : []* char

ポインタの配列であることが一発でわかりますが、何かｗ
（配列要素 [] を間接参照 * すると、char が得られる、という順序）
まあ、そういう遊びなんでひとつ。。

うわっキモ

変数君とポインタ君。

変数君はポケットを持ってるよ。
でも体が弱くて自分じゃ遊びに行けないんだ。
何かをあげるとポケットに入れてるから
「今ポッケに何が入ってる？」って聞くと教えてくれるよ。

ポインタ君はポケットを持ってないんだ。
でもとっても元気で「○歩歩け！」って言うと言った歩数だけ歩くし、
住所を教えてあげれば、すぐにそこへとんでっちゃう。
それに自分の居るところの住所をいつでも分かるという特技があるんだよ。
とても良くできた地図でも持ってるのかな？

ポケットが無いから物をあげても「僕持てないよ！」って言うし
何を持ってるか聞いても「僕何も持ってないよ！」って答えるんだ。

だから、そんな時はこんな風に言ってあげて。
「今居るところに置いて良いよ」「今居るところに何がある？」

でもポインタ君も地面に物を置くのはあんまり好きじゃないから
同じところに変数君が居たら、こっそり変数君のポケットを使っちゃうんだ。
変数君の持ってる物と、ポインタ君の居るところにある物が
同じになっちゃうことがよくあのはこういう訳なんだ。

きもっ。

char* p // この * と
cout << *p ; // この * は

意味が違うだろ。

>>488
それだったら宣言では*も[]も()も前置な方が読みやすいかも。
変数を使うときは*も[]も()も後置で。

double(int)*[10] func; // intをとりdoubleを返す関数へのポインタ10個の配列
func[0] => double(int)*
func[0]* => double(int)
func[0]*(0) => double

どうも感覚に合わない。

char timpo,*small;
timpo = 0;
*small = 0; // なぜだめなんだ？


char* timpo,small;
timpo = small; // なぜだめなんだ？


char* timpo="small";
char* small;
small="Timpo"; //なぜだめなんだ

char *p;
ってのは、「p に * をつけると char が得られるような p」という、
使い方の例示になっているんだよ。

> char* timpo="small";
> char* small;
> small="Timpo"; //なぜだめなんだ
これは駄目じゃなくない？

>495
大丈夫みたいですね。勉強しはじめなのでｽﾏｿ。
ウキ━━━━━━━━━《ﾟДﾟ》━━━━━━━━━ッ!!!!!
マスマス、ワケワカンネッ!!(´・ω・`)ｼｮﾎﾞｰﾝ

これでどうYO!あってRU?

普通「ポインタ型の"変数"」と「ポインタ」のどちらも
単に「ポインタ」とよばれている。

> char timpo,*small;
> timpo = 0;
> *small = 0; // なぜだめなんだ？
timpoは「変数」、smallは「ポインタ型の"変数"」。
この三行ではsmallは有効な「ポインタ」を保持していないため
*（間接演算子）を使ってsmallの保持する「ポインタ」が指す領域に
値を格納することはできない。

> char* timpo,small;
> timpo = small; // なぜだめなんだ？
timpoは「ポインタ型の"変数"」、smallは「変数」、よって代入は不可。

&（アドレス演算子）を使い timpo = &small; とすれば
timpoにsmallの「ポインタ」が代入され、
timpoはsmallへの「ポインタ」を持った「ポインタ型の"変数"」となる。

> char* timpo="small";
> char* small;
> small="Timpo"; //なぜだめなんだ
可能。一行目のtimpoと三行目の"Timpo"は別物である。
timpoは「ポインタ型の"変数"」、"Timpo"は文字列リテラル。
文字列リテラルはメモリ上に固定的に配置され、式中では先頭へのポインタを返す。

よって三行目では「ポインタ型の"変数"」であるsmallに
"Timpo"の「ポインタ」が格納されることになる。
（printf( "small = %s", small ); の実行結果は small = Timpo ）

Ａはコピー機を持っている。
Ｂも必要なのだが、放って置くとＢもコピー機を買ってきそうなので、
ＡはＢに「ここにあるから使えれ」と教えてあげた。

コピー機（何でもいいけど）がデータ、「ここにあるから使えれ」がアドレス。
・・・・・・と知り合いに教えた事がある。これ、合ってる？

ある2ちゃんねらが言った。

　ポ　イ　ン　タ　は　テ　ィ　ム　テ　ィ　ム　

だと。

500　そろそろ誰かまとめて

ｽﾚをあんまり読んでないけど。
ﾒﾓﾘｰ読んだ値を
　 　1.：そのまま返す。
　 　2.：ｱﾄﾞﾚｽとして認識する。

こんなスレ読むだけムダ。
ムダムダムダァ。

>>498　なんか俺には難しい。そこまで複写機と親しくないからか

>>498
AとBが何に対応するか入れたほうが良い。

どこかで
田代風に書いてた人がいたよ。
変数をスカートにたとえてｗ

むかし、むかし。あるところに、お爺さんとお婆さんが住んでいました。
ある朝、いつものように、お爺さんは山へ芝狩りに、お婆さんは川へ洗濯へ行きました。

川でお婆さんが洗濯をしていると、
川上から大きな桃がどんぶらこ、どんぶらこと流れてきました。
お婆さんは何とかこの桃を手に入れようと、頑張りました。
・・・ダメでした。桃は、ゆっくりと川下へ流れて行きました。

日も暮れ、山から帰ってきたお爺さんに、お婆さんは川で起きた出来事を話しました。
「うまそうじゃった・・・」ガックリと膝をつき、うなだれるお婆さんに、お爺さんは言いました。
「それは残念だったのう。なに、桃が食いたきゃワシが山から取ってきてやるわい。」
お婆さんは答えず、まるで甲子園で負けたピッチャーのようにワナワナと震えています。
「のう婆さん。それより飯・・・」
おなかの空いたお爺さんは、空の鍋を心配そうに見つめています。
すると、お婆さんが顔を上げ、ぽつり　と言いました。
「・・・・・・まだ、間に合う。」
「え？」
「あの流れなら、まだ川を流れて居るじゃろう。」
「・・・・・・・・・。」
沈黙が家を包みました。ふくろうの声が、刻を刻みます。
その重圧にお爺さんが耐えられなくなった頃、お婆さんは言いました。
「・・・取って来い。」
「な、何をじゃ？」
「爺さん、桃ぉ・・・、取って来い。」
「え・・・　えぇ！？」

「じ、じゃが婆さん、それは昼間の話じゃろう？　いくらなんでも・・・」
驚くお爺さんをよそに、お婆さんはナタを持ち　ゆらり　と立ちあがりました。
「どっちがいい・・・」
問いかけるお婆さん。
「ど、どっちって何じゃ？」
聞き返すお爺さん。
「このナタにぶった切られるの。　桃と　てめぇと　どっちが良いんじゃ！？　あ゛！？」
すごむ　お婆さん。
「ひっ！？」
お爺さんピンチ。
「さぁ、どっちなんじゃ！？」
追い詰めるお婆さん。
「ひー！？」
お爺さんピンチ。
「”ひー” じゃわかんねぇじゃろがぁぁぁ！！」
着物を脱ぎ捨て、叫ぶお婆さん。
「ひーーーーー！！」
お爺さんピンチ。
「桃かぁぁぁぁぁぁ！！　それともぉぉぉぉ、てめぇかぁぁぁぁぁあ！！」
うねる垂れ乳。
「ひ、ひーーーーーーーーッ！！」
お爺さんｐ

めでたしめでたし

目出足し目出足し

グローバル.c:
　struct Female Ａ子;


君.c:
　struct Female *君の彼女 = &Ａ子;
　　　　　　：
　　　　　　：
　　友達に紹介(君の彼女);　　// 紹介しただけ
　　君の彼女->デート();　　　// フォールト発生！


友達.c:
　struct Female *友達の彼女 = NULL;

　友達に紹介(struct Female *kano)
　{
　　友達の彼女 = kano;　　// お前のモノは俺のモノ
　　　　　　：
　　　　　　：(*kano を貪る)
　　　　　　：
　　Free(kano);　　　　　 // 遠くへ捨てる
　}

>>495
494じゃないけどさ。
「char *pは，p に * をつけると char が得られるような p」って説明よく見るし
意味的には正しいけど，決して分かりやすいとは思わないな。
だって，「*pはchar型」とは言わないだろう？
「pはchar*型」って言わないかい？
だとしたら，「char* p（charへのポインタ型であるp）」の方が分かりやすいと思うんだが。どうか？

ふう。


ここはObserverパターンにして簡潔にっと。

ポインタなんて機械語知ってれば
何も難しくない

>>513
ｱｾﾝﾌﾞﾗ間違い？

>514
アセンブラって何か知ってる？

>>515
あなたの方こそ大丈夫？（ｗ

アセンブリ言語をアセンブラでアセンブルする。
機械語とアセンブラはあまりに性質が違うもので、、

アセンブリ言語と機械語ってそんなに厳密にわけなきゃいかんほど違うものか？
ほぼ1対1で翻訳できるんだから同義と考えて差し支えないと思うが。

Z80でマシン語を直接DATA文に放り込んでたあの頃が懐かしいな

　ま　た　>>519　み　た　い　な　お　爺　さ　ん　が　出　て　き　た　よ　！


お前らはhttp://pc.2ch.net/i4004/に篭ってろヴァカ

>>505
こわがりすぎー

知障の息子ですので皆さん温かく見守ってやってください。

>>518
一度ハンドアセンブルしてみなさい。
違いが判るから。

>>511
いいけど、そすっと配列や関数ポインタが絡むとワケワカになる。

詰まるところ、入門書の説明で理解できないヤツには
どんな喩え方をしてやっても無駄、ということだな。

ビデオライブラリに例えるなら
ビデオテープ：メモリ
ポインタ：テープの位置と何本組かの情報ファイル。
ポインタのポインタ：上記のファイルのインデックス。
参照・操作処理：
　ポインタを使う：ビデオライブラリのテープをそのまま見る。
　　　　　　　　　マスタテープを編集
　値渡し：ダビングして見る。
　　　　　ダビングテープを編集
ってのはどうかな？

>>524
配列はポインタのシンタックスシュガーみたいなもんだろ？

int array[10];

arrya[3] = *(array+sizeof(int)*3)

関数ポインタが絡むとは？

>>527
みたいなものではない。
シンタックスシュガーって言いたいだけですか？

C++で初心者を脱したあたりのヤシに
　struct size{ int x, y; };
　int size::*p = &size::x;
を使ってるコードのデバグさせて混乱に陥らせている私は
逝ってよしでしょうか？

>>531
何の意味があるの？
何をそれで表現しようとしてるの？あなたは。
怒り？悲しみ？喜怒哀楽？

俺はＣを始めて半年経って、やっとポインターが分かってきた。俺には
ポインターより、複雑な論理演算子マジック(?)の方が難しい。でも
未だにファイル入出力のポインターが理解できない！mallocって何だ？

ポインタなんか初めから素通りで理解できたから、こんなスレは必要なし。
mallocは知ってるけど、それを使わずにプログラム作れてたらからまだ使ったことはない。

> ファイル入出力のポインター

確かに解ってなさそうだ

>>527
配列とポインタを混同するなって言う人が見たら嘆くね。

Cはポインタが使えるのが魅力だな。
VBにはポインタがないから、回りくどいコーディングが必要になるので不便だ。

>>537
同じ理由でJavaもC#も回りくどいコーディングが必要になるってか？
ウソつくな。

ポインタとか配列とかぜんぜんいしきしてませんがなにか？

配列とポインタを混同するのは、配列の操作の一部にポインタを
使わなければ出来ない処理があるというCの制限のせい。
すべての配列の操作を配列として扱うことが出来る言語では混同しない。

>>534
小さな配列しか使ったことがないらしい。
漏れもないから、malloc不要。

>配列とポインタを混同するのは、配列の操作の一部にポインタを
>使わなければ出来ない処理があるというCの制限のせい。

まあいいけど。ほんとは間違い。

間違いというだけならオウムにも出来る。

誰か、ここに、ﾌﾟｯっていうAA貼っといて。

例えば、a[i]を*(a+i)と表現できるように、配列として[]を使わなくても
Ｃはポインタ演算子を使えば何でも出来るね。ポインタ＞配列だ！
それに自己参照構造体を使えばリスト構造も作れるし・・・。

配列と参照(とオプションで文字列型)があればポインタなんかいりませんよ。
唯一の例外は固定のアドレスを直接参照する必要があるOSやドライバを作るときだけでしょう。
アセンブラを使えばなんでも出来る。ゆえにアセンブラ＞Ｃ＋＋(他すべて)なんて
アフォみたいなこと言ってはいけません。

>>544
(´,_ゝ`)ﾌﾟｯ
死ねあふぉ。

>>536
だから「みたいなもん」って書いてあるんだろう？
＃sizeofの結果が違うとか言いたいんですよね？

>>548
だから「みたいなものではない」って書いてあるんだろうｗ？

>>532
>逝ってよしでしょうか？
こんな意地悪は逝ってよしです(w

>>532
>何の意味があるの？
ちゃんと勉強しようね、メンバポインタって物だよ。
イベントドリブン式のプログラムを書くときの強力な武器になる。
デリゲートが良いと感じたのならアタックしてみれ。

メモリは棚です
変数は引出しです
変数の引出しはそのまま使えば中身が見れます
前に＆をつけると引き出し番号が分かります
ポインタも引き出しですが,変数とは振る舞いが違います
ポインタの引出しはそのまま使うと他の変数の引き出し番号が分かります
前に＊をつけると他の変数の中身が見れます
前に＆をつけるとポインタの引き出し自体の引き出し番号が分かります
そして配列は連続した引出しです
最後に参照はポインタの引出しと変数の引出しを中でくっつけたものです

・・・あまり例えになってませんねごめんなさい

>>550
>イベントドリブン式のプログラムを書くときの強力な武器になる。
はあ？

>>552 != >>532

>>553
おいおい。

>>554
おいおい。

>>556
おいおい。

オヨヨ。

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

書けちゃいました．．．

ポインタとぼいんちゃんは似てる

えっと
552 == 554 == 600

>>545
> 例えば、a[i]を*(a+i)と表現できるように、配列として[]を使わなくても
> Ｃはポインタ演算子を使えば何でも出来るね。ポインタ＞配列だ！
> それに自己参照構造体を使えばリスト構造も作れるし・・・。

言いたいことはわかるが、それって「goto 文 (と if 文) 使えばどんな制御構造も実現できるから、goto > while/do/switch だ。」と言ってんのとあまり変わらないぞ。
何でもできるから偉いと言うわけじゃないことぐらい、理解しろよ。

>例えば、a[i]を*(a+i)と表現できるように、配列として[]を使わなくても
>Ｃはポインタ演算子を使えば何でも出来るね。ポインタ＞配列だ！

ということはポインタとして表されていて、配列で表せないものがあるとい
う事だよね？
あまり詳しくないんでイメージできない、誰か例を挙げてくれんかな。

だからキモイっつーの。
おえ

配列とポインタをなんか勘違いしてませんか？

int a[10]; // sizeof(int)*10バイト確保

a[3] // ＝ *(a+3)

配列はメモリを確保してポインタでアクセスできるんだろ。
比較するようなもんじゃないよ…

普通に抽斗の例で解りやすいと思う。
抽斗には番号以外に名前がついてる。
そんで、抽斗あけたら中に紙が入ってて、「X番の引き出しをあけれ」とか書いてるのがポインタ用抽斗。

>>566
> 普通に抽斗の例で解りやすいと思う。

動きとしては合ってるけど、何でそんな引出しが必要なのかがわからん。

>>563
> ということはポインタとして表されていて、配列で表せないものがあるとい
> う事だよね？

本当にできないのは >>546 に書いてある H/W アドレスとかだな。
あと、C/C++ では動的配列だな。
それ以外の奴は、効率を考えなければ大概配列で何とかなる。(ここでいう効率は、プログラムの作成時と実行時の両方を含むよ。)

配列は大昔、長屋とか、マンションとかで例えて教えたことあるけど、ポインタは
一般的な物として例えるのが難しいね…

封筒の中に紙が入っていて、紙に本当の場所が書いてあるという感じか。
もしくは転送郵便。

なぜこの形式のほうが効率が良いかというと、そういうものだから仕方が無い（ｗ

>>569
> なぜこの形式のほうが効率が良いかというと、そういうものだから仕方が無い（ｗ

頼むよ、こんなアフォな書き込みしかできないんなら、でてくんな。

きっと>>569は一生懸命考えたんだよ。名言だと思って。
苦笑して放置してやれ。

機械語書かせりゃ勝手に理解すんだろ？
ポインタだろうがlongだろうが変数は変数だ。
それ以上でも以下でもない。

それより_int64ってなんでつか？

ポインタで悩む脳味噌がある事が信じられない

□　→　■実体
ポインタ

□　→　□　→　■実体
　　　　ポインタ
ポインタ

□　→　□　→　□　→　■実体
ポインタ　　　　ポインタ
　　　　ポインタ

■実体
■　
■←□(p--後の位置)
■←□ポインタp
■←□(p++後の位置)
■　ポインタは、ポインタが指す実体のサイズにあわせて加減算される

構造体に含まれるポインタ
┌─┐
│□→■(■型のポインタと、■型の実体)
│□→■
└─┘

構造体に含まれ、構造体を指すポインタ
┌─┐
│□→┌─┐
│■││□│(構造体型のポインタと、構造体の実体)
└─┘│■│
　　　└─┘

ずれタ。氏のう。

構造体に含まれるポインタによる、シンプル（かつ無意味）なツリー構造
　　　　┌─┐
　　　　│□→ NULL （指すものが何も無い場合、NULL値であると呼ばれる）
┌─┐│□→
│□→└─┘
│□→┌─┐
└─┘│□→
　　　　│□→ この先にはさらに構造体を追加できあます
　　　　└─┘
データが無いツリーは、通常つくられることはない
でもサンプルとしては、イイ！

mallocで取得したmemory領域を、
freeはどうやって知るんですせぅか？

char *ptr;
long addr;

ptr = malloc(1028);
addr = ptr;

として、addrを所持して
べつのところで
char *ptr2 = addr;

free(ptr2);

とかしていたら、
そのうちにセグメントエラーというようなことに
なりますのでしょうか？

すみません。

タイトルを見て、

ぽいんたーを上手に　"教えて"　みよう

だと読み違えました。
ポッカリミスでした。　てへっ。

>>580
いや、俺のほうこそスレ違いだたーよ。
誤解招くようなコピペなんかして悪かったな。

ぽいんたーは、
本の隅っこの方によくついてるあれ...
なんていったっけ...?

とにかく、あれみたいなもん。

ISBNコードならそんな気がしないでもない。

ポインタって、あれ、テレビのチャンネル番号でしょ。２チャンとか。
実際の局名はテレ東とか日テレとかだけど、んなもんいちいち覚えてらんねぇ。

オッス！おいら、「ぽいん太」

ポインタで悩む脳味噌がある事が信じられない

>>586
お前の人生なんてポインタだよ。

　　　！！！ポインタで悩む脳味噌がある事が信じられない！！！


あるならそれは猿以下だな。

じじいきもっ

猿発見>>589

制御ジジィが陣取るスレって、ここですか？

ためになるから適当に続けてくらさい

小生はアセンブラのＺ８０を３０年間使い続けておる。

いいか？若造ども。コンピュータの基本はアセンブラなんじゃよ。
お前たち、ハードの内部で何が起きてるかわかってるのか？最近ジャブだのパーラだの、色々な言語が流行ってるみたいだが、あんなチャラチャラしたもんクソじゃ。
次から次へと出てきてすたれるのじゃ。Ｃのポインタがわからん奴はウチの会社に来なはれ。みっちりＺ８０で３年間修行させてやる！
修行を終えたお前さんは、もう地に足の付いた一流のエンジニアの仲間入りじゃ。

連絡先を教えて下さい。

ダルメシアンに似ている

ポインタってのはよお、いわば死体なんだよな。
で、死体は魂が入らないと動かないだろ。
魂が入ってはじめて人間と呼べるわけだ。
ポインタを渡すってことは、この死体をやりとりするわけ。
で、アドレス演算子&は、人間から魂を取り出す作業。つまり死体にする作業だっ・・・！
*は死体に魂を吹き込む作業。つまり人間にするってこと・・・！
int a;
aは人間だ。
&aは死体。
int* b;
bは死体。
*bは人間。
a=b 人間は死体ではないからエラーっ・・・！
a=*b　*bは人間だから人間＝人間なのでOK・・・！単純明快・・・っ！！

クズども・・・これでわからなければ・・・一生おまえたちは負け組み・・！！生きていてもどうしようもないカスだ・・・！ゴミ以下の・・・・！！

つまらんなぁ。

ポインタってのはよお、いわばビルゲイツなんだよな。
で、ビルゲイツは金が入らないと動かないだろ。
金が入ってはじめて人間と呼べるわけだ。
ポインタを渡すってことは、このビルゲイツをやりとりするわけ。
で、アドレス演算子&は、人間から金を取り出す作業。つまりビルゲイツにする作業だっ・・・！
*はビルゲイツに金を吹き込む作業。つまり人間にするってこと・・・！
int a;
aは人間だ。
&aはビルゲイツ。
int* b;
bはビルゲイツ。
*bは人間。
a=b 人間はビルゲイツではないからエラーっ・・・！
a=*b　*bは人間だから人間＝人間なのでOK・・・！単純明快・・・っ！！

クズども・・・これでわからなければ・・・一生おまえたちは負け組み・・！！生きていてもどうしようもないカスだ・・・！ゴミ以下の・・・・！！

つまらんなぁ。

初めてメモリというものを見た。
左手の水平線から右手の水平線まで隙間なく尻が並んでいた。
圧巻する光景だ。
ふと気付くと向こうからポインタが伸びてきた。
ポインタは長く伸びた腕の形をしていて、その先では手が結ばれている。
ただ人差し指だけはしっかりと前に突き出していて、まるで何かを貫こうと
しているかのようである。
次の瞬間ポインタはすらすら伸びると狙っていたかのようにある尻の中に
吸い込まれていった。
ズブッ「…うぐぅ」
茶色く染まった太い人差し指が印象的な出来事だった。

ポインタはエロサイトの連番画像へのリンク(ｱﾄﾞﾚｽ自体をインクリメント可能)

>>600
コピペそれともオリジナル？
オリジナルだったらやるねえ。

>>600=>>602
自演ウザイよ。

602 だけど 600 じゃないよ、まっ、どうでもいいけど

>>1-604
ポインタがわからないから面白くない

>>604
ふ〜〜〜ん、じゃあんたは >>600 は「やるねえ」と思ってるわけだ、「自演」ならまだ理解できるけど、想像を絶する奴だな。

ポインタはURLのようなモノだ

600は幻想的だね

尻が出てこなければの話だが。

いや尻にしているところがいいのだ。
こういうファンタジーを嗜むことができるような数奇者に
なるべし。

つまらないと思うなら、お前もっと凄いの書いてみろよ >>606

ところでこの前つまらんことで議論になったんだが、
みなさんはメモリをイメージする時、頭の中は横に並んでる？それとも縦？

こんな感じか↓
□□□□□□□□□□□□□□・・・

↓こんな感じか
□
□
□
□
□
□
□
・
・
・

自分は、最近は２次元こんな感じだなあ、
使っているマシンのアライメントの問題もあるんだけど。
□□□□
□□□□
□□□□
・
・

配列だと要素1個を□として□□□□□□□□□□□□□□だな。
で□そのものは別にイメージする。
構造体1個だと定義のimageで
□
□□
□□□□□□□□
・
・
・
みたいな感じだ。

1バイト1アドレスとしてイメージしています。

脳内では横
書くときは縦かな

流れにぜんぜん関係なくて悪いんだけど、
さっき自動販売機でジュース買ったら、
これってポインタかもって....
配列もあるし,,,,
頭悪くてすまん。。。。。

>>610
つまらんと判断する能力と、優れたものを書く能力は違うと言うことぐらい理解しろ、ヴァカ。

たらいまわし（ｗ

>>596
なーんか、わかりかけたような気がするんだけど・・・・

できれば、char版で作り直してほすぃ。。。。
おながいしますです。

>>611
漏れは
□□□□□□□□□□□□□□□□□□□□□□□□□
だね。よく資格試験の解説書は２次元で書いてあるが、それではわかり難い。

漏れの恩師が教えてくれたメモリのイメージっつうのがあって、それは、
メモリ内は一直線に並んだ廊下にウサギ小屋が無数に並んでいて、その各
オリには番号が順にふってある。その番号のドアを開けたとき、白いウサギが
飛び出してくるか、黒いウサギが飛び出してくるかっていう仕組みだ。
一つののウサギを指し示すとき、ウサギの名前を書いたプレートを立てるか、
オリにつけられた番号で示すかの話。

こう考えればポインタ演算もわかり易いと思う。
ポインタが難しいと悩むお前ら、メモリはただのウサギ小屋だ。

>>620
そこまでせな理解できんかったんかい！

>>620
ええはなしやなー。で、どっちのウサギが美味かった？

Z80のIX,IY

暗がりの中、オレはあてもなくその場に立ち尽くしていた。

思い出せない...

そこがどこなのか...
なぜそこに炒るのか...
おれはだれなのか...

おれには記憶がなかった...。

ただ、首にかけられた札に書かれた文字、

"kokyaku_type"

それがおれの名前だと言うことだけはわかった。

ほかにも記号と変な数字が書かれていた。
意味はわからないが、とにかくおれは歩き出した。

歩き出して気づいたが、まわりにも大勢人がいた。
皆、無表情なまま立ち尽くしている。
そして、そいつらの首には札がさげられていた。
さらに歩いていくと、おれの札に書かれた数字と同じ場所におれとよく似たやつが立っていた。声をかけようと近づいてみると、そいつもおれの方に近づいてきた。
おれは怖くなっておもわず声をかけたがへんじはない。
無表情のまま、こちらに近づいてくる。
そして...!

そいつはおれの所へくると、おれのケツの穴に吸い込まれていった。

...おれのなかに記憶が蘇った。
そう、おれは変数４。
すなわち、kokyaku_type == 4だったんだ!

>>71
そうですがなにか?

>>625
明後日の方向にレスなさってますか？

Java 以外は糞!

age

俺javaでAWT、Swing、JMFから一通りできるから、自身もってＣにも挑戦しようと
思ったんだけど今一ポインタが理解できない。
具体的に

関数呼び出し時の変数操作ができる。
メモリのアドレスを保持している。(&で取り出し)

くらいの理解しかできないよ。
どう役に立つのかを是非教えてください。
正直C++のクラス概念の方が理解するのに楽だった。

イテレータ使ってループで処理→スライサーで野菜を裁断
ポインタでぶん回し→ナイフで野菜切る
関数にオブジェクトを参照渡し→鍋に入れて火をかける
関数にポインタ渡し→ナイフに刺して火にくべる
戻り値を参照で受け取る→フォークで口に運ぶ
戻り値をポインタで受け取る→ナイフで刺して食う
つーか腹減った。

"変数 x" と言ったときに "変数の名前 x" と "変数 xの保持する値" が
プログラム上で明確に区別されてないのがわかりにくい原因じゃないかな
x = 1 と x == 1 で x の意味が違うでしょ
そのへんの区別がちゃんとできればポインタもわかると思うよ

　　あるネット関連会社の社長は、「いずれにしても2ちゃんねるは
資金が底をつけば終わり。あまり知られていないことだが、
2ちゃんねる内部関係者によると今、大手通信会社系が調査費名目で資金提供している。
だが、それが止まれば続けてはいけないだろう」と証言する。
2ちゃんねるが判決によって力を失った場合、資金提供の打ち切りも予想される。
http://ascii24.com/news/reading/causebooks/2002/07/01/636911-000.html

　以下、別の記事のキャッシュ http://memo2ch.tripod.co.jp/article.html
　2ちゃんねるに近いあるインターネット関連会社の社長は、2ちゃんねるの幹部から得
た話として証言する。「2ちゃんねるは、運営者や幹部などがそれぞれ別々に会社を
作りカネの流れを見え難くしているが、実際の資金源は複数の大手通信会社系からの
調査費名目のカネ。月額で計約700万円と言い、年間にすれば1億円近く。額はともあ
れ、これは通信会社系的には、ぼう大なトラフィックを調査すると言う表向きの理由
が一応は立つ。自社系に都合の悪い書き込みがされた時に優先的に削除してもらうこ
とも期待している」と前置きし「通信会社系の削除の期待も含めて、2ちゃんねるは
総会屋と同じになっている」と言うのだ。
　その具体的な理由として社長は、こう話す。「2ちゃんねるはボランティアの削除人
が書き込みをチェックして、好ましくない書き込みを一所懸命削除している、という
ことになっているが、あれはウソ。削除人には給料が支払われ、その給料の原資と
なっているのが、まずいことを書き込まれた企業が削除要求とともに渡す裏金。これ
はまさに、総会屋の構図そのものだ。これまで裁判になっているのは金額で折り合え
なかったり、裏金を出さない強い態度の企業とだけだ」

>>631
すばらスィ！
確かにそのような具体例を挙げて意味を明確にすれば、
初心者にも理解しやすくなるかもしれませんねえ。

>>631
x の意味は同じだが・・・？

>>629
Javaで言うところのオブジェクトは全てポインタなの。
基本型はなぜか値コピーしとるだろ？
Cでは、全ての変数が(型に係わらず)コピーして使うように
統一されているわけ。
Javaのように使うためにはポインタが必須なわけよ。

このあたり、Javaのほうがややこしくないか？

>>638
ポインタの話とは遠くなるが。
あの Smalltalk でも代入はメソッド呼び出しじゃなくて構文だよ。
文脈上の解釈で、シンボルとしての x と、オブジェクトとしての x という違いがある。

>>640
x = 1 と x == 1 で x の意味が違う？
両方ともオブジェクトとしてのxだろ？

>>638
Cを想定したコード、というのを明記してなかったので混乱させたかも。
x = 1 の場合の x は "x という変数の名前" (つまりアドレス相当)
x == 1 の場合の x は "x という変数の保持する値そのもの"
という違いがあります。わからなかったらMLの代入構文を見るといいよ。

>>642
int x ;
x = 1 ;
x == 1 ; ← 真だろ？
&x == x だとでも？

どうしてわかってくれないかなあ。
x = 1 と x == 1 でわからないなら
x = x の左辺値と右辺値の違いでもいいよ。
ちなみにMLの代入の型は 'a ref * 'a -> unit。

>>644
ごめん。マジでわかんね。
左辺値と右辺値の違いが
>>631 そのへんの区別がちゃんとできればポインタもわかると思うよ
につながるのか・・・・
ポインタも左辺値になりうるが・・・？

　 ∧＿∧ 　　
　（　´∀｀）＜　ぬるぽ

アセンブラの勉強した方が早い気がする。

K&R の書き方がよくないのもあるな。
int *ptr;
ではなく
int* ptr;
とするべきだ。K&R方式は型の名前と変数の名前がごっちゃになってるからな。

>>648
お前大丈夫か！？
int *ptr -> C
int* ptr -> C++

>>648

int* i,j ; // 罠

Cの宣言は糞だな

>>649
ﾌﾟｯ。仕様書嫁。

>>650
もっともスマートな解決法は別の行に書く事だが、
「本当のワンライナー」級の解決方法としては
int* i; int* j;
だな。どちらにしても , で区切って一度にすませようとするなという事だ。

効率わる

watcom のサンプルコードとかは
int * i;
だったな

ぽいんた、ポインタ、ポインタカード



ゲッツ！

>>653
意味と表現を近づける為のコストとしては安いと思うけど？
「型 名前」の大原則を破ると意味と表現が離れるからね。

>>656
カンマで区切るのにはそれなりに意味がある。
配列と、その操作用のポインタとかでは
型を合わせていることを明示するために
int d[100],*p ;
とか書いたりもできるし。

*の位置にはあまり拘らず、どんな書き方でもちゃんと
読めるようになっとくのが正解。

ところで、656はなぜ
「型 名前」にこだわる？

配列宣言とかって int[100] d ; じゃないし。
さらにいえば「配列へのポインタ」とか宣言できる？

>>657
C/C++ の組込みの配列の書式は頭の痛い問題…というか、C はもう使わないし、
C++ では滅多に組込み配列は使わないのでいいんだけどね。

配列に関しては Java と C# がどういう書式をサポートしているかを考えてください。
C → Java → C# の順で時代の流れです。

> ところで、656はなぜ
> 「型 名前」にこだわる？
逆に何故こだわらないのかを問いたいです。
物事を複雑にする理由がない時は単純な形にしておくべきです。
例えば、以下の例はコンパイルが通らないような気がしますが
int**&** pprppVal; は int へのポインタへのポインタへの参照のポインタへのポインタの pprppVal という変数と読み下せますが、
int **&**pprppVal; は int の(注:ここで意味が一度途切れる)ポインタへのポインタへの参照のポインタへのポインタの pprppVal (ここで最初が int だったという事をもう一度思い出さなければいけない) という変数。となってしまい、

型 名前 のルールの方が直感的だからです。
C++ では関数ポインタと配列以外の全ての要素でこのルールは一定に作用します。
(逆にいえば関数ポインタと配列は正直頭の痛い問題です。)

>>658
後者は後者の読み方があるということが言いたかっただけ。

文法のとおりに読むことが「直感的ではない」と言い切る
のには流石に抵抗あるぞ。

int * p ;
int * (p) ;

int *p ;
int (*p) ;

int* p ;
(int*) p ;

さて、仲間はずれはどれ？

関数ポインタや配列が読めない時点で656氏の読み方は
破綻していると考えるのも自然かと。
どちらが優れているかの議論は置いといても、
違うスタンスで書かれたソースをうまく読めないのは辛かろう。

> さて、仲間はずれはどれ？
これは卑怯な問題だと思う。変数宣言が ( で始まるようにはなってないんだから。

> 関数ポインタや配列が読めない時点で656氏の読み方は
> 破綻していると考えるのも自然かと。
関数ポインタの書式はああするべきではなかったと
カーニハン博士自身が書いている(たしかプログラミング作法だったと、違ったらｽﾏｿ)
配列に関しては上記 >>658 の通り、Java で任意、C# で強制された
表記法がより直感的だったと考えるのが適切でしょう。

私も別に「型 名前」を強制はしてません。
ただ、ポインタ理解のハードルの中に、あの type *var という変則的な
(私にとっては変則的だというのはいままでの説明で納得していただけたかと思います。)
記法があるのではないか？と考えているだけです。

問題のお返しに、私の持論の方の正当性を実証したいと思います。
(ただの意地なので、別にケンカを売っているわけではないです。)

typedef struct{ int v1, int v2 } st;
// ここは中立的に真ん中に書いてみました。
st * src = new st();
st * dst;
// 三つのうちで意図する動作が行われるのはどれ？
dst = (st)src;
dst = (st*)src;
dst = (st)*src;

IP記録実験
http://qb.2ch.net/test/read.cgi/accuse/1042013605/

1 名前：ひろゆき ◆3SHRUNYAXA ＠どうやら管理人 ★ 投稿日：03/01/08 17:13 ID:???
そんなわけで、qbサーバでIPの記録実験をはじめましたー。

27 名前：心得をよく読みましょう 投稿日：03/01/08 17:20 ID:yL/kYdMc
SETTING.TXT管轄でないということは全鯖導入を視野に、か？

38 名前：ひろゆき ◆3SHRUNYAXA 投稿日：03/01/08 17:22 ID:rLfxQ17l
>>27
鋭いです。

73 名前：ひろゆき ◆3SHRUNYAXA 投稿日：03/01/08 17:27 ID:rLfxQ17l
＞ところで、IPが抜かれて何か今までと変わることってあるのでしょうか？
・今までより、サーバが重くなる。
・裁判所や警察からの照会があった場合にはIPを提出することがある。

ネタスレを立てるにしても９割の悪意と１割の良心を心がけます

●持ちは串刺せてもあんまり関係ないですか？

ダイアルUＰで繋ぐ度に違う俺は安全でしょうか？
　　　　　　　　　　　　　　

======2==C==H======================================================

　　　　　　　　　２ちゃんねるのお勧めな話題と
　　　　　ネットでの面白い出来事を配送したいと思ってます。。。

===============================読者数： 138720人　発行日：2003/1/9

年末年始ボケがそろそろ収まり始めた今日このごろのひろゆきです。

そんなわけで、年末に予告したIP記録ですが実験を開始しています。

「２ちゃんねる20030107」
こんな感じで各掲示板の最下部に日付が入ってるんですが、
20030107以降になってるところはログ記録実験中ですー。

んじゃ！

────────────────────────Age2ch─
■この書き込みは、Age2chを使って配信されています。
────────────────────────────
Keep your thread alive !
http://pc3.2ch.net/test/read.cgi/software/1041952901/l50
────────────────────────────

http://www.zdnet.co.jp/news/0301/09/njbt_07.html

毎度のzdnetね。

>>593
同意。いろんな状況があるけど、結局たどり着くところはそこだと思う。

スレに即した質問したのに返ってこない

アメリカの場合を語るならクリッパーとかそれ以前までさかのぼって話せないと
たぶん意味のある議論にはならない。

あと、とりあえず法解釈の問題ではないと思う。法政策の問題。

>>984
つーか>>976のリンク先に一回だけ名前出てたじゃん。
なんかのミスかもしれないけど

書き込まないのが一番という事で。　　　　　　　　　　　　　　　

>>・圧縮やなんかでdat落ちした分を省いた=若干落ちてます。正解です。
１つしか落ちてないけど？
１つなのに若干って。笑

挙手による多数決は最大の愚行！！ 　　　　　　　　　　　　　　　
匿名性が失われ自分に反対する者が誰かは
わかるのに小数派には反論さえ許されない
最悪のシステム！！

もしも常に特定の人物と
意見が対立し　常に片方だけが意思を
抹殺されたら…

それが続けば必ず集団は決裂する！！

>>407
はい　よろしくお願いします

マンコとかきまくることは法律でも問題ないからIPなどとってくれ！！

新しいテーマをだして書き込み募集したいんですけどどうしたらいいの？

======2==C==H======================================================

　　　　　　　　　２ちゃんねるのお勧めな話題と
　　　　　ネットでの面白い出来事を配送したいと思ってます。。。

===============================読者数： 139038人　発行日：2003/1/10

なにやら、連日メルマガだしてるひろゆきです。

そんなわけで、ログ記録実験ですが、いちいちサーバ指定するのが面倒なので、
全部のサーバに入れてみました。

重くなって落ちたりしてもご愛嬌ってことで。。。

んじゃ！

────────────────────────Age2ch─
■この書き込みは、Age2chを使って配信されています。
────────────────────────────
Keep your thread alive !
http://pc3.2ch.net/test/read.cgi/software/1041952901/l50
────────────────────────────

ほんとだ

＜血液型A型の一般的な特徴＞（見せかけの優しさ・もっともらしさ（偽善）に騙されるな！）
●とにかく気が小さい(神経質、臆病、二言目には「世間」、了見が狭い）
●他人に異常に干渉する（しかも好戦的・ファイト満々でキモイ、自己中心）
●自尊心が異常に強く、自分が馬鹿にされると怒るくせに平気で他人を馬鹿にしようとする
（ただし、相手を表面的・形式的にしか判断できず(早合点・誤解の名人)、実際にはたいてい、内面的・実質的に負けている）
●「常識、常識」と口うるさいが、実はA型の常識はピントがズレまくっている（日本の常識は世界の非常識）
●権力、強者（警察、暴走族…ｅｔｃ）に弱く、弱者には威張り散らす（強い者に弱く、弱い者には強い）
●あら探しだけは名人級（例え10の長所があってもほめることをせず、たった１つの短所を見つけてはけなす）
●基本的に悲観主義でマイナス思考に支配されているため、性格がうっとうしい（根暗）
●一人では何もできない（群れでしか行動できないヘタレ）
●少数派の異質、異文化を排斥する(差別主義者、狭量）
●集団によるいじめのパイオニア＆天才(陰湿＆陰険）
●悪口、陰口が大好き（Ａ型が３人寄れば他人の悪口、裏表が激しい）
●他人からどう見られているか、体裁をいつも気にしている（「世間体命」、「〜みたい」とよく言う）
●自分の感情をうまく表現できず、コミュニケーション能力に乏しい（同じことを何度も言う、知障）
●表面上意気投合しているようでも、腹は各自バラバラで融通が利かず、頑固(本当は個性・アク強い）
●人を信じられず、疑い深い（自分自身裏表が激しいため、他人に対してもそう思う）
●自ら好んでストイックな生活をし、ストレスを溜めておきながら、他人に猛烈に嫉妬する（不合理な馬鹿）
●執念深く、粘着でしつこい（「一生恨みます」タイプ）
●自分に甘く他人に厳しい（自分のことは棚に上げてまず他人を責める。しかも冷酷）
●男は、女々しいあるいは女の腐ったみたいな考えのやつが多い(他人をけなして相対的に自分の立場を引き上げようとする等）


それと、Ｏ♀はエコヒイキきつくて、冷酷だからな。

Ａ♂の異質排除×Ｏ♀の冷酷＝差別・いじめ　とあいなる。

新しいテーマをだして書き込み募集したいんですけどどうしたらいいの？

674 名前：ひろゆき ◆3SHRUNYAXA 投稿日：03/01/08 23:36 ID:1BXnvYvY
通報する人は、IPはあるので管理者に連絡してくれれば、
「捜査関係事項照会書で照会しますよー」って言ってたて伝えてくださいー。

217 名前：ひろゆき ◆3SHRUNYAXA [] 投稿日：03/01/08 17:49 ID:rLfxQ17l
　　　一定期間でログは消しますです。
249 名前：ひろゆき ◆3SHRUNYAXA [] 投稿日：03/01/08 17:52 ID:rLfxQ17l
　　　＞荒らしとか犯罪のためなの？
　　　そす。

246 名前：心得をよく読みましょう[] 投稿日：03/01/08 17:52 ID:BH998yxV
　　　>ひろゆき
　　　俺のお気に入りのスレとか荒されてるんだがそういうのにも有効？

257 名前：ひろゆき ◆3SHRUNYAXA [] 投稿日：03/01/08 17:53 ID:rLfxQ17l
　　　　　　いずれは。

312 ：ひろゆき ◆3SHRUNYAXA ：03/01/10 19:59 ID:jWxHxvti
全部にいれてみた。

確かに小一時間はオカシカッタ

ポインタって何ですか?

打ち間違えのザサイにケチつけんなよ！
名誉毀損でうったえるからな！

ネオむぎを超えるわけない
犯人が１７歳以下なら話は別だが

中国の漬け物ですか？(^_^;)

IT ITって大騒ぎ　　多分9割は楽しんで騒いでいる

気にしないでいいと思います。

これから毎日集団下校になるのかな

二審も一審を支持。これに対して上告しようにも、
刑事訴訟と同様、自由に上告できるってもんでもないのです。
民事訴訟法312条 （上告の理由） 1項
「上告は、判決に憲法の解釈の誤りがあること
その他憲法の違反があることを理由とするときに、することができる。」
http://www.m-net.ne.jp/~doba/goto/hon.htm

ようするに上告しても今の制度では100％無駄。
これで完全終了ってことか。

きねん

、実際に名誉毀損を照明するのは係争になってからの話で
係争前の通告として現行法では 内容証明つき郵便が認知されている。

お前らに丁寧に教えてやるけど
どーせならば 現行法で裁けない理由を羅列して潰した方が得だぞ。
（それでも現行法で裁かれるんだけどな）

誤爆にみせかけたコピペ荒らしっすよ

（＾＾）

よんど

ふぉんど

（＾＾）

（＾＾）

C とアセンブラに辛うじて残ってます。

　

ポインタは配列

ポインタはデーターを場所を示すデーター

ポインタはヲタ

>>703
関数を指すポインタもあるのですが...。
(まあ、関数のコードもデータと言えんことはないけどな。)

ポインタって難しいワ

「俺の友達の友達が言ってたんだけど・・・」
っていう会話は「俺の友達の友達」が
実は自分のことを指しているかもしれない
つまり、直接「俺」といってしまうとヤバイのであえて
「俺の友達の友達が・・・」と言う事によって
「俺」が保護される

話し相手に「俺」を隠匿することになるわけだ

これは参照なのか？ポインタなのか？それともそもそもこの説明は間違ってるのか？

お前の女は俺の物

お前は俺の物

俺はお前の物

気持ちわるい...

ケツの穴に指

奥歯をガタ

http://www.mashimo.com/pointer.html

アソコ

おっぱいぽいんぽいん

ポインタの長所を述べよ

>>717
参照と違ってNULLを保持出来る

JavaやC#の参照はNULLを保持できるのでCのポインタの長所が含まれているわけですな。

ちんぽいんた

ぼいんﾀﾝ

C++ でも、別に null オブジェクト作りゃええやん。
まぁ、いちいち作らなあかんわけやけども。

矢印でしょ

　　 '(''--'　　　　　　　　　　　　　　　　　　　　 ヽ
　　 ヽ,　　　　　　　　　　　　　　　　　　　　　　　ヽ　　 い　 メ free
　.<'',,,　　　　　　　　　　 ,-,　　/', , ,　　　　　　 　 |
　　ゝ　　　　/　 ／　　 （（　／-''／ ./ , , ;: ,,　　　|　 　う　　モ　　す
　　ヽ; :　　 （　 （''--'''''＼,''-'　 ''''''''~'''~　ヽ ;;　　 .|
　　 .＼ ,...,--'二二二二>　.丶ヽ二二二二-;:/''ヽ|　　 ん　　リ　 れ
　　　 ..||　|,　'ｧ'ｲo;;-ヽ丶　 　,~~-''''{;o';> |' |:..''| |/
　　　　|| (';ヽ　-,,.....- ｧﾉ::|　 .|ヽ　---...-'.　.|:::::| .|　 だ　 を　 ば
　　　　.l:.| l::|　,.-''''''''　,/::|　　　　　~ ~''-z　|::l/ /
　　　　ヽヽ::|;　　　　　 |;:::|　　　　　　　　　.l::/ /　　　　な　　解　
　　　　 .ヽ;:::|　　　　　　,l;:''''　,　　　　　 　 l /./|
　　　　　 ＼:|　　　　　 （:::, ρ）　　　　　　l// ﾉ　　　　？　　放　
　　　　　　|;:::;l　　　　　　　　　　　　　　　/;:::::/
　　　　　　;:::::ﾄ、　　　==ﾆﾆﾆﾆ==　　　 /.|　.|　　　　　 　　す　　
　　　　 .lｼ',;::::|＼　　　　　　　　　　　　/　.|　.l,,.）
　　　　　ゞ)　.|　ヽ　　　　''＝''''''　　　/　　|　,,,/　　　　　　　　る
　　　　　 ）　 .|　 ;;＼　　　　　　　　ｱl　　 .|　,<
　　　,,...-( (　 |　 'l;;;l.＼　　　　　／ / ./　 l　　)=-,,_　　　 　と
,,..-'''’　　　'＼l　　.;;　　’''---'''~　　;　;　　l;ﾉ,;;/　　 ’''- ,_
　　　　　　　　|　　 ;;　　　　　　　　;　 ;　　　　　　　　　　　’'-

ポインタ＝ホームレス

（＾＾）

保守・　　

　　 ∧＿∧
　　（　　＾＾ ）＜ ぬるぽ（＾＾）

　　 ∧＿∧
　　（　　＾＾ ）＜ ぬるぽ（＾＾）

>>728-729
ヌルポインタ？

今だ！5番ゲットォォｫｫ！！
￣￣￣￣￣∨￣￣￣　　　　　　　(´´
　　　　 ∧∧　　　）　　　　　　(´⌒(´
　　⊂（ﾟДﾟ⊂⌒｀つ≡≡≡(´⌒;;;≡≡≡
　　　　　　 ￣￣　 (´⌒(´⌒;;
　　　　　　ｽﾞｻﾞｰｰｰｰｰｯ

ome

━―━―━―━―━―━―━―━―━[JR山崎駅（＾＾）]━―━―━―━―━―━―━―━―━―

C++でさぁ、

class Obj{};
ってクラスがあって、

Obj* array[3][10];
って宣言したら、

array[0][0] = new Obj();
array[0][1] = new Obj();
・・・
array[2][9] = new Obj();
って感じでいいのけ？

ポインタの配列がよーわからん。

>>734
それでオッケー。
ただし、

> array[0][0] = new Obj();
> array[0][1] = new Obj();
> ・・・
> array[2][9] = new Obj();

なんて全部並べるなら、配列なんか使う必要なし。

　　　 　∧＿∧
ﾋﾟｭ.ｰ　(　　＾＾ ） ＜これからも僕を応援して下さいね（＾＾）。
　　＝〔~∪￣￣〕
　　＝ ◎――◎ 　　　　　　　　　　　　　　　　　　　　　山崎渉

>>160
禿同

話変わるけど、携帯ゲーム機"プレイステーションポータブル(PSP)

　このPSPは、新規格UMD(ユニバーサルメディアディスク)というディスクを利用しており、そのサイズは直径6cmととても小さい(CDの半分程度)。 容量は1.8GBとなっている。
画面は4.5インチのTFT液晶で、480px x 272px(16:9)。MPEG4の再生やポリゴンも表示可能。外部端子として、USB2.0とメモリースティックコネクタが用意されているという。

この際、スク・エニもGBAからPSPに乗り換えたらどうでしょう。スク・エニの場合、PSPの方が実力を出しやすいような気がするんですが。
任天堂が携帯ゲーム機で圧倒的なシェアをもってるなら、スク・エニがそれを崩してみるのもおもしろいですし。かつて、PS人気の引き金となったFF７のように。

整数の配列へのポインタを返す関数へのポインタをメンバに持つ構造体へのポインタを持つクラスへのポインタを返す関数へのポインタを持つ共用体とか

　__∧＿∧_
　|（　　＾＾ ）|　＜寝るぽ（＾＾）
　|＼⌒⌒⌒＼
　＼ |⌒⌒⌒~|　　　　　　　　　山崎渉
　　 ~￣￣￣￣

（＾＾）

a

　　　 (⌒V⌒)
　　　│ ＾ ＾ │＜これからも僕を応援して下さいね（＾＾）。
　　⊂|　　　　|つ
　　　（＿）（＿）　　　　　　　　　　　　　　　　　　　　　　山崎パン

ポインタはアドレスを操作する。

みんなメチャクチャ書いてるねぇ・・・

ポインタは、「ポイントする者」、つまり「位置を指し示す者」の事。

プログラミングにおいて、ポインタは「オブジェクトの位置を保持するオブジェクト」。
オブジェクトっつうのは、変数だったり関数だったり、要はメモリ上に展開される「何か」。
その位置を示すオブジェクトがポインタ。
ポインタは大抵変数として実現するので、ポインタ自身もまたオブジェクトなのよ。
だから「ポインタのポインタ」なんて事が出来るわけね。

さて、上では便宜上「メモリ上に展開」と書いたが、高級言語を使っている場合、それは必ずしもメモリであるとは限らない。
ページングすれば HD上に展開されてしまうし、CPUのキャッシュに入る事もある。
高級言語でプログラミングするという事は、「オブジェクトが実際にはどこにあるか？」を隠蔽する、という事だ。

だから、ポインタはメモリアドレスを指す、というのは、限定的には合っているが厳密には合ってない。
オブジェクトのアドレスを指す、と言えば、ちょっとはマシになる（メモリという言葉を使わない）、かな。

マジンガーＺにでてきたな

ポン太

ポインタは、オブジェクトのアドレスを格納するオブジェクトです

>>745
上手に例えてよｗ

平屋建ての巨大なホテルがあって、部屋数が数億ある。
部屋には、それぞれ00000001号室から99999999号室まで部屋番号が
付いている。
さらに、各部屋には電球が８つ取り付けてある。
変数を宣言すると、ランダムにその変数のバイト数だけ連続した部屋が確保される。
変数に値を代入すると、確保した部屋の電球を使って、その変数のデータを保持する。
変数に＆をつけると、確保した部屋のうち一番最初の部屋の部屋番号を返す。
部屋番号がxなら、*xは部屋に入っているデータを返す。
また、部屋番号xにデータを入れたければ、*x=aのように。
*xを左辺において代入する。
部屋番号は「ポインタ変数型」の変数に入れる。
ただし、部屋番号だけでは何部屋使っているのかわからないので、
ポインタ変数型にはその部屋に入ってるデータの型名も
指定するようになっている。使っている部屋数がわかるように。

>>750
読むだけで疲れる。
例えるなら、エロく例えろ。

使い捨て携帯の電話番号みたいなものじゃない？

おっぱいがミサイルのやつか・・・

問題。
int32は4バイトである。
(1)ポインタint32型(*i32)のアドレスをインクリメント(i32++)すると元から何バイト進むか？
(2)ポインタint32型のアドレスをインクリメントする。(i32++)
　 このとき、中身(*i32)はインクリメントする前の値より1だけ多いあたいであるといえるか。(int32 i32_2=*i32)
(3)また、char型(*ch)のポインタでアドレスをインクリメントするとき、(ch++)
　 int32型のポインタをインクリメントしたものと同じ結果を出すには
　 何回インクリメントしなければよいか。
(4)[問.2]と同様に、[問.3]でインクリメントしたあと、その中身(*ch)は
　 インクリメントした回数と同じだけ増えたものといえるか。
(5)そしてそれはなぜ？
(Extra)Pentiumシリーズは今日も32ビットである。
　 　 これint型が4バイト(=32ビット)なのはなぜか。

＃僕はたとえるなら、「スライドするもの」とたとえるかな。
＃映写機のフィルムはchar型の大きさで記録されている。とか。
＃4画面だとint32で2画面だとshort。
＃ややこしいかな・・・。映写機なんて最近聞かないし。

//テストプログラム
#include <stdio.h>
int main(){
int *i32,i32_2;//ポインタと変数を用意
char *ch=(char*)i32;//何を代入して初期化しているでしょう？？
//------
i32_2=(*i32);
i32++;
if((i32_2+1) == (*i32) ){
puts("(i32_2+1) == (*i32)");
}else{
puts("(i32_2+1) != (*i32)");
}
puts("---<*i32>---");
printf("元のアドレス[%d] 今のアドレス[%d]\n",(i32-1),(i32));
printf("さっきの値[%d] 今の値[%d]\n",i32_2,(*i32));
puts("---<*ch >---");
printf("元のアドレス[%d] 先のアドレス[%d]\n",ch,(ch+1));
printf("元の値[%d] 先の値[%d]\n",(*ch),(*(ch+1)) );
return 0;
}
上のプログラムはポインタの中身は書き換えていないので実行してもマシンが飛んだりすることはありません。（でもテスト以外では、やらないで！）
実行するときは、VCはリリースビルドしてください。ほかでは試してないです。warningは今回だけ無視して良いです。
なお、上のソースで(*i32)=(なんかの値) とかやるとPCの寿命が減ります。これがやってはいけないバグです。なので、やめましょう。(理由は考えてみよう）

>>754
回答例
(1)4バイト。
(2)いえない。インクリメントで値(中身)をいじっているわけではないから。
(3)4回。char型のポインタはインクリメントすると1バイト進みます。4バイト進めるためには4回インクリメントする。
(4)いえない。問.2と同じで中身に対しては何も関与してない。
(5)ポインタはアドレスをいじることで移動する物であって、対象が固定的ではないから。
(extra)CPUの1本のレジスタが一回に扱える数の最大値が基本的に4バイト(32ビット)だから。
　 　 　Pentiumは一回に8バイト(64ビット)扱えるレジスタを持っているが、使用の実態は32bitレジスタを2本専有だったりするので汎用とは言いがたい。
　 　 　ちなみに計算するときは、intを使うのがCPU的に扱いやすくて早いといわれている。他の型があるのは省メモリーのため。等。

>>755
char型を初期化しているのは、アドレスで初期化しています。
つまり、ポインタを移動させているのです。

あと、書き込み可能な領域とは、自分専用に与えられた領域を指します。
ポインタは領域の間を自由に飛ぶことができます。が！
むやみに中立地帯を自分のエゴで書き換えると、ろくでもないことになります。やめましょう。

荒らしっぽくなってしまって申し訳ない。

>>749
スレ主旨とはズレた書き込みで申し訳なかったが、「例え」はどうしても真実と
ズレた事を書かなきゃならないんで、まずは正論から書いてみた。

携帯電話番号の話をしてくれた人がいたんで、それを使って例えてみよう。

携帯電話を持っている人＝各種オブジェクト
携帯電話＝ポインタ
携帯電話番号＝ポインタ値

地上（メモリとか）のいろんな場所に散らばって存在している「携帯を持つ人」は、
それ自身なんらかの状態を持っていて、それはさまざまだ。
で、その「携帯を持つ人」を指定・特定するには、その人の所在地を言ってみたり、
その人の容姿を言ってみたり、いろいろな方法があると思う。

（ａ）もしその人が携帯を持っているなら（＝ポインタがあるなら）、携帯の電話番号（ポインタ値）を指定するだけで、その人が特定できる。
（ｂ）携帯を持っていない人（＝ポインタがない）は、そういう方法では特定できない。

Ｃ言語だと、以下のようになる。

（ａ）
int a; // 誰か : オブジェクトa
int* a_ptr; // 「誰か」用の携帯 : オブジェクトa用のポインタ
a_ptr = &a; // 「誰か」に携帯を持たせる : ポインタにアドレスを代入
// 以降、a_ptrを使うだけで、aの位置が得られるし、aそのものを使ってもよい

（ｂ）
int a; // 誰か : オブジェクトa
// ポインタは無いので、aそのものを扱う「しか」ないし、aの位置は分からない

ポインタｯﾃﾄﾞｺﾃﾞｳｯﾃﾙﾉ

>>1
ウルトラ警備隊の車

>758
文具屋かな？替えの電池もついでに買っておけよ

レーザーポインターを上手に例えてみよう

知人などの目に一瞬当てて驚かせる小道具。

ゴレンジャーの女隊員

クラスの宣言や継承なんか、ポインタ指定してるみたいなイメージがする。

>>761 レーザーポインター「で」例えてみた。

大会があり、参加者(人)を変数とする。
レーザーポインターをもった人をポインタとする。(人なので変数でもある)
ゼッケンをメモリアドレスとする。

人が参加する際に(変数を確保する際)、ゼッケン(メモリアドレス)が割り当てられる。

ポインタを代入する行為は、特定の人物のゼッケンの番号を覚えるということである。
ポインタから参照する行為は、覚えた人に向けてレーザーポインターで光を当て、
指し示すということである。

class ポインタ : public アドレス{
　public:
　　ポインタ operator ++();
　　ポインタ operator --();
}

class アドレス : public 整数 {
　public:
　　operator &();
　　operator *();
}

　皆！！大事な事を忘れてないか１？
　お前らが書きこんでる先はなんだ？

　スレだろ！！

　スレの中に並んでるのは何だ？次元は？
１次元状にレスが並んでるだろうが、
よく考えてみろコレは、メモリー上と同じではないか！！
と言う事は、レスを変数 or Bitに例えれば2ちゃんねらーに分かりやすい(・∀・)<ｲｲ

と言う事でスレを使った説明１つ考えてみた

2ｃｈでは基本的にスレッドに書き込めるレスは1000である。
その為">>"の先に書く数字は1000未満の値を入れる事になる。
と言う事はあおるAAのテンプレ↓を作ろうと思うと4文字分のスペースを">>"の後に入れて作ればずれないAAができる。

　　　　　　∧＿∧　 　 　　∧＿∧
　　　　　_（　´∀｀）　　　　（´∀｀　）
　 三(⌒), 　　　ノ⊃　　　 （　>>1　） 　
　　　 ￣/　/)　 ）　　　　　 |　|　　|
　　　 . 〈＿）＼_）　 　　　 （__（_＿_）


それと同じように、メモリ上ではアドレスは0xFFFFFFFFまである。
これを見ると、１バイトはFFなので４バイトあればメモリ上すべての位置をカバーできる訳だ、その為いかなる型で宣言しようとポインタは4バイトなのである。
ではなぜポインタに型を宣言するか？それを説明するとだいぶ長レスになるので後者に任せヒントだけ書いておくとする。

long Matrix[40];
char *Pointer = (char*)(void*)Matrix;
こうすると１バイトずつ扱える。
長文レスｽﾏｿ。