Why is C++ so much harder than Java?

[uperkurk]

I'm into my second year now at uni and after learning Java for the past year, the course is now introducing us to C++. We're still doing java but now C++ aswell.

I don't know if I'm the only one but C++ is sooooo much harder than java, today after just our second lesson we're being introduced to header files and coding our own. it took my 2 hours just to figure out how to right a program that read from a file, command line arguments and then added up the number of arguments and printed out the sum of those arguments.

The thing is our lecturer uploads the solutions to the problems 1 week after the problem was given to us, so I can always wait until the solution is provided and then try to piece together what is going on, but I just don't understand it.

Everything seems to be moving at such a fast past and I'm just slipping behind, I'm 1 week behind so far and tomorrow is the next exercise and I still can't complete last weeks one :/

 

[phinds]

Is there a question in here somewhere or did you just need to get that off your chest?

 

[uperkurk]

Mainly just to get it off my chest lol. Also for someone to tell me that they were in my position and it's just a hurdle that you need to overcome and once you start doing more C++ you'll get used it it?

I don't know really =(

 

[rcgldr]

It took me 2 hours just to figure out how to write a program that reads from a file, command line arguments and then added up the number of arguments and printed out the sum of those arguments.

Seems the main issue here is pointers, and in this case, a pointer to an array of pointers to the arguments, often declared as a pointer to a pointer to a character ( ... , char **argv ) or sometimes as an array of pointers to characters ( ... , char *argv[] ). The end result is basically the same, since C / C++ treats arrays and pointers similarly.

 

[Whovian]

Pointers can be non-intuitive to the Java programmer.

But headers already after week 2? That's a little too accelerated.

 

[coalquay404]

Pointers can be non-intuitive to the Java programmer.

This has always mystified me since Java has pointers too: Java references are, in fact, just pointers.

In my experience there are a couple of things in particular that seem to blow Java programmers minds when they come to programming in C++:

• the lack of a garbage collector and the resultant necessity to engage in manual memory management for anything allocated on the heap;
• the ability to store actual objects - not just pointers or references to objects - as members in other objects.

The first isn't actually a problem since the advent of smart pointers and RAII mean that nobody beyond library writers should really need to worry about memory management. The second is fixed simply with practice.

 

[AlephZero]

But headers already after week 2? That's a little too accelerated.

You can't write any C++ (or even C) programs without using the predefined headers, and you can't write any non-trivial code that is sensibly stuctured without writing your own headers.

If you already know Java, this probably isn't a first programming course that spends two weeks explaining what "i = i + 1" means. I would have thought you would be meeting headers within in the first two hours, not the first two weeks.

 

[Hurkyl]

The first isn't actually a problem since the advent of smart pointers and RAII mean that nobody beyond library writers should really need to worry about memory management.

Of course, that doesn't stop some people from teaching/learning C++ from a 25-year old perspective on using the language.

Because of this, "I'm learning C++" can mean a very wide variety of things.

 

[rcgldr]

Pointers can be non-intuitive to the Java programmer.

This has always mystified me since Java has pointers too: Java references are, in fact, just pointers.

I think the syntax is part of the issue, since it doesn't consistently flow left to right:

char achar[]; // array of characters
char * pchar; // pointer to character
char ** ppchar; // pointer to pointer to character
char * papchar[]; // pointer to array of pointers to characters

Then there's the issue that pointers can be used similar to arrays:

... *(pchar + 1) is the same as ... pchar[1]

The syntax for pointer to function isn't obvious either:

int (*pfun)(void); // ptr to function wtih no parameters and returning integer

 

[pwsnafu]

Of course, that doesn't stop some people from teaching/learning C++ from a 25-year old perspective on using the language.

Because of this, "I'm learning C++" can mean a very wide variety of things.

Ah, the old days of programming when people said "I program in C++ because Java is too slow". I was just talking to a programmer who was saying "I program in Java because Ruby is too slow" :rofl:

 

[seaofghosts]

Yesterday I got lost in my own C++ code. I totally forgot WTF I was doing. So I hear ya... My two semesters of Java was a walk in the park compared to my first semester of C++!

But that means you're learning, too. :p

 

[jhae2.718]

I think the syntax is part of the issue, since it doesn't consistently flow left to right:

char achar[]; // array of characters
char * pchar; // pointer to character
char ** ppchar; // pointer to pointer to character
char * papchar[]; // pointer to array of pointers to characters

Then there's the issue that pointers can be used similar to arrays:

... *(pchar + 1) is the same as ... pchar[1]

The syntax for pointer to function isn't obvious either:

int (*pfun)(void); // ptr to function wtih no parameters and returning integer

Things like

[color=#B00040]char[/color] [color=#666666]*[/color]([color=#666666]*[/color]c[[color=#666666]10[/color]])([color=#B00040]int[/color] [color=#666666]**[/color]p);

get interesting...

 

[D H]

I think the syntax is part of the issue, since it doesn't consistently flow left to right:

That's because it doesn't flow left to right. For the most part, it flows right to left. In general it swings from center to right to left to right to left to ... You just have to get into the swing of things.

char const * foo;
// foo is a pointer to a const char.
// Simply read from right to left.

char * const bar;
// bar is a const pointer to a char.
// Once again, just read right to left.

int *(*baz(double red_herring))[];
// baz is a pointer to a function that takes a double and
// returns a pointer to an array of pointers to integers.
// Now we really do need to get into the swing of things.
// How to read this:
//   1. Find the identifier: It's baz. That "red_herring" is a red herring.
//      baz is ...
//   2. Read to the right: ... a function that takes a double.
//   3. Stop at the unbalanced close paren and read to the left: 
//       ... a pointer to a function that takes a double ...
//   4. Stop at the open paren, swing back to reading to the right:
//      ... that returns an array ...
//   5. Stop at the semicolon, swing back to reading to the left:
//       ... of pointers to integers.
// Easy-peasy! :)

 

[D H]

Things like

[color=#B00040]char[/color] [color=#666666]*[/color]([color=#666666]*[/color]c[[color=#666666]10[/color]])([color=#B00040]int[/color] [color=#666666]**[/color]p);

get interesting...

c is an array of 10 function pointers each of which takes a pointer to a pointer to an int as an argument and returns a pointer to a char.

 

[rcgldr]

char const * foo;
// foo is a pointer to a const char.
// Simply read from right to left.

Except this is also allowed:

const char * foo;
// foo is a pointer to a const char.

There's also two ways of accessing members via pointers to structures or classes:

(*pobject).member or pobject->member

Then C++ added another alternative with function parameters accessed by reference

using pointer:

    fun(&object);
// ...
void fun (OBJECT * pobject)
{
...  pobject->member  ...
}

using reference.

    fun(object);
// ...
void fun (OBJECT &object) // parameter is actually pointer to object
                          // allowing object to be modified by fun
{
...  object.member  ...
}

With reference method, you can't tell from the call if the function can modify object (pass by reference instead of pass by value), you have to look at the function or it's prototype, which could be located in a separate header file.

The classic mistake if(x = 1)... when you meant if(x == 1) ...

One of the cases where whitespace matters:

a+*ptr2b (a plus (*ptr2b))
a-*ptr2b (a minus (*ptr2b))
a**ptr2b (a times (*ptr2b))
a/*ptr2b (/* comments out all remaining code until */ if there is any)

 

[coalquay404]

Here's a strange pointer-related "feature" of C++. Suppose we define a five-element array of ints, a, to store the integers from 0 to 4. Everyone knows that the following prints '4' to stdout:

std::cout << a[4] << std::endl;

If you want to mess with someone's head, the same result can be achieved using the following code:

std::cout << 4[a] << std::endl;

You're well on your way to understanding pointers and arrays if you can wrap your head around why this works.

 

[D H]

That's a misfeature, not a feature, and it's an inherited misfeature from C. It's due to the extremely weak support in C for arrays. Unfortunately, this is one of the misfeatures that makes C a bit poor for scientific computing.

All in my opinion, of course.

 

[Mark44]

std::cout << 4[a] << std::endl;

Simple - here's the definition of that array.

 int 4[a] = {0, 1, 2, 3, 4};

 

[D H]

No. It's worse than that, Mark. 4[a] and a[4] as an lvalue or rvalue refer to exactly the same thing. It's because C treats the operator [] as syntactic sugar for pointer addition and deferencing. a[4] is just a sugar coated version of *(a+4), and 4[a] is just a sugar coated version of *(4+a).

 

[jhae2.718]

If you have a copy of Expert C Programming: Deep C Secrets, the commutativity of the subscript operator is discussed some on p. 243.

 

[rcgldr]

In general it swings from center to right to left to right to left to ... You just have to get into the swing of things.

int *(*baz(double red_herring))[];

My favorite post in this thread.

Getting back to the OP, once you get past the terse syntax of C / C++ and perhaps the STL (standard template library) that your class may get into later on, you'll find the actual programming to be similar to what you would do with any programming language.

 

[Ben Niehoff]

C is a logical, if complex, language. Everyone complains about pointers, but once you get the concept, really it is just a simple idea that can be chained together into more complex things.

C++, on the other hand, is an unholy beast. It's a mashed-together conglomeration of both procedural and object-oriented ideas, and there are way too many fiddly details about the implementation of the language that must be memorized in order to write in it effectively. Seriously, what is the need for both references and pointers?

If speed is critical in your application, use plain C. If you like doing things object-oriented, use Java or some other high-level language.

 

[coalquay404]

... there are way too many fiddly details about the implementation of the language that must be memorized in order to write in it effectively.

Such as?

Seriously, what is the need for both references and pointers?

There are several reasons why references are a good idea. Here's two off the top of my head:

• For safety reasons, when using pointers you need to be obsessive about checking for nulls; references are guaranteed to always be non-null.
• References give you a straightforward way of implementing operator overloading.

 

[Whovian]

I'd say that C++ is, well, a cover-all language, which tries to allow for a lot of paradigms and sub-paradigms. I will agree, it can get unnecessarily mashed-up at times, and the lack of memory management can be a little annoying.

All languages equal in their own right, C++ is my personal favourite, so I'll try to point out the good parts and gloss over the flaws, since that's what I do with stuff I like. Multiple Inheritance is confusing and rarely useful, but when it is useful, it's useful. The more common alternative, which uses interfaces, is still possible in C++. The closest to templates I've seen in another language is Objective-C's dynamic typing.

But, yea. It can be bulky and unwieldy.

 

[D H]

Getting back to the OP, once you get past the terse syntax of C / C++ and perhaps the STL (standard template library) that your class may get into later on, you'll find the actual programming to be similar to what you would do with any programming language.

I disagree. Every language has its own idioms, its peculiar way of doing things. One of the key obstacles to learning a new language is to learn how to write in the vernacular of that language as opposed to force-fitting the idioms of some other language onto the language at hand. An even bigger issue is that some languages are fundamentally very different from one another. A pure functional language is very, very different from a procedural language.

C++, on the other hand, is an unholy beast. It's a mashed-together conglomeration of both procedural and object-oriented ideas

That's not quite fair. OO is always going to be on top of some other programming paradigm, be it procedural (Java, C++, ObjectiveC), functional (Haskell, CLOS), or logical (Logtalk).

Seriously, what is the need for both references and pointers?

Do C++ the modern, RAII way and you won't use very many pointers. The C++ standard library provides a number of mechanisms that in many cases eliminate the need for pointers. Needing a pointer is a bit of a code smell. Needing a void* pointer is worse than code smell. The ubiquity of void* in C versus its absence in well-written C++ is one of the key features that distinguish the two languages.

I'd say that C++ is, well, a cover-all language, which tries to allow for a lot of paradigms and sub-paradigms.

That mish-mash just got bigger with C++11. C++03 functors started to give a bit of a functional programming flavor to the language. Lambda expressions and closures sealed the deal. The new standards makes C++ have aspects of procedural programming, object oriented programming, generic programming, meta programming, functional programming, and multiprocessing. All that's missing is logic programming.

and the lack of memory management can be a little annoying.

Smart pointers take care of a lot of those memory management problems, and do so without needing a garbage collector.

The closest to templates I've seen in another language is Objective-C's dynamic typing.

The closest thing is Ada generics. The same two people, David Musser and Alexander Stepanov, who developed Ada generics also strongly influenced how C++ templates work and developed the bulk of the STL. Interestingly, Stepanov is fervently anti-OO: "I think that object orientedness is almost as much of a hoax as Artificial Intelligence."

But, yea. It can be bulky and unwieldy.

I can't argue with that.

 

[rcgldr]

Getting back to the OP, once you get past the terse syntax of C / C++ and perhaps the STL (standard template library) that your class may get into later on, you'll find the actual programming to be similar to what you would do with any programming language.

I disagree. Every language has its own idioms, its peculiar way of doing things. One of the key obstacles to learning a new language is to learn how to write in the vernacular of that language as opposed to force-fitting the idioms of some other language onto the language at hand.

I was thinking along the lines of the simple tasks in a classroom environment, such as reading and writing files, sorting arrays, ... , the type of things he may have already done in Java . I'm not sure if the OP's class is going to involve the more advanced features of C++, and it's not like he's moving from Java to a declarative language or some obscure language like APL.

 

[jhae2.718]

..C++, on the other hand, is an unholy beast...

If speed is critical in your application, use plain C. If you like doing things object-oriented, use Java or some other high-level language.

I'm tempted to agree with you w.r.t. C++, but it does have its uses. But Java? Not even once!

C was my first language, and is probably my favorite. Python and Go are also near the top for me, and MATLAB is a necessary evil.

Begun, the language war has.