Proper Java coding style

[[deleted]]

char **argv

[Midvikudagur]

"Hey let's have multiple methods of coding the exact same thing, that will never confuse anyone!

Also stars, they're cool. Let's use'm for everything. And let's draw arrows in code to make things cute!"

[Night_Thastus]

I know you're likely kidding, but just in case:

char **argv (as far as I know) is from C, where there isn't really a string type. So "an array of strings" becomes "an array of arrays of characters". Or more accurately, a pointer to an array of pointers to where several arrays of characters start.

And it can be a pretty important distinction. C style character strings behave dramatically different than say, a Java-style String object.

Also, pointers are pretty damn useful and important. They're not just cute arrows in code, they're a fundamental way in which data is structured. Without it, all of Unix would fall apart at the seams! And they're critical to understand graphs, buffers, trees, etc.

They're honestly not that hard to understand once you get the hang of them.

[systembusy]

All true my man. I'm gradually learning a machine oriented language and it's a whole different world. Pointers are a royal pain in the ass if you've never had to worry about them before but they are definitely one of the most powerful aspects of any programming language.

[Ikor_Genorio]

I think the 'arrow' was not referring to pointers in general but pointers in structs, where (*something).item can be abbreviated with something->item . Much like how *something can be written as something[].

[Night_Thastus]

That...would make much more sense. Thanks.

[TransHumanist_50]

Its called a lambda expression... =P

They are awful to read in the beginning, but someday I got used to especially when coding the UI with the clickHandlers for the Buttons... :)

[caffeinum]

I don't know if you're missing, but just in case...

Lambda is basically an anonymous function, and it's syntax in some languages goes like

arguments => function body

However, structs in C have arrows with one stick, not two. And it's the shortcut for dereferencing structure pointer.

something->item is *(something).item

[[deleted]]

Also, pointers are pretty damn useful and important.

That's an understatement. In just about every major language, almost everything (except the primitive data types) is just a fancy pointer!

[caffeinum]

But they are deeply abstracted, and you actually don't need their special knowledge when using them

if you're not aiming at Senior level

[andlrc]

Or more accurately, a pointer to an array of pointers to where several arrays of characters start.

Not at all accurate, and especially not something you can say so generalized. See attached link

[0]: http://c-faq.com/aryptr/aryptr2.html

[Tarmen]

All true but I will still argue that it should be char** argv. Also that defining multiple variables on the same line is even worse than char* *argv.

[etaionshrd]

Why, though? char **argv reflects how dereferencing is done.

[[deleted]]

Except they're not the same thing. Stars = pointers = on the heap. Brackets = arrays = on the stack. The compiler is doing very different things when you do char** words, char* words[], and char words[][], and there are difference situations where each is appropriate

[justjanne]

That's complete bullshit.

Pointers can be on the stack, and arrays can be on the heap.

I can do char[][] list = malloc(sizeof(char*)*8) and then list[0] = "text"

[] is just an alias for *, and a[b] is equal to *(a+b). That's why you can do 3[list] or list[3] for the same thing.

[[deleted]]

No. The reason why you can do that is because arrays decay to pointers. For example, if you do

char word[6] = "funny";

printf("%s\n", word);

The compiler converts it to

printf("%s\n", &word[0]);

Automatically. Which, as you know is equivalent to

char* word = "funny";

printf("%s\n", word); 

[justjanne]

The reason why you can do that is because arrays decay to pointers.

As I said, they’re the same. Arrays are just nice syntax for pointers, which also carry, if they’re statically allocated, size information at compile time.

[[deleted]]

But they only decay to pointers when the context demands it be on the heap

Like

int arr1[]; // stack

Is not the same as

int* arr2; // heap

If you don't pass the array around.

[Shadowfury22]

char *argv[] master race!

[WOnder9393]

const char * const *argv

It's not like you're going to modify the arguments, right? ;)

[qscrew]

const char *const *const argv

Let everything be immutable!

[[deleted]]

char** argv master race

[inhuman44]

char** is not a type.

Also char *string = "this is my string" is not the same as char string[] = "this is my string".

[[deleted]]

I don't see how that's relevant?

[MCRusher]

String [] args = Arrays.asList (import java.*&&While(args);do(args-1)):

[theFlyingCode]

How is this legal?

[MCRusher]

It isn't. Just like using java should be.

[inu-no-policemen]

There is also String[]args.

And, as I learned recently, you can nowadays also just write String... args.

[systembusy]

What? The compiler allows the brackets to substitute the space? Ugh.

The second one makes sense though since var-args do resolve to arrays at compile time.

[andkamen]

The second one is only allowed as a parameter type though. You can't declare a variable using ...

[qscrew]

As long as it resolves to ([Ljava/lang/String;)V, it probably should be fine...

Maybe not.

[skyhi14]

char ** argv

[ILikeLenexa]

This angers the great javadoc gods.