Thread: Two style doubts ( do while and pointers )

Originally Posted by VelvetMirror

It isn't too much redundant ( code repeated )?, how would you do it?

I would use a do while loop. Notice that the argument of that style guide makes sense when the body of the loop has many lines. If you want to more faithfully follow it, you could do things like move the body of the loop into a function, then call the function twice. You could also make use of a flag variable that controls the while loop, but the flag would likely be set at the end of the while loop, thus negating the whole point of avoiding the use of a do while loop.

That said, if we consider a more developed form of your example, we might observe that we may wish to print a message if the user enters a number outside of the range, or possibly enters non-numeric input. Therefore, the loop might be changed to a controlled infinite loop to cater to this.

Originally Posted by VelvetMirror

So I should write also things like FILE* fp instead of FILE *fp?

It depends. If you are working with an existing code base that already follows a convention, or if your company/project has an established convention, then stick to that convention. Otherwise, the choice is yours, including the choice to follow this style guide. See Stroustrup's answer to the FAQ Is ``int* p;'' right or is ``int *p;'' right?

Originally Posted by compnub1

Maybe you can be the star in the middle like this for better style.

That is not better style, unless it is the convention used for existing code.

Bear in mind that style guides are completely subjective: get two style guide writers into a room, and you'll get to watch a never-ending debate.

Originally Posted by VelvetMirror

So a practical example:

Code:

     do {
        printf( "Write a number between 1 and 10: " );
        scanf( "%d%*c", &number );
    } while( ( number < 1 ) || ( number > 10 ) );

I should instead write:

Code:

    printf( "Write a number between 1 and 10: " );
    scanf( "%d%*c", &number );
    while( ( number < 1 ) || ( number > 10 ) ) {
           printf( "Write a number between 1 and 10: " );
           scanf( "%d%*c", &number );
    }

It isn't too much redundant ( code repeated )?, how would you do it?

Personally, I'd use a do-while loop. That's my style.

However, if I was required to comply with this style guideline, I'd use;

Code:

number = 0;   /*   Start with some number out of the required range */

while( ( number < 1 ) || ( number > 10 ) )
{
           printf( "Write a number between 1 and 10: " );
           scanf( "%d%*c", &number );
}

Note that I've put the curly braces in a different position too - again that's my stylistic preference

Personally, I disagree with the second guideline, whether I'm using C or C++. My reason is that it (sort of, arguably) implies that this;

Code:

float* x, y;

declares two pointers. However, y is not a pointer. So, in this case, I'd attach the asterix to the variable name;

Code:

float *x, y;

Of course, if another part of the style guideline requires only one variable be defined per statement, this sort of thing can be mitigated. But, with that sort of constraint, I consider the positioning of the asterix becomes completely irrelevant anyway.

do-while

If I was going for style, I'd use the do-while there. But in practice I stay away from them even when I shouldn't (I do the same with switch statements), just because I'm so used to seeing only while (or a string of if-else if) and it's easier for me to work through mentally. I guess that's something I ought to work on, so my code is more readable.

float* x; // NOT: float *x;
int& y; // NOT: int &y;

I prefer to have the asterisk next to the variable, for the reason that grumpy pointed out and because I think of the declaration like this:

Code:

int *x; //*x is an int

This is how I remembered how the pointer is referenced when I started C. I declared the variable the same way I would reference it later - if I need the value stored in x, I type *x, so int *x makes more sense to me.

For the same reason, I actually prefer the pass-by-reference style as

Code:

int& y; //y is an int

because you type 'y' when referring to the value stored.

EDIT: And all this talk about where things go makes me think of const. Oh, sweet 'demon of style' const.