Question about my trim function and pointers

Hey, I wrote this function to eliminate all leading and trailing spaces from a string..

Code:

void trim(char** str) {
	char ptr[strlen(str)+1];
	int i = 0, j = 0;
	while (isspace(str[i]) == 1) {
			i++;
		}
	while (str[i] != '\0') {
		ptr[j++] = str[i++];
	}
	ptr[j] = '\0';
	int n = strlen(ptr);
	while (--n >= 0) {
		if (isspace(ptr[n]) == 0) {
			break;
		}
	}
	ptr[n+1] = '\0';
	str = ptr;
}

..and have a quick question about ways of using it, I know to call the above I should:

Code:

char *aString = " trim this string ";
trim(&aString);

right? due to the passing by reference thing.. but i was thinking if the following changes were made, the result will be exactly the same? just hoping someone can affirm my thoughts.

Code:

char *trim(char* str) {
/* trim code.. */
return str;
}

aString = trim(aString);

is one way better style than the other?

thanks.

That isn't exactly C compliant... but as long as your C++ compiler is cool with it, I guess I will let it slide. Well firstly, you can't use an = sign to fill a string buffer. Secondly, I recommend doing the bottom one, only because you can always add error checking and have the errors lead to returning NULL if something goes horribly awry.

i just edited my code and posed the question a little differently

char *aString = " trim this string ";

aString should be declared as const and cannot be modified

Originally Posted by vart

aString should be declared as const and cannot be modified

what, i can't modify it, meaning i can't use my function on it?

That isn't exactly the case you presented that I agreed to. Your code was initially something to the tune of:

Example

Code:

char aString[20] = "     sloppy string    ";

char *trim(char *);  // was the one I called "a good idea"

Which is the way to do it. A string literal is always going to be a constant value that can cause pandora's box to be thrust open upon altering. The double indirection is not necessary for your trim function. The parameter is a pointer, you aren't going to be altering the pointer itself, so you may as well not complicate your code with extra dereferencing.

Originally Posted by space-oddity

what, i can't modify it, meaning i can't use my function on it?

You can, as I said... but you will have to face the consequences of opening pandora's box. And between you and me.... you don't want the box.

okay, thanks. so the code at the bottom of the first post is the way to go?

I believe so for no other reason than error handling. Since you can't throw exceptions or anything in C you should just have errors returned by the function (when possible). In this case lets say the user passes in 0, then having an return value would help the developer debug and know "oh duh, I must've passed in 0 to begin with. Where is malloc() not called." Right?

Originally Posted by space-oddity

what, i can't modify it, meaning i can't use my function on it?

If you did this:

Code:

char aString[20] = "     sloppy string    ";

then you can modify it.
However, if you did this:

Code:

char *aString = " trim this string ";

then you cannot (or at least, you shouldn't) modify it, because it points to a literal string constant which (depending on compiler/platform) could be stored in Read Only memory.

Also note how your first example is wrong (you should at least get a warning). You are trying to assign an array (one pointer) to a pointer-to-pointer. They are not the same types. As you know, to get the original value, you must dereference the pointer first, so you'd do something like *pOriginal = ptr.
However, now we get another problem. pOriginal would point to your array inside the function which is placed on the stack. Therefore, that array will be cleaned up and destroyed once the function ends and pOriginal will point to garbage afterwards.