&foo[bar] or (foo + bar) ?
-
what is your preference? I'm guessing some people prefer
&foo[bar]because they may find the intent to be expressed more clearly. I find(foo + bar)to be more succinct with less steps, and therefore clearer to me.Check out my IoT graphics library here: https://honeythecodewitch.com/gfx And my IoT UI/User Experience library here: https://honeythecodewitch.com/uix
-
what is your preference? I'm guessing some people prefer
&foo[bar]because they may find the intent to be expressed more clearly. I find(foo + bar)to be more succinct with less steps, and therefore clearer to me.Check out my IoT graphics library here: https://honeythecodewitch.com/gfx And my IoT UI/User Experience library here: https://honeythecodewitch.com/uix
You probably have to be a real C nerd to use
(foo + bar). I'm not sure that anyone I work with would grok that they're both the same thing. But maybe I work with journeymen, and not craftsmen? For me,&foo[bar]gives me a brain cramp when I try to parse it. I'd prefer&(foo[bar])just to make it obvious what is having it's address taken. Just to be pedantic."A little song, a little dance, a little seltzer down your pants" Chuckles the clown
-
what is your preference? I'm guessing some people prefer
&foo[bar]because they may find the intent to be expressed more clearly. I find(foo + bar)to be more succinct with less steps, and therefore clearer to me.Check out my IoT graphics library here: https://honeythecodewitch.com/gfx And my IoT UI/User Experience library here: https://honeythecodewitch.com/uix
-
what is your preference? I'm guessing some people prefer
&foo[bar]because they may find the intent to be expressed more clearly. I find(foo + bar)to be more succinct with less steps, and therefore clearer to me.Check out my IoT graphics library here: https://honeythecodewitch.com/gfx And my IoT UI/User Experience library here: https://honeythecodewitch.com/uix
-
You probably have to be a real C nerd to use
(foo + bar). I'm not sure that anyone I work with would grok that they're both the same thing. But maybe I work with journeymen, and not craftsmen? For me,&foo[bar]gives me a brain cramp when I try to parse it. I'd prefer&(foo[bar])just to make it obvious what is having it's address taken. Just to be pedantic."A little song, a little dance, a little seltzer down your pants" Chuckles the clown
Hail to the parenthesis. I always get comments that I use unnecessary parentheses in my code when I add them to pointer arithmetic or compound statements. My response is always along the lines of "yes I know and you were able to tell at a glance the order in which those statements were executed, and how the data was manipulated". Just put the damn () in there to make it easy for someone else to follow what you're trying to do without having to resort to the language specification. It's so much more maintainable for the next person, or yourself in 18 months when you go back to it.
Be wary of strong drink. It can make you shoot at tax collectors - and miss. Lazarus Long, "Time Enough For Love" by Robert A. Heinlein
-
what is your preference? I'm guessing some people prefer
&foo[bar]because they may find the intent to be expressed more clearly. I find(foo + bar)to be more succinct with less steps, and therefore clearer to me.Check out my IoT graphics library here: https://honeythecodewitch.com/gfx And my IoT UI/User Experience library here: https://honeythecodewitch.com/uix
If the data type is defined as an array then use it as array in expressions. If the data type is defined as a pointer then use it as a pointer in expressions.
honey the codewitch wrote:
some people prefer &foo[bar]
Rather certain that I am one that would not want to see that. I work to write code that is maintainable and using tricks just because the exist is not something that I look on favorably.
-
If the data type is defined as an array then use it as array in expressions. If the data type is defined as a pointer then use it as a pointer in expressions.
honey the codewitch wrote:
some people prefer &foo[bar]
Rather certain that I am one that would not want to see that. I work to write code that is maintainable and using tricks just because the exist is not something that I look on favorably.
That's not really a trick. It's "get me the address of the Nth array element." It's just another way of writing (foo + bar); If you insist on not mixing pointer and array ops than you'd be stuck with the very syntax you don't like in order to get the address of an array element, unless there's a 3rd way to do it I'm not considering?
Check out my IoT graphics library here: https://honeythecodewitch.com/gfx And my IoT UI/User Experience library here: https://honeythecodewitch.com/uix
-
what is your preference? I'm guessing some people prefer
&foo[bar]because they may find the intent to be expressed more clearly. I find(foo + bar)to be more succinct with less steps, and therefore clearer to me.Check out my IoT graphics library here: https://honeythecodewitch.com/gfx And my IoT UI/User Experience library here: https://honeythecodewitch.com/uix
-
&(foo[bar])makes it real obvious you want the address of the _bar_th element of array fooBe wary of strong drink. It can make you shoot at tax collectors - and miss. Lazarus Long, "Time Enough For Love" by Robert A. Heinlein
fair enough. Edit: To me the operation is obvious, such that using parentheses never even occurred to me. Clearly that's not the case with the other people that have commented here. ;P Not sure what that says about my code. :~
Check out my IoT graphics library here: https://honeythecodewitch.com/gfx And my IoT UI/User Experience library here: https://honeythecodewitch.com/uix
-
fair enough. Edit: To me the operation is obvious, such that using parentheses never even occurred to me. Clearly that's not the case with the other people that have commented here. ;P Not sure what that says about my code. :~
Check out my IoT graphics library here: https://honeythecodewitch.com/gfx And my IoT UI/User Experience library here: https://honeythecodewitch.com/uix
It's obvious to me too, but I've been coding C since I upgraded from assembler back in the late 80's :-). Those who aren't as strong in C that have looked at my code always find it easier to understand pointer manipulation if I use array notation with those redundant (). They have more difficulty with foo + bar -- the idea that foo + 1 moves the pointer by (size of what foo points) bytes instead of 1 byte always blows their mind.
Be wary of strong drink. It can make you shoot at tax collectors - and miss. Lazarus Long, "Time Enough For Love" by Robert A. Heinlein
-
That's not really a trick. It's "get me the address of the Nth array element." It's just another way of writing (foo + bar); If you insist on not mixing pointer and array ops than you'd be stuck with the very syntax you don't like in order to get the address of an array element, unless there's a 3rd way to do it I'm not considering?
Check out my IoT graphics library here: https://honeythecodewitch.com/gfx And my IoT UI/User Experience library here: https://honeythecodewitch.com/uix
-
So you say it is an array. Then use it as an array when you identify the element you want to take the address of.
that's exactly what &foo[bar] does. Literally it reads as take the address of the bar element of foo.
Check out my IoT graphics library here: https://honeythecodewitch.com/gfx And my IoT UI/User Experience library here: https://honeythecodewitch.com/uix
-
that's exactly what &foo[bar] does. Literally it reads as take the address of the bar element of foo.
Check out my IoT graphics library here: https://honeythecodewitch.com/gfx And my IoT UI/User Experience library here: https://honeythecodewitch.com/uix
-
what is your preference? I'm guessing some people prefer
&foo[bar]because they may find the intent to be expressed more clearly. I find(foo + bar)to be more succinct with less steps, and therefore clearer to me.Check out my IoT graphics library here: https://honeythecodewitch.com/gfx And my IoT UI/User Experience library here: https://honeythecodewitch.com/uix
-
I used to write things like 2[array] to wind up certain colleagues. (Often the ones that insisted on putting the constant on the LHS of a comparison operator.)
Software rusts. Simon Stephenson, ca 1994. So does this signature. me, 2012
-
I used to write things like 2[array] to wind up certain colleagues. (Often the ones that insisted on putting the constant on the LHS of a comparison operator.)
Software rusts. Simon Stephenson, ca 1994. So does this signature. me, 2012
-
what is your preference? I'm guessing some people prefer
&foo[bar]because they may find the intent to be expressed more clearly. I find(foo + bar)to be more succinct with less steps, and therefore clearer to me.Check out my IoT graphics library here: https://honeythecodewitch.com/gfx And my IoT UI/User Experience library here: https://honeythecodewitch.com/uix
-
Did you intend to put an 'Enter' between 'foo' and 'bar'? If the comma was intended as an 'Enter', I guess that the comma between, 'bar' and '+' would have fouled it up.
That is wrong, yes ... I was letting it slide because I was so late in on the thread that I figured no one would notice. Is it me or has the complexion of such changed lately? Anyway. What I meant to type was "foo,bar+". I'm no programmer just an antique calculator button presser. :sigh:
-
what is your preference? I'm guessing some people prefer
&foo[bar]because they may find the intent to be expressed more clearly. I find(foo + bar)to be more succinct with less steps, and therefore clearer to me.Check out my IoT graphics library here: https://honeythecodewitch.com/gfx And my IoT UI/User Experience library here: https://honeythecodewitch.com/uix
One of the things that pisses me off in this book I bought about programming GPUs is that he presents so called "pseudocode" example for presenting his solutions. This pseudocode makes extensive use of C style pointer arithmetic, such as (foo + bar) without a word of mention; the reader is supposed to understand what it means, regardless of his programming background or preferred language. I do have enough background to understand it when I see it. But I see pseudocode as abstracted above one specific programming language, not just as an excuse for ignoring specific requirements of one chosen language. (foo+bar) is something you'll never find in any comparable language. It doesn't belong in any abstracted pseudocode. So does it belong in concrete code in one specific language? Well, if you strive to establish a tribal code, to distinguish between those who are in and those outside, this may be one of your tools. Those who say 'But that is an array, FGS! - Why don't you treat it as one?' - and recoil in horror. Maybe those could have been good developers for your project.
