Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.lang.c > #92033 > unrolled thread
| Started by | eva galois <eva.galois@yandex.ru> |
|---|---|
| First post | 2016-08-09 19:37 -0400 |
| Last post | 2016-08-10 08:19 -0700 |
| Articles | 20 on this page of 387 — 27 participants |
Back to article view | Back to comp.lang.c
Difference between these pointer syntaxes eva galois <eva.galois@yandex.ru> - 2016-08-09 19:37 -0400
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-10 01:12 +0100
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-09 23:57 -0700
Re: Difference between these pointer syntaxes mark.bluemel@gmail.com - 2016-08-10 00:29 -0700
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-10 20:50 +0100
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-10 15:54 -0700
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-11 01:20 +0100
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-10 18:01 -0700
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-11 07:40 -0700
Re: Difference between these pointer syntaxes Ike Naar <ike@iceland.freeshell.org> - 2016-08-11 22:43 +0000
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-10 11:51 +0100
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-10 08:11 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-10 17:13 +0100
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-10 20:57 +0100
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-10 21:21 +0100
Re: Difference between these pointer syntaxes jameskuyper@verizon.net - 2016-08-10 14:38 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-10 23:16 +0100
Re: Difference between these pointer syntaxes jameskuyper@verizon.net - 2016-08-10 20:19 -0700
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-11 01:36 +0100
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-11 10:49 +0100
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-11 11:46 +0100
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-11 13:09 +0100
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-11 15:45 +0100
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-11 16:46 +0100
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-11 19:44 +0100
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-11 18:58 +0100
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-12 01:13 +0100
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-12 11:18 +0100
Re: Difference between these pointer syntaxes Ike Naar <ike@iceland.freeshell.org> - 2016-08-12 16:28 +0000
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-12 18:51 +0100
Re: Difference between these pointer syntaxes Ike Naar <ike@iceland.freeshell.org> - 2016-08-12 18:18 +0000
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-12 11:31 -0700
Re: Difference between these pointer syntaxes Ike Naar <ike@iceland.freeshell.org> - 2016-08-12 19:30 +0000
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-12 20:44 +0100
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-12 14:32 -0700
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-12 23:03 +0100
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-12 22:46 -0700
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-12 12:37 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-12 21:07 +0100
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-12 13:34 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-12 22:12 +0100
Re: Difference between these pointer syntaxes Melzzzzz <mel@zzzzz.com> - 2016-08-12 23:24 +0200
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-13 00:59 +0100
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-13 11:28 +0100
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-13 03:56 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-13 12:52 +0100
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-13 17:34 +0100
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-13 09:44 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-13 18:35 +0100
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-13 11:21 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-15 12:35 +0100
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-15 15:10 +0100
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-15 17:07 +0100
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-15 10:03 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-15 17:26 +0100
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-15 11:42 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-15 19:04 +0100
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-15 12:27 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-15 20:04 +0100
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-15 13:32 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-15 21:32 +0100
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-15 14:50 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-15 22:38 +0100
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-15 16:03 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-16 00:32 +0100
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-15 17:57 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-16 01:28 +0100
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-15 19:13 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-16 11:01 +0100
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-16 08:35 -0700
Re: Difference between these pointer syntaxes fir <profesor.fir@gmail.com> - 2016-08-16 07:29 -0700
Re: Difference between these pointer syntaxes already5chosen@yahoo.com - 2016-08-16 10:40 -0700
Re: Difference between these pointer syntaxes jameskuyper@verizon.net - 2016-08-16 10:48 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-16 12:21 -0700
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-16 12:19 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-16 14:03 -0700
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-16 13:14 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-16 21:48 +0100
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-16 14:14 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-16 15:22 -0700
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-16 14:46 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-16 16:41 -0700
Re: Difference between these pointer syntaxes Les Cargill <lcargill99@comcast.com> - 2016-08-17 08:44 -0500
Re: Difference between these pointer syntaxes James Kuyper <jameskuyper@verizon.net> - 2016-08-17 10:12 -0400
Re: Difference between these pointer syntaxes Les Cargill <lcargill99@comcast.com> - 2016-08-17 10:38 -0500
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-17 10:45 -0700
Re: Difference between these pointer syntaxes Les Cargill <lcargill99@comcast.com> - 2016-08-17 17:06 -0500
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-17 17:06 -0700
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-17 09:58 -0700
Re: Difference between these pointer syntaxes Les Cargill <lcargill99@comcast.com> - 2016-08-17 16:54 -0500
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-17 09:59 -0700
Re: Difference between these pointer syntaxes Jean-Marc Bourguet <jm@bourguet.org> - 2016-08-17 19:41 +0200
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-17 13:03 -0700
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-17 11:45 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-17 13:10 -0700
Re: Difference between these pointer syntaxes Jean-Marc Bourguet <jm@bourguet.org> - 2016-08-17 23:01 +0200
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-17 21:09 +0100
Re: Difference between these pointer syntaxes Les Cargill <lcargill99@comcast.com> - 2016-08-17 17:16 -0500
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-17 17:20 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-18 00:04 +0100
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-17 18:01 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-18 01:03 +0100
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-17 19:10 -0700
Re: Difference between these pointer syntaxes Jean-Marc Bourguet <jm@bourguet.org> - 2016-08-18 11:11 +0200
Re: Difference between these pointer syntaxes Les Cargill <lcargill99@comcast.com> - 2016-08-18 09:40 -0500
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-18 11:25 -0700
Re: Difference between these pointer syntaxes Les Cargill <lcargill99@comcast.com> - 2016-08-18 12:51 -0500
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-18 13:22 -0700
Re: Difference between these pointer syntaxes Tim Rentsch <txr@alumni.caltech.edu> - 2016-08-19 00:20 -0700
Re: Difference between these pointer syntaxes Les Cargill <lcargill99@comcast.com> - 2016-08-19 17:41 -0500
Re: Difference between these pointer syntaxes Tim Rentsch <txr@alumni.caltech.edu> - 2016-08-20 00:17 -0700
Re: Difference between these pointer syntaxes Les Cargill <lcargill99@comcast.com> - 2016-08-20 13:43 -0500
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-20 21:00 +0100
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-20 16:00 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-21 00:52 +0100
Re: Difference between these pointer syntaxes fir <profesor.fir@gmail.com> - 2016-08-21 13:04 -0700
Re: Difference between these pointer syntaxes Tim Rentsch <txr@alumni.caltech.edu> - 2016-08-25 18:06 -0700
Re: Difference between these pointer syntaxes James Kuyper <jameskuyper@verizon.net> - 2016-08-26 07:31 -0400
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-26 14:25 +0100
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-26 06:36 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-26 15:37 +0100
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-26 07:59 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-26 09:07 -0700
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-26 09:22 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-26 11:22 -0700
Re: Difference between these pointer syntaxes Jerry Stuckle <jstucklex@attglobal.net> - 2016-08-26 11:21 -0400
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-26 08:37 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-26 09:46 -0700
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-26 09:23 -0700
Re: Difference between these pointer syntaxes Jerry Stuckle <jstucklex@attglobal.net> - 2016-08-26 12:52 -0400
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-26 10:50 -0700
Re: Difference between these pointer syntaxes Richard Heathfield <rjh@cpax.org.uk> - 2016-08-26 17:46 +0100
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-26 10:38 -0700
Re: Difference between these pointer syntaxes Jerry Stuckle <jstucklex@attglobal.net> - 2016-08-26 14:05 -0400
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-26 12:01 -0700
Re: Difference between these pointer syntaxes Jerry Stuckle <jstucklex@attglobal.net> - 2016-08-26 15:12 -0400
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-26 12:48 -0700
Re: Difference between these pointer syntaxes Jerry Stuckle <jstucklex@attglobal.net> - 2016-08-26 15:55 -0400
Re: Difference between these pointer syntaxes Richard Heathfield <rjh@cpax.org.uk> - 2016-08-26 21:02 +0100
otRe: Difference between these pointer syntaxes Jerry Stuckle <jstucklex@attglobal.net> - 2016-08-26 16:27 -0400
Re: otRe: Difference between these pointer syntaxes Richard Heathfield <rjh@cpax.org.uk> - 2016-08-26 22:20 +0100
Re: otRe: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-26 15:15 -0700
Re: otRe: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-26 17:01 -0700
Re: otRe: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-26 16:45 -0700
Re: otRe: Difference between these pointer syntaxes Jerry Stuckle <jstucklex@attglobal.net> - 2016-08-26 20:32 -0400
Re: otRe: Difference between these pointer syntaxes Richard Heathfield <rjh@cpax.org.uk> - 2016-08-27 03:09 +0100
Re: otRe: Difference between these pointer syntaxes Jerry Stuckle <jstucklex@attglobal.net> - 2016-08-26 22:32 -0400
Re: otRe: Difference between these pointer syntaxes Richard Heathfield <rjh@cpax.org.uk> - 2016-08-27 04:07 +0100
Re: otRe: Difference between these pointer syntaxes James Kuyper <jameskuyper@verizon.net> - 2016-08-27 00:24 -0400
Re: otRe: Difference between these pointer syntaxes Richard Heathfield <rjh@cpax.org.uk> - 2016-08-27 07:03 +0100
Re: otRe: Difference between these pointer syntaxes "James R. Kuyper" <jameskuyper@verizon.net> - 2016-08-27 12:34 -0400
Re: otRe: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-27 11:46 -0700
Re: otRe: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-27 20:04 -0700
Re: otRe: Difference between these pointer syntaxes Tim Rentsch <txr@alumni.caltech.edu> - 2016-08-27 20:25 -0700
Re: otRe: Difference between these pointer syntaxes Joe Pfeiffer <pfeiffer@cs.nmsu.edu> - 2016-08-27 21:32 -0600
Re: otRe: Difference between these pointer syntaxes Tim Rentsch <txr@alumni.caltech.edu> - 2016-08-27 20:42 -0700
Re: otRe: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-27 20:54 -0700
Re: otRe: Difference between these pointer syntaxes Lew Pitcher <lew.pitcher@digitalfreehold.ca> - 2016-08-27 23:58 -0400
Re: otRe: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-27 22:53 -0700
Re: otRe: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-27 23:29 -0700
Re: otRe: Difference between these pointer syntaxes Tim Rentsch <txr@alumni.caltech.edu> - 2016-09-01 08:21 -0700
Re: otRe: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-27 19:27 +0100
Re: otRe: Difference between these pointer syntaxes "James R. Kuyper" <jameskuyper@verizon.net> - 2016-08-27 14:46 -0400
Re: otRe: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-27 11:45 +0100
Re: otRe: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-27 04:47 -0700
Re: otRe: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-27 12:26 -0700
Re: otRe: Difference between these pointer syntaxes Richard Heathfield <rjh@cpax.org.uk> - 2016-08-27 13:06 +0100
Re: otRe: Difference between these pointer syntaxes "James R. Kuyper" <jameskuyper@verizon.net> - 2016-08-27 13:59 -0400
Re: otRe: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-27 11:52 -0700
Re: otRe: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-27 19:31 +0100
Re: otRe: Difference between these pointer syntaxes jameskuyper@verizon.net - 2016-08-27 13:47 -0700
Re: otRe: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-27 22:49 +0100
Re: otRe: Difference between these pointer syntaxes jameskuyper@verizon.net - 2016-08-27 15:07 -0700
Re: otRe: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-29 11:11 -0700
Re: otRe: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-27 15:57 -0700
Re: otRe: Difference between these pointer syntaxes Jerry Stuckle <jstucklex@attglobal.net> - 2016-08-27 20:50 -0400
Re: otRe: Difference between these pointer syntaxes Jerry Stuckle <jstucklex@attglobal.net> - 2016-08-27 20:45 -0400
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-26 21:18 +0100
Re: Difference between these pointer syntaxes James Kuyper <jameskuyper@verizon.net> - 2016-08-27 00:20 -0400
Re: Difference between these pointer syntaxes James Kuyper <jameskuyper@verizon.net> - 2016-08-27 00:27 -0400
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-26 17:01 +0100
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-26 19:50 +0100
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-26 21:30 +0100
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-26 22:11 +0100
Re: Difference between these pointer syntaxes James Kuyper <jameskuyper@verizon.net> - 2016-08-26 23:42 -0400
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-26 21:15 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-27 11:37 +0100
Re: Difference between these pointer syntaxes jameskuyper@verizon.net - 2016-08-27 10:47 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-27 12:20 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-27 12:07 -0700
Re: Difference between these pointer syntaxes "James R. Kuyper" <jameskuyper@verizon.net> - 2016-08-27 14:52 -0400
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-27 21:20 +0100
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-27 14:18 -0700
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-27 23:14 +0100
Re: Difference between these pointer syntaxes Tim Rentsch <txr@alumni.caltech.edu> - 2016-08-27 20:06 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-27 23:37 -0700
Re: Difference between these pointer syntaxes Tim Rentsch <txr@alumni.caltech.edu> - 2016-08-30 08:51 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-16 20:36 +0100
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-16 14:10 -0700
Re: Difference between these pointer syntaxes Tim Rentsch <txr@alumni.caltech.edu> - 2016-08-19 00:59 -0700
Re: Difference between these pointer syntaxes Les Cargill <lcargill99@comcast.com> - 2016-08-19 17:53 -0500
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-19 18:25 -0700
Re: Difference between these pointer syntaxes Les Cargill <lcargill99@comcast.com> - 2016-08-19 20:14 -0500
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-20 14:37 +0100
Re: Difference between these pointer syntaxes Les Cargill <lcargill99@comcast.com> - 2016-08-20 13:27 -0500
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-20 20:30 +0100
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-20 15:30 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-20 15:48 +0100
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-20 17:12 +0100
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-20 22:20 +0100
Re: Difference between these pointer syntaxes Les Cargill <lcargill99@comcast.com> - 2016-08-20 13:31 -0500
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-20 15:02 -0700
Re: Difference between these pointer syntaxes Tim Rentsch <txr@alumni.caltech.edu> - 2016-08-19 17:26 -0700
Re: Difference between these pointer syntaxes Les Cargill <lcargill99@comcast.com> - 2016-08-19 19:47 -0500
Re: Difference between these pointer syntaxes fir <profesor.fir@gmail.com> - 2016-08-16 15:09 -0700
Re: Difference between these pointer syntaxes fir <profesor.fir@gmail.com> - 2016-08-16 15:22 -0700
Re: Difference between these pointer syntaxes Ian Collins <ian-news@hotmail.com> - 2016-08-17 10:45 +1200
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-17 00:11 +0100
Re: Difference between these pointer syntaxes Ian Collins <ian-news@hotmail.com> - 2016-08-17 11:25 +1200
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-16 16:12 -0700
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-17 00:37 -0700
Re: Difference between these pointer syntaxes "James R. Kuyper" <jameskuyper@verizon.net> - 2016-08-16 19:12 -0400
Re: Difference between these pointer syntaxes Ian Collins <ian-news@hotmail.com> - 2016-08-17 11:22 +1200
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-17 01:23 +0100
Re: Difference between these pointer syntaxes Gareth Owen <gwowen@gmail.com> - 2016-08-17 20:55 +0100
Re: Difference between these pointer syntaxes Les Cargill <lcargill99@comcast.com> - 2016-08-17 17:20 -0500
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-17 17:41 -0700
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-17 16:43 -0700
Re: Difference between these pointer syntaxes Jean-Marc Bourguet <jm@bourguet.org> - 2016-08-18 11:59 +0200
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-18 13:20 +0100
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-18 07:35 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-18 16:16 +0100
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-18 08:43 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-18 16:52 +0100
Re: Difference between these pointer syntaxes Tim Rentsch <txr@alumni.caltech.edu> - 2016-08-19 00:35 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-19 11:22 +0100
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-15 13:52 -0700
Re: Difference between these pointer syntaxes "James R. Kuyper" <jameskuyper@verizon.net> - 2016-08-16 16:39 -0400
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-16 22:33 +0100
Re: Difference between these pointer syntaxes jameskuyper@verizon.net - 2016-08-16 15:32 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-17 00:00 +0100
Re: Difference between these pointer syntaxes jameskuyper@verizon.net - 2016-08-16 17:45 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-17 10:53 +0100
Re: Difference between these pointer syntaxes jameskuyper@verizon.net - 2016-08-17 07:44 -0700
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-17 08:28 -0700
Re: Difference between these pointer syntaxes jameskuyper@verizon.net - 2016-08-17 10:16 -0700
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-17 15:23 -0700
Re: Difference between these pointer syntaxes jameskuyper@verizon.net - 2016-08-17 15:33 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-17 17:29 +0100
Re: Difference between these pointer syntaxes jameskuyper@verizon.net - 2016-08-17 10:52 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-17 20:18 +0100
Re: Difference between these pointer syntaxes jameskuyper@verizon.net - 2016-08-17 13:16 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-17 21:34 +0100
Re: Difference between these pointer syntaxes jameskuyper@verizon.net - 2016-08-17 14:45 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-17 23:19 +0100
Re: Difference between these pointer syntaxes jameskuyper@verizon.net - 2016-08-17 16:03 -0700
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-17 16:19 -0700
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-17 14:09 -0700
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-17 19:51 +0100
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-17 20:44 +0100
Re: Difference between these pointer syntaxes jameskuyper@verizon.net - 2016-08-17 13:33 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-17 21:45 +0100
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-17 15:37 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-17 23:48 +0100
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-17 16:25 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-17 18:07 -0700
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-17 17:07 -0700
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-17 17:22 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-17 19:14 -0700
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-17 19:03 -0700
Re: Difference between these pointer syntaxes Tim Rentsch <txr@alumni.caltech.edu> - 2016-09-01 08:23 -0700
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-09-01 09:55 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-09-01 12:39 -0700
Re: Difference between these pointer syntaxes Anand Hariharan <mailto.anand.hariharan@gmail.com> - 2016-09-09 12:48 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-09-09 15:18 -0700
Re: Difference between these pointer syntaxes Anand Hariharan <mailto.anand.hariharan@gmail.com> - 2016-09-11 09:34 -0700
Re: Difference between these pointer syntaxes Tim Rentsch <txr@alumni.caltech.edu> - 2016-09-04 14:55 -0700
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-09-05 00:05 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-09-05 01:37 -0700
Re: Difference between these pointer syntaxes Tim Rentsch <txr@alumni.caltech.edu> - 2016-09-11 06:31 -0700
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-09-05 10:51 +0100
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-09-05 14:13 -0700
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-09-05 16:57 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-09-06 01:21 +0100
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-09-05 17:31 -0700
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-09-06 02:12 +0100
Re: Difference between these pointer syntaxes Ike Naar <ike@iceland.freeshell.org> - 2016-09-06 06:42 +0000
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-09-06 01:47 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-09-06 08:28 -0700
Re: Difference between these pointer syntaxes Richard Heathfield <rjh@cpax.org.uk> - 2016-09-06 13:54 +0100
Re: Difference between these pointer syntaxes Gareth Owen <gwowen@gmail.com> - 2016-09-06 18:06 +0100
Re: Difference between these pointer syntaxes John Bode <jfbode1029@gmail.com> - 2016-09-08 07:09 -0700
Re: Difference between these pointer syntaxes David Brown <david.brown@hesbynett.no> - 2016-09-06 09:29 +0200
Re: Difference between these pointer syntaxes Geoff <geoff@invalid.invalid> - 2016-09-06 09:06 -0700
Re: Difference between these pointer syntaxes Gareth Owen <gwowen@gmail.com> - 2016-09-05 18:21 +0100
Re: Difference between these pointer syntaxes Tim Rentsch <txr@alumni.caltech.edu> - 2016-09-11 06:47 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-18 13:00 +0100
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-17 16:48 -0700
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-18 12:05 +0100
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-18 05:26 -0700
Re: Difference between these pointer syntaxes Richard Heathfield <rjh@cpax.org.uk> - 2016-08-18 13:43 +0100
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-18 14:05 +0100
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-19 00:27 +0100
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-19 02:59 -0700
Re: Difference between these pointer syntaxes David Brown <david.brown@hesbynett.no> - 2016-08-19 14:28 +0200
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-19 14:25 +0100
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-19 06:50 -0700
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-19 15:45 +0100
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-19 08:02 -0700
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-19 08:19 -0700
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-19 17:35 +0100
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-19 10:02 -0700
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-19 10:24 -0700
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-19 22:47 +0100
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-19 16:08 -0700
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-20 00:32 +0100
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-19 17:17 -0700
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-20 11:59 +0100
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-21 04:55 -0700
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-22 07:59 -0700
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-19 17:14 +0100
O(n log n) in place median algorithm (was: Difference between these pointer syntaxes) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-19 23:38 +0100
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-19 08:09 -0700
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-18 07:27 -0700
Re: Difference between these pointer syntaxes David Brown <david.brown@hesbynett.no> - 2016-08-18 17:40 +0200
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-18 10:34 -0700
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-18 09:49 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-18 13:04 -0700
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-18 12:05 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-18 13:52 -0700
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-18 12:51 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-18 14:58 -0700
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-18 15:36 -0700
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-18 09:14 -0700
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-18 09:37 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-17 17:58 -0700
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-17 16:46 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-17 19:03 -0700
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-18 01:55 +0100
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-18 11:04 +0100
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-18 23:04 +0100
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-19 00:10 +0100
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-19 01:08 +0100
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-19 11:04 +0100
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-19 12:32 +0100
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-19 13:45 +0100
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-19 14:40 +0100
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-19 15:30 +0100
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-19 15:54 +0100
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-19 16:24 +0100
Re: Difference between these pointer syntaxes John Bode <jfbode1029@gmail.com> - 2016-08-17 16:04 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-18 00:41 +0100
Re: Difference between these pointer syntaxes jameskuyper@verizon.net - 2016-08-17 16:59 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-18 01:24 +0100
Re: Difference between these pointer syntaxes John Bode <jfbode1029@gmail.com> - 2016-08-18 08:30 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-18 10:49 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-18 19:20 +0100
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-18 01:39 +0100
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-18 10:47 +0100
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-18 11:03 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-18 11:32 -0700
Re: Difference between these pointer syntaxes Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-08-19 00:28 +0100
Re: Difference between these pointer syntaxes jameskuyper@verizon.net - 2016-08-17 12:23 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-17 21:19 +0100
Re: Difference between these pointer syntaxes Malcolm McLean <malcolm.mclean5@btinternet.com> - 2016-08-17 03:10 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-17 09:47 -0700
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-17 08:33 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-17 10:12 -0700
Re: Difference between these pointer syntaxes jameskuyper@verizon.net - 2016-08-17 10:04 -0700
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-13 09:34 -0700
Re: Difference between these pointer syntaxes Tim Rentsch <txr@alumni.caltech.edu> - 2016-08-18 08:04 -0700
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-11 07:51 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-11 15:57 +0100
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-11 09:04 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-11 09:17 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-11 19:15 +0100
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-11 11:41 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-11 20:06 +0100
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-11 13:42 -0700
Re: Difference between these pointer syntaxes Keith Thompson <kst-u@mib.org> - 2016-08-11 12:38 -0700
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-11 20:15 +0100
Re: Difference between these pointer syntaxes supercat@casperkitty.com - 2016-08-11 13:37 -0700
Re: Difference between these pointer syntaxes Gareth Owen <gwowen@gmail.com> - 2016-08-11 19:54 +0100
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-10 12:04 +0100
Re: Difference between these pointer syntaxes James Kuyper <jameskuyper@verizon.net> - 2016-08-10 11:12 -0400
Re: Difference between these pointer syntaxes BartC <bc@freeuk.com> - 2016-08-10 17:27 +0100
Re: Difference between these pointer syntaxes John Bode <jfbode1029@gmail.com> - 2016-08-10 08:19 -0700
Page 1 of 20 [1] 2 3 … 20 Next page →
| From | eva galois <eva.galois@yandex.ru> |
|---|---|
| Date | 2016-08-09 19:37 -0400 |
| Subject | Difference between these pointer syntaxes |
| Message-ID | <nodpg5$cr7$1@dont-email.me> |
Could someone explain (compiler and/or assembly level) differences between *(arr[i]) and (*arr)[i]? I'm interested in how they are evaluated. Correct me if I'm wrong, but I think the first dereferences a pointer at arr[i] and the second dereferences the pointer arr, and then takes the ith element (I guess if arr is a 2d array).
[toc] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2016-08-10 01:12 +0100 |
| Message-ID | <8737mdh47k.fsf@bsb.me.uk> |
| In reply to | #92033 |
eva galois <eva.galois@yandex.ru> writes: > Could someone explain (compiler and/or assembly level) differences > between *(arr[i]) and (*arr)[i]? I'm interested in how they are evaluated. > > Correct me if I'm wrong, but I think the first dereferences a pointer > at arr[i] and the second dereferences the pointer arr, and then takes > the ith element Yes, that's it, but C's [] syntax is defined in terms of arithmetic and *, so the full story is a little bit more general than your description. E1[E2] means *(E1+E2) so your two examples must be evaluated as if they were actually **(arr+i) and *(*arr+i) Note that *(E1+E2) is symmetric in the two expressions, so it does not matter which is the pointer and which is the number. You can write i[arr] just a legally as arr[i]. (This is what Stefan Ram is saying in part of his reply.) Also, when interpreting these it's important to remember that array values get converted to pointers in C (not everywhere, but certainly in this sort of case). > (I guess if arr is a 2d array). The equivalence of E1[E2] and *(E1+E2) also means that *E can be written as E[0]. Thus your two examples are arr[i][0] and arr[0][i] which, as you can see, shows that both could be seen as accessing a 2D structure of some sort. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | supercat@casperkitty.com |
|---|---|
| Date | 2016-08-09 23:57 -0700 |
| Message-ID | <b0ef2157-15ff-4667-809e-80fff4df4933@googlegroups.com> |
| In reply to | #92037 |
On Tuesday, August 9, 2016 at 7:12:40 PM UTC-5, Ben Bacarisse wrote:
> Yes, that's it, but C's [] syntax is defined in terms of arithmetic and
> *, so the full story is a little bit more general than your description.
The relationship was defined in terms of arithmetic at a time when pointer
arithmetic operated on addresses without regard for what they identified.
Since then, things have become somewhat murky. Given
int (*arr)[5];
int *p = malloc(6 * sizeof (int));
arr = p;
The expressions p[n] and arr[n] will both identify the same storage location
in cases where both are defined, but the former will be defined for values
of n from 0 to 5, inclusive, while the latter would yield Undefined Behavior
if n=5.
[toc] | [prev] | [next] | [standalone]
| From | mark.bluemel@gmail.com |
|---|---|
| Date | 2016-08-10 00:29 -0700 |
| Message-ID | <3d91818e-9e4a-44a9-ab2c-92ecbf392eb3@googlegroups.com> |
| In reply to | #92046 |
On Wednesday, 10 August 2016 07:57:15 UTC+1, supe...@casperkitty.com wrote:
> On Tuesday, August 9, 2016 at 7:12:40 PM UTC-5, Ben Bacarisse wrote:
> > Yes, that's it, but C's [] syntax is defined in terms of arithmetic and
> > *, so the full story is a little bit more general than your description.
>
> The relationship was defined in terms of arithmetic at a time when pointer
> arithmetic operated on addresses without regard for what they identified.
> Since then, things have become somewhat murky. Given
>
> int (*arr)[5];
> int *p = malloc(6 * sizeof (int));
> arr = p;
>
> The expressions p[n] and arr[n] will both identify the same storage location
> in cases where both are defined, but the former will be defined for values
> of n from 0 to 5, inclusive, while the latter would yield Undefined Behavior
> if n=5.
$ cat superc.c
#include <stdlib.h>
int main(void) {
int (*arr)[5];
int *p = malloc(6 * sizeof (int));
arr = p;
}
$ cc -o superc superc.c
superc.c: In function ‘main’:
superc.c:6:8: warning: assignment from incompatible pointer type
arr = p;
Could you explain your point again please?
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2016-08-10 20:50 +0100 |
| Message-ID | <87shucflni.fsf@bsb.me.uk> |
| In reply to | #92046 |
supercat@casperkitty.com writes: > On Tuesday, August 9, 2016 at 7:12:40 PM UTC-5, Ben Bacarisse wrote: >> Yes, that's it, but C's [] syntax is defined in terms of arithmetic and >> *, so the full story is a little bit more general than your description. > > The relationship was defined in terms of arithmetic at a time when pointer > arithmetic operated on addresses without regard for what they > identified. Eh? The address arithmetic has always been defined in terms of the type of the pointed-to object. To what are you referring? > Since then, things have become somewhat murky. Given > > int (*arr)[5]; > int *p = malloc(6 * sizeof (int)); > arr = p; (you need cast here -- it's a constraint violation without one) > The expressions p[n] and arr[n] will both identify the same storage location > in cases where both are defined, No they don't. <snip> -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | supercat@casperkitty.com |
|---|---|
| Date | 2016-08-10 15:54 -0700 |
| Message-ID | <abb92968-4bf6-4bbb-8a84-cfb6cdd71094@googlegroups.com> |
| In reply to | #92099 |
On Wednesday, August 10, 2016 at 2:51:05 PM UTC-5, Ben Bacarisse wrote: > supercat writes: > > The relationship was defined in terms of arithmetic at a time when pointer > > arithmetic operated on addresses without regard for what they > > identified. > > Eh? The address arithmetic has always been defined in terms of the type > of the pointed-to object. To what are you referring? I should have said "without regard for the size of any array of which the object might be a part". Perhaps the simplest example would be given: "char foo[10][10];", early C compilers would have regarded both "foo[0][12]" and "foo[1][2]" as accessing the byte of storage whose address was 12 above the start of the array, but the present Standard explicitly regards the former as yielding Undefined Behavior since it tries to index outside the bounds of array "foo[0]".
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2016-08-11 01:20 +0100 |
| Message-ID | <878tw4f967.fsf@bsb.me.uk> |
| In reply to | #92108 |
supercat@casperkitty.com writes: > On Wednesday, August 10, 2016 at 2:51:05 PM UTC-5, Ben Bacarisse wrote: >> supercat writes: >> > The relationship was defined in terms of arithmetic at a time when pointer >> > arithmetic operated on addresses without regard for what they >> > identified. >> >> Eh? The address arithmetic has always been defined in terms of the type >> of the pointed-to object. To what are you referring? > > I should have said "without regard for the size of any array of which the > object might be a part". Perhaps the simplest example would be given: > "char foo[10][10];", early C compilers would have regarded both "foo[0][12]" > and "foo[1][2]" as accessing the byte of storage whose address was 12 above > the start of the array, Many later compilers did too. In fact, lots of current ones will too if you ask them nicely. > but the present Standard explicitly regards the > former as yielding Undefined Behavior since it tries to index outside the > bounds of array "foo[0]". Not only the present standard, but the one before, and the one before that, and the one before *that*. When C (formally) last had unrestrained pointer arithmetic, The Good Life was top of the TV ratings. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Keith Thompson <kst-u@mib.org> |
|---|---|
| Date | 2016-08-10 18:01 -0700 |
| Message-ID | <lnh9asrud8.fsf@kst-u.example.com> |
| In reply to | #92108 |
supercat@casperkitty.com writes:
> On Wednesday, August 10, 2016 at 2:51:05 PM UTC-5, Ben Bacarisse wrote:
>> supercat writes:
>> > The relationship was defined in terms of arithmetic at a time when pointer
>> > arithmetic operated on addresses without regard for what they
>> > identified.
>>
>> Eh? The address arithmetic has always been defined in terms of the type
>> of the pointed-to object. To what are you referring?
>
> I should have said "without regard for the size of any array of which the
> object might be a part". Perhaps the simplest example would be given:
> "char foo[10][10];", early C compilers would have regarded both "foo[0][12]"
> and "foo[1][2]" as accessing the byte of storage whose address was 12 above
> the start of the array, but the present Standard explicitly regards the
> former as yielding Undefined Behavior since it tries to index outside the
> bounds of array "foo[0]".
The behavior you describe for early C compilers is entirely consistent
with the behavior being undefined.
The early C manual I checked doesn't directly address the question, but
the wording suggests to me that it probably assumed they were
equivalent.
I suspect early C compilers (and many modern ones) would treat
`foo[0][12]` and `foo[1][2]` as effectively equivalent simply because
that's the easiest thing to do. Did early C compilers *document* this
equivalence?
Some CPUs have addressing modes that limit the size of an offset.
Did early compilers for such systems go out of their way to ensure that
the generated code actually would treat `foo[0][12]` and `foo[1][2]` as
equivalent, whether the indices were constants or variables?
--
Keith Thompson (The_Other_Keith) kst-u@mib.org <http://www.ghoti.net/~kst>
Working, but not speaking, for JetHead Development, Inc.
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"
[toc] | [prev] | [next] | [standalone]
| From | supercat@casperkitty.com |
|---|---|
| Date | 2016-08-11 07:40 -0700 |
| Message-ID | <8a0389e3-4ad6-4eb4-a5d2-887a2e842470@googlegroups.com> |
| In reply to | #92111 |
On Wednesday, August 10, 2016 at 7:35:08 PM UTC-5, Keith Thompson wrote:
> supercat writes:
> > I should have said "without regard for the size of any array of which the
> > object might be a part". Perhaps the simplest example would be given:
> > "char foo[10][10];", early C compilers would have regarded both "foo[0][12]"
> > and "foo[1][2]" as accessing the byte of storage whose address was 12 above
> > the start of the array, but the present Standard explicitly regards the
> > former as yielding Undefined Behavior since it tries to index outside the
> > bounds of array "foo[0]".
>
> The behavior you describe for early C compilers is entirely consistent
> with the behavior being undefined.
Indeed. The problem is that there are times when the "old" behavior is
useful and the Standard is unclear what one must do to achieve it. The
most logical way to enable optimizations while avoiding breakage of
existing code would have been to treat the application of [] to an array
as being different from a combination of array-to-pointer decomposition,
addition, and dereferencing. Such treatment would have been consistent
with defined behaviors, but would have made clear that given:
int arr[10][10];
the expression arr[x][y] would be limited to y in the range 0..9, but the
expression ((int*)arr[0])[i] would be usable for any value of i that would
cause the pointer arithmetic to land in the same allocation as arr. It
would also make clear that if "foo" has members "int arr[5],*p;", the
statement "foo->arr[3]=5;" is a write to lvalue "foo", but "foo->p[3]=5;"
isn't (in the former expression, the terminology in the Standard would
describe "foo->arr" as being decomposed to an rvalue of type "int*", which
is then used to yield an lvalue of type "int").\
[toc] | [prev] | [next] | [standalone]
| From | Ike Naar <ike@iceland.freeshell.org> |
|---|---|
| Date | 2016-08-11 22:43 +0000 |
| Message-ID | <slrn3vfsnqpvrl.rbu.ike@iceland.freeshell.org> |
| In reply to | #92046 |
On 2016-08-10, supercat@casperkitty.com <supercat@casperkitty.com> wrote: > The relationship was defined in terms of arithmetic at a time when pointer > arithmetic operated on addresses without regard for what they identified. > Since then, things have become somewhat murky. Given > > int (*arr)[5]; > int *p = malloc(6 * sizeof (int)); > arr = p; > > The expressions p[n] and arr[n] will both identify the same storage location > in cases where both are defined, but the former will be defined for values > of n from 0 to 5, inclusive, while the latter would yield Undefined Behavior > if n=5. Given that sizeof p[n] != sizeof arr[n], is this just a cryptic way of saying that p[n] and arr[n] are both defined only for n==0 ?
[toc] | [prev] | [next] | [standalone]
| From | BartC <bc@freeuk.com> |
|---|---|
| Date | 2016-08-10 11:51 +0100 |
| Message-ID | <nof0v7$mhn$1@dont-email.me> |
| In reply to | #92037 |
On 10/08/2016 01:12, Ben Bacarisse wrote: > eva galois <eva.galois@yandex.ru> writes: > >> Could someone explain (compiler and/or assembly level) differences >> between *(arr[i]) and (*arr)[i]? I'm interested in how they are evaluated. >> >> Correct me if I'm wrong, but I think the first dereferences a pointer >> at arr[i] and the second dereferences the pointer arr, and then takes >> the ith element I guess your reply has confused the OP enough that it doesn't matter if I further point out that: - In the first example, arr is 'an array of T' or a 'pointer to T' - In the second example, arr is a 'pointer to array of T'. > Yes, that's it, but C's [] syntax is defined in terms of arithmetic and > *, so the full story is a little bit more general than your description. > > E1[E2] means *(E1+E2) so your two examples must be evaluated as if they > were actually > > **(arr+i) and *(*arr+i) > > Note that *(E1+E2) is symmetric in the two expressions, so it does not > matter which is the pointer and which is the number. You can write > i[arr] just a legally as arr[i]. (This is what Stefan Ram is saying in > part of his reply.) > > Also, when interpreting these it's important to remember that array > values get converted to pointers in C (not everywhere, but certainly in > this sort of case). > >> (I guess if arr is a 2d array). > > The equivalence of E1[E2] and *(E1+E2) also means that *E can be written > as E[0]. Thus your two examples are > > arr[i][0] and arr[0][i] > > which, as you can see, shows that both could be seen as accessing a 2D > structure of some sort. And your reply neatly summaries everything I think is wrong about C array handling. Otherwise it wouldn't be necessary to explain it at this length. - That A[i] is also *(A+i) and vice versa - That A[i] is also i[A] (completely unnecessary) - That A[0] is also *A and vice versa - That A 'decays' to &A[0] in most expression contexts, when A is of type 'array of T'. So that it becomes 'pointer to T' - That something involving one deref and one index op (which can also be viewed as two deref ops) can be considered to be an access to a 2D array, when it might be nothing of the sort. (While two index ops can access something that is not a 2D array!) There are many other implications from this lot that you don't fully appreciate until they bite you. -- Bartc
[toc] | [prev] | [next] | [standalone]
| From | supercat@casperkitty.com |
|---|---|
| Date | 2016-08-10 08:11 -0700 |
| Message-ID | <31b2cadc-10d6-4979-a86e-dca5c0b16f65@googlegroups.com> |
| In reply to | #92055 |
On Wednesday, August 10, 2016 at 5:51:28 AM UTC-5, Bart wrote:
> I guess your reply has confused the OP enough that it doesn't matter if
> I further point out that:
>
> - In the first example, arr is 'an array of T' or a 'pointer to T'
>
> - In the second example, arr is a 'pointer to array of T'.
The hazards of posting while sleepy.
My intention was to give a case where something declared as an array type
was part of a larger allocation, and where a pointer-to-element type could
be used to access things beyond the array. I'm not sure why I thought a
pointer-to-array type would be better for that purpose than a pointer to a
structure which contains an array, given that pointer-to-array types have
so many weird quirks. Even if I'd avoided getting tripped up myself, the
behavior of pointer-to-array types would trip up anyone trying to understand
my point, making them inferior to structures for example purposes. Given:
#include <stdlib.h>
typedef struct { int arr[8]; } arr8;
int test(void *p, int n, int mode)
{
arr8 *p1 = p;
int *p2 = p;
if (mode)
return p1->arr[n];
else
return p2[n];
}
the expressions p1->arr[n] and p2[n] will use identical pointer arithmetic
in all cases where p1->arr[n] is defined, but some compilers may regard
the former as an invitation to have surrounding code assume that n cannot
be greater than 7.
[toc] | [prev] | [next] | [standalone]
| From | BartC <bc@freeuk.com> |
|---|---|
| Date | 2016-08-10 17:13 +0100 |
| Message-ID | <nofjqv$or1$1@dont-email.me> |
| In reply to | #92072 |
On 10/08/2016 16:11, supercat@casperkitty.com wrote: > On Wednesday, August 10, 2016 at 5:51:28 AM UTC-5, Bart wrote: >> I guess your reply has confused the OP enough that it doesn't matter if >> I further point out that: >> >> - In the first example, arr is 'an array of T' or a 'pointer to T' >> >> - In the second example, arr is a 'pointer to array of T'. > > The hazards of posting while sleepy. > > My intention was to ... Are you the OP? -- Bartc
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2016-08-10 20:57 +0100 |
| Message-ID | <87mvkkflc0.fsf@bsb.me.uk> |
| In reply to | #92055 |
BartC <bc@freeuk.com> writes: > On 10/08/2016 01:12, Ben Bacarisse wrote: >> eva galois <eva.galois@yandex.ru> writes: >> >>> Could someone explain (compiler and/or assembly level) differences >>> between *(arr[i]) and (*arr)[i]? I'm interested in how they are evaluated. >>> >>> Correct me if I'm wrong, but I think the first dereferences a pointer >>> at arr[i] and the second dereferences the pointer arr, and then takes >>> the ith element > > I guess your reply has confused the OP enough that it doesn't matter > if I further point out that: > > - In the first example, arr is 'an array of T' or a 'pointer to T' > > - In the second example, arr is a 'pointer to array of T'. How do you know that? (It's a reasonable assumption, but you seem to be stating is as a certain matter of fact.) <snip> > And your reply neatly summaries everything I think is wrong about C > array handling. That means my explanation was a good one! <snip> -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | BartC <bc@freeuk.com> |
|---|---|
| Date | 2016-08-10 21:21 +0100 |
| Message-ID | <nog2bn$er8$1@dont-email.me> |
| In reply to | #92100 |
On 10/08/2016 20:57, Ben Bacarisse wrote:
> BartC <bc@freeuk.com> writes:
>
>> On 10/08/2016 01:12, Ben Bacarisse wrote:
>>> eva galois <eva.galois@yandex.ru> writes:
>>>
>>>> Could someone explain (compiler and/or assembly level) differences
>>>> between *(arr[i]) and (*arr)[i]? I'm interested in how they are evaluated.
>>>>
>>>> Correct me if I'm wrong, but I think the first dereferences a pointer
>>>> at arr[i] and the second dereferences the pointer arr, and then takes
>>>> the ith element
>>
>> I guess your reply has confused the OP enough that it doesn't matter
>> if I further point out that:
>>
>> - In the first example, arr is 'an array of T' or a 'pointer to T'
>>
>> - In the second example, arr is a 'pointer to array of T'.
>
> How do you know that? (It's a reasonable assumption, but you seem to be
> stating is as a certain matter of fact.)
What are the other possibilities? That the arr in the second example
might be a pointer to T?
(In Pascal notation the examples - assuming the first arr is array of T
- would be:
arr[i]^ # index then deref
arr^[i] # deref then index
Indexing can only be done on an array. A deref can only be done on a
pointer. There is no need for the speculation there can be in C.)
--
Bartc
[toc] | [prev] | [next] | [standalone]
| From | jameskuyper@verizon.net |
|---|---|
| Date | 2016-08-10 14:38 -0700 |
| Message-ID | <7f6ae46e-611f-46fa-9832-d0b96946af54@googlegroups.com> |
| In reply to | #92103 |
On Wednesday, August 10, 2016 at 4:21:19 PM UTC-4, Bart wrote:
> On 10/08/2016 20:57, Ben Bacarisse wrote:
> > BartC <bc@freeuk.com> writes:
> >
> >> On 10/08/2016 01:12, Ben Bacarisse wrote:
> >>> eva galois <eva.galois@yandex.ru> writes:
> >>>
> >>>> Could someone explain (compiler and/or assembly level) differences
> >>>> between *(arr[i]) and (*arr)[i]? I'm interested in how they are evaluated.
> >>>>
> >>>> Correct me if I'm wrong, but I think the first dereferences a pointer
> >>>> at arr[i] and the second dereferences the pointer arr, and then takes
> >>>> the ith element
> >>
> >> I guess your reply has confused the OP enough that it doesn't matter
> >> if I further point out that:
> >>
> >> - In the first example, arr is 'an array of T' or a 'pointer to T'
> >>
> >> - In the second example, arr is a 'pointer to array of T'.
> >
> > How do you know that? (It's a reasonable assumption, but you seem to be
> > stating is as a certain matter of fact.)
>
> What are the other possibilities? That the arr in the second example
> might be a pointer to T?
By assuming that both examples were using the same definition of 'arr', I narrowed it down to just four general possibilities:
T2 arr1[M][N];
T2 (*arr2)[N];
T2 *arr3[M];
T2 **arr4;
Your comment claims that the second example requires that arr be a pointer. Neither arr1 nor arr3 are pointers, they are arrays. Yet (*arr1)[i] and (*arr3)[i] are both valid expressions.
[toc] | [prev] | [next] | [standalone]
| From | BartC <bc@freeuk.com> |
|---|---|
| Date | 2016-08-10 23:16 +0100 |
| Message-ID | <nog94b$8et$1@dont-email.me> |
| In reply to | #92105 |
On 10/08/2016 22:38, jameskuyper@verizon.net wrote:
> On Wednesday, August 10, 2016 at 4:21:19 PM UTC-4, Bart wrote:
>> On 10/08/2016 20:57, Ben Bacarisse wrote:
>>> How do you know that? (It's a reasonable assumption, but you seem to be
>>> stating is as a certain matter of fact.)
>>
>> What are the other possibilities? That the arr in the second example
>> might be a pointer to T?
>
> By assuming that both examples were using the same definition of 'arr', I narrowed it down to just four general possibilities:
>
> T2 arr1[M][N];
> T2 (*arr2)[N];
> T2 *arr3[M];
> T2 **arr4;
>
> Your comment claims that the second example requires that arr be a pointer. Neither arr1 nor arr3 are pointers, they are arrays. Yet (*arr1)[i] and (*arr3)[i] are both valid expressions.
OK. So we have all the possibilities listed below. It seems both the
OP's two examples are equivalent. They are interchangeable. You can
write these terms any way you like, and they will still compile.
This is what makes me very uneasy about using arrays in C. And it makes
it harder to explain to beginners: arr can be a pointer, or it can be an
array, or or it can an array of arrays or a pointer to a pointer; and it
is possible to write *(arr[i]) or (*arr)[i] or any of the forms below;
it doesn't matter! C allows a very sloppy treatment.
So I prefer to use these rules (strictly enforced when generating C
code, less so when writing it directly because the syntax becomes awkward):
- * dereferencing is ONLY used for a type 'pointer to T'
- [] indexing is ONLY used for a type 'array of T'
Then only these access forms would be used:
T2 arr1[M][N]; // as arr1[i][j]
T2 (*arr2)[N]; // (*arr2)[j]
T2 *arr3[M]; // *arr3[i]
T2 **arr4; // **arr3
Which also handily match their declarations exactly (which I understand
was the point of this declaration syntax).
------------------------------------------
typedef int T2;
#define M 5
#define N 4
int main(void)
{
T2 arr1[M][N];
T2 (*arr2)[N];
T2 *arr3[M];
T2 **arr4;
int i,j;
*(arr1[i]);
*(arr2[i]);
*(arr3[i]);
*(arr4[i]);
(*arr1)[i];
(*arr2)[i];
(*arr3)[i];
(*arr4)[i];
arr1[i][j];
(*arr1)[j];
*arr1[j];
**arr1;
arr2[i][j];
(*arr2)[j];
*arr2[j];
**arr2;
arr3[i][j];
(*arr3)[j];
*arr3[j];
**arr3;
arr4[i][j];
(*arr4)[j];
*arr4[j];
**arr4;
}
--
Bartc
[toc] | [prev] | [next] | [standalone]
| From | jameskuyper@verizon.net |
|---|---|
| Date | 2016-08-10 20:19 -0700 |
| Message-ID | <afa32386-18c9-43d3-b9e6-2d9eb7272a3e@googlegroups.com> |
| In reply to | #92106 |
On Wednesday, August 10, 2016 at 6:16:52 PM UTC-4, Bart wrote: > On 10/08/2016 22:38, jameskuyper@verizon.net wrote: > > On Wednesday, August 10, 2016 at 4:21:19 PM UTC-4, Bart wrote: > >> On 10/08/2016 20:57, Ben Bacarisse wrote: > > >>> How do you know that? (It's a reasonable assumption, but you seem to be > >>> stating is as a certain matter of fact.) > >> > >> What are the other possibilities? That the arr in the second example > >> might be a pointer to T? > > > > By assuming that both examples were using the same definition of 'arr', I narrowed it down to just four general possibilities: > > > > T2 arr1[M][N]; > > T2 (*arr2)[N]; > > T2 *arr3[M]; > > T2 **arr4; > > > > Your comment claims that the second example requires that arr be a pointer. > > Neither arr1 nor arr3 are pointers, they are arrays. Yet (*arr1)[i] and > > (*arr3)[i] are both valid expressions. > > OK. So we have all the possibilities listed below. It seems both the > OP's two examples are equivalent. They are interchangeable. No one said they were interchangeable. In fact, the original question was about how they differed. It's possible to declare arr in such a way that both expressions are syntactically correct, don't violate any constraints, and have defined behavior - and I gave you a compressive description of all declarations of arr for which that would be true. But in general, that defined behavior will be different for the two expressions. It's also possible to declare arr in such a way that only one or the other of those two expression has defined behavior, in which case the answer to the OP's question would be: "this expression has defined behavior, and the other one does not". I don't think that's a particularly useful way to answer the question, which is why I concentrated on declarations of arr for which both expressions have defined behavior. > You can > write these terms any way you like, and they will still compile. More accurately, you can write them any way that C likes, and C likes a wider variety of forms than you do, but your freedom is not completely open-ended. [i](*arr), for instance, isn't an acceptable alternative form for (*arr)[i]. > This is what makes me very uneasy about using arrays in C. And it makes > it harder to explain to beginners: arr can be a pointer, or it can be an > array, or or it can an array of arrays or a pointer to a pointer; and it > is possible to write *(arr[i]) or (*arr)[i] or any of the forms below; > it doesn't matter! C allows a very sloppy treatment. > > So I prefer to use these rules (strictly enforced when generating C > code, less so when writing it directly because the syntax becomes awkward): > > - * dereferencing is ONLY used for a type 'pointer to T' > > - [] indexing is ONLY used for a type 'array of T' > > Then only these access forms would be used: > > T2 arr1[M][N]; // as arr1[i][j] > T2 (*arr2)[N]; // (*arr2)[j] > T2 *arr3[M]; // *arr3[i] > T2 **arr4; // **arr3 Let's examine the two expressions using those restrictions: *(arr[i]) - The equivalent expressions, obeying your rules, are: arr1[i][0], (*(arr2+i))[0], *arr3[i], and **(arr4+i) (*arr)[i] - The equivalent expressions, obeying your rules, are: arr1[0][i], (*arr2)[i], *(arr3[0]+i), and *(*arr4+i) None of the expressions in the first group is equivalent to any of the expressions in the second group, unless i==0, in which case they're all equivalent.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2016-08-11 01:36 +0100 |
| Message-ID | <871t1wf8f8.fsf@bsb.me.uk> |
| In reply to | #92103 |
BartC <bc@freeuk.com> writes:
> On 10/08/2016 20:57, Ben Bacarisse wrote:
>> BartC <bc@freeuk.com> writes:
>>
>>> On 10/08/2016 01:12, Ben Bacarisse wrote:
>>>> eva galois <eva.galois@yandex.ru> writes:
>>>>
>>>>> Could someone explain (compiler and/or assembly level) differences
>>>>> between *(arr[i]) and (*arr)[i]? I'm interested in how they are evaluated.
>>>>>
>>>>> Correct me if I'm wrong, but I think the first dereferences a pointer
>>>>> at arr[i] and the second dereferences the pointer arr, and then takes
>>>>> the ith element
>>>
>>> I guess your reply has confused the OP enough that it doesn't matter
>>> if I further point out that:
>>>
>>> - In the first example, arr is 'an array of T' or a 'pointer to T'
>>>
>>> - In the second example, arr is a 'pointer to array of T'.
>>
>> How do you know that? (It's a reasonable assumption, but you seem to be
>> stating is as a certain matter of fact.)
>
> What are the other possibilities? That the arr in the second example
> might be a pointer to T?
For the second, you could have
int x = 4, *arr = &x;
int i[] = {1, 2, 3, 4, 5};
so, yes, arr could be a pointer. It could also be an array:
int arr[] = {4, 3, 2, 1};
int i[] = {1, 2, 3, 4, 5};
Likewise, for the first, there is no need for arr to be an array or a
pointer:
int x = 5, arr = 4;
int *i[] = {0, 0, 0, 0, &x};
<snip>
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | BartC <bc@freeuk.com> |
|---|---|
| Date | 2016-08-11 10:49 +0100 |
| Message-ID | <nohhmm$dp8$1@dont-email.me> |
| In reply to | #92112 |
On 11/08/2016 01:36, Ben Bacarisse wrote:
> BartC <bc@freeuk.com> writes:
>
>> On 10/08/2016 20:57, Ben Bacarisse wrote:
>>> BartC <bc@freeuk.com> writes:
>>>
>>>> On 10/08/2016 01:12, Ben Bacarisse wrote:
>>>>> eva galois <eva.galois@yandex.ru> writes:
>>>>>
>>>>>> Could someone explain (compiler and/or assembly level) differences
>>>>>> between *(arr[i]) and (*arr)[i]? I'm interested in how they are evaluated.
>>>>>>
>>>>>> Correct me if I'm wrong, but I think the first dereferences a pointer
>>>>>> at arr[i] and the second dereferences the pointer arr, and then takes
>>>>>> the ith element
>>>>
>>>> I guess your reply has confused the OP enough that it doesn't matter
>>>> if I further point out that:
>>>>
>>>> - In the first example, arr is 'an array of T' or a 'pointer to T'
>>>>
>>>> - In the second example, arr is a 'pointer to array of T'.
>>>
>>> How do you know that? (It's a reasonable assumption, but you seem to be
>>> stating is as a certain matter of fact.)
>>
>> What are the other possibilities? That the arr in the second example
>> might be a pointer to T?
>
> For the second, you could have
>
> int x = 4, *arr = &x;
> int i[] = {1, 2, 3, 4, 5};
>
> so, yes, arr could be a pointer. It could also be an array:
>
> int arr[] = {4, 3, 2, 1};
> int i[] = {1, 2, 3, 4, 5};
>
> Likewise, for the first, there is no need for arr to be an array or a
> pointer:
>
> int x = 5, arr = 4;
> int *i[] = {0, 0, 0, 0, &x};
OK...
Let me ask you, do you think it was a good idea for + between pointer
and offset to be commutative?
That is, allowing offset+pointer as well as pointer+offset.
Because, allowing the same equivalence between a[i] and *(a+i), that
allows someone to write i[a]. Even though hardly anyone does this, you
can never be quite sure.
It also makes nonsense of the syntax a[i]: in a million other languages
the thing in brackets is the index or selector, the thing outside is the
collection or sequence you're trying to index into.
So a[i] in C is obviously intended to look like those other uses, but
that becomes futile is someone can also write i[a]. Or, worse, when i is
the array and a is the index, and they write a[i].
--
Bartc
[toc] | [prev] | [next] | [standalone]
Page 1 of 20 [1] 2 3 … 20 Next page →
Back to top | Article view | comp.lang.c
csiph-web