Thread: This has really anoyed me

Originally Posted by two31d

Well... It's just as easy to write int = int + 1, instead of int++... What's the big deal?

Code:

char *v = "this is a C style string";
int sc = 0;

while (*v++)
{
    ++s;
}

vs.

Code:

char *v = "this is a C style string";
int sc = 0;

while (*v)
{
    v = v + 1;
    s = s + 1;
}

Although the two are computationally equivilent, the first is far more concise. If the instructors don't want you to use shorthand, why the heck are they teaching C++ in the first place? Do they skip over the use of "cout << variable" because students might confuse it with left shift operations?

The example is trivial, but I have other things to do.

Try this one:

Code:

std::list< int > ints;
ints.push_back(1); ints.push_back(2); ints.push_back(3);

for(std::list< int >::iterator it = ints.begin(); it != ints.end(); ++it) {
  std::cout << *it << ' ';
}

as opposed to the (supposedly) equivalent

Code:

std::list< int > ints;
ints.push_back(1); ints.push_back(2); ints.push_back(3);

for(std::list< int >::iterator it = ints.begin(); it != ints.end(); it = it + 1) {
  std::cout << *it << ' ';
}

Hi chrismax2

You'll be doing MT262 like me then.

edit>> Bear in mind that this is a low-level course. I don't even think we're going to hit pointers. I'm only doing it for the credits.

Coding standards are a fact of life. If you are going to whine that you can't use "insert favourite construct here" when your house standard says you can't, you'll be out of a job.

Also no programmer would be caught dead using x = x + 1; when you have things like ++ and x += 1;

Yes they would if they worked in a multi language code shop where the coding standards had been written to ensure that the majority of code written by the majority of coders in the majority of languages would understand what was going on.

x = x + 1;

Is pretty unambiguous regardless of your background.

Hey Robr

Good to hear from you, I will look out for you on the course site.

I got enough books, and as for adrianxw , I am not in a job and I don't have to agree with them if I dont want to. I just feel it's the wrong thing to do. Do you really agree with them yourself?

Yeah they dont even talk about pointers in the course, but then I got 8 different C++ books, so I can learn that through them. I kind of know them

Originally Posted by adrianxw

x = x + 1;

Is pretty unambiguous regardless of your background.

There are places where post increment and post decrement are very valuable, and not using them requires the addition of a temporary variable to hold the old value of the variable.

Also, with pointers, though it's equivilent, which looks clearer?

Code:

struct foo *ptr;

ptr=get_FirstFoo();
while (ptr != NULL)
{
    do_something(ptr);
    ptr++;
}

or

Code:

struct foo *ptr;

ptr=get_FirstFoo();
while (ptr != NULL)
{
    do_something(ptr);
    ptr = ptr + 1;
}

More people have trouble with explicit pointer arithmetic than have trouble with post-increment.

Coding standards, however, trump all. I've had to forego all sorts of things I like to use (function pointers, conditional expressions (cond?v1:v2), #defines (yes, #define, in C, is banned one place that I worked. Don't ask), and arrays (in C++). You must adhere to the coding standards set by your employer, even if you think they're stupid.

[edit]
I'm currently working at a place where the C coding standard requires casts wherever a "safe" type promotion might occur. There are some folks in the C programming forum who believe that an explicit type cast is an indication that the programmer is less than competant. (I'm not one of them.)
[/edit]

Originally Posted by jwenting

your example is contrived. It is never necessary to use x++, though x=x+1 might require more lines of code (which itself in many companies is a good thing because they judge programmer productivity based on the number of lines of code they produce).

Have you tried my example yet? There are classes that quite reasonably overload ++, but not += or +. Using x=x+1 with those results in a compile error.

yes, #define, in C, is banned one place that I worked. Don't ask

I do ask. How do you do symbolic constants then?

Originally Posted by jwenting

That is an error in the implementation of those classes, don't blame the operator for that...

No, it is not. It is a logical consequence of the fact that these classes, by design, do not support arbitrary jumps other than by repeatedly using increment. It makes sense, it's intuitive.
I don't blame the operator. I blame the assumption that every class implementing ++ must implement +=.

you don't. You define some globals and hope noone changes them.

That's not sufficient. You can't use globals as sizes for static arrays.

no class needs to use an operator for anything. Operator overloading is a luxury, not a necessity.

Completely irrelevant. Whether the method is called inc() or operator ++, whether it's called add() or operator +=, the principle is that there are cases when incrementing makes sense, but adding doesn't. Thus, having a ++ operator but not a += operator makes sense, and any coding standard that says it must be written as x=x+1 is ignoring that.