Thread: Questions..

>> is that legal?

No. The result is undefined. The string should be treated as constant.

>> also, does it matter where you put the "*" at all when it is used?

Whitespace is ignored between tokens in C, so you could even get away with "int*pointer"

Originally Posted by argv

Hello.

I can't get this to work:

Code:

argv[1]=strcat(argv[1], ".dat");

is that legal?

also, does it matter where you put the "*" at all when it is used? Whether it be a dereference operation, function entrance, array of memory addresses, or anything else? (besides it has to be in the right order..)

is "argv* []" the same as "argv *[]" and so on?
is "int * pointer" the same as "int* pointer" and "int *pointer"?

I guess thats it for now. Thanks!

All of these have the same meaning

Code:

int *p;
int* p;
int * p;

But it is always safer to use int *p. For eg. when sevearl pointers are to be declared simultaneously. int *p,*q,*r.

Just as you would with any other constant string - copy it.

Originally Posted by Sebastiani

No. The result is undefined. The string should be treated as constant.

No, the strings accessible via argv are modifiable. However, there is still undefined behaviour, but for a different reason: the concatenation results in ".dat" being appended, but argv[1] does not (or more accurately: might not) have any space to contain the extra 4 characters. As such, copying argv[1] to an array with sufficient space is a correct solution.

>> No, the strings accessible via argv are modifiable.

Well of course it is, as it "belongs" to the program you are free to modify it as you wish, but the OP wanted to append to it (which would be a very bad idea for the exact reason that you pointed out). But yes, to be sure, you're explanation is more clear on the matter, but I still recommend that the practice be avoided, as it error prone (for beginners, at least).

Originally Posted by Sebastiani

>> No, the strings accessible via argv are modifiable.

Well of course it is, as it "belongs" to the program you are free to modify it as you wish,

Somebody is changing their tune!

Originally Posted by argv

Something like this?

Somewhat, except that you do not know if argv[1] actually has less than 20 characters, so strcpy() risks buffer overflow. Something like this might be better:

Code:

if (argc > 1)
{
    const char extension[] = ".dat";
    char *name = malloc(strlen(argv[1]) + sizeof(extension));
    if (name)
    {
        strcpy(name, argv[1]);
        strcat(name, extension);

        /* ... */

        free(name);
    }
    else
    {
        /* Report memory allocation error */
    }
}
else
{
    /* Report missing command line argument */
}

EDIT:

Originally Posted by BEN10

But it is always safer to use int *p. For eg. when sevearl pointers are to be declared simultaneously. int *p,*q,*r.

It would be even safer to avoid declaring multiple pointers (or possibly even multiple variables) on the same line.

Originally Posted by argv

Sweet, I'll use that style then.

I tend to follow that style when writing C, but read Is ``int* p;'' right or is ``int *p;'' right?

Originally Posted by laserlight

Somewhat, except that you do not know if argv[1] actually has less than 20 characters, so strcpy() risks buffer overflow. Something like this might be better:

Code:

if (argc > 1)
{
    const char extension[] = ".dat";
    char *name = malloc(strlen(argv[1]) + sizeof(extension));
    if (name)
    {
        strcpy(name, argv[1]);
        strcat(name, extension);

        /* ... */

        free(name);
    }
    else
    {
        /* Report memory allocation error */
    }
}
else
{
    /* Report missing command line argument */
}

Ok, haven't gotten into the malloc command much yet, thats next quarter. If I throw that in, my teacher will know I stole it. haha

by the way, is: "char *name" the same as "char name[]";

Originally Posted by laserlight

EDIT:

It would be even safer to avoid declaring multiple pointers (or possibly even multiple variables) on the same line.


I tend to follow that style when writing C, but read Is ``int* p;'' right or is ``int *p;'' right?

I dunno, but I like 'int* p' for some wierd reason. I guess as long as your consistent, it doesn't matter.

>> char *name = malloc(strlen(argv[1]) + sizeof(extension));

That's correct, of course, but just a reminder to the OP that the length above is equivalent to strlen(argv[1]) + strlen(extension) + 1 (to allow room for the null terminator).

>> Somebody is changing their tune!

Not really. My explanation certainly wasn't as concise (or strictly accurate) as laserlight's, but it wasn't exactly incorrect, either.