Thread: char pointers/app won't work

This does NOT allocate enough space.

Code:

char* ptrB=malloc(sizeof(char*));

strlen() +1 should be enough.

Tim S.

1) To be blunt, it doesn't work because you coded it incorrectly, without understanding the difference between pointers and strings. The selectLower() function returns a pointer to the terminating zero character in the allocated string (or, at least, it attempts to - but the incorrect malloc() call breaks other things). Since printf("%s", anystring) stops writing when it encounters a char with value zero, no output will be produced.

2) The malloc() call is incorrect. sizeof(char*) yields the size of a pointer. That is a fixed value (albeit compiler dependent) - the value is typically 2 on a 16-bit system, 4 on a 32-bit system, and 8 on 64-bit system. Since the string in main() is longer than 8 characters, your code will overrun that buffer. The length you supply if you want to represent a string needs to be at least the maximum length of the string that will be stored, plus one (for the zero terminator). If you only want the allocated memory to be the number of lowercase letters then, yes, you need to count the lowercase letters. Note: the number of lower-case letters in a string never exceeds the length of that string.

3) The cause of overwriting your original string is probably the buffer overrun (strictly speaking, anything is allow to happen because of that, but overwriting your original string is one possibility). Correct the problems I've pointed out, making use of the hints I've included, and your problems will go away - unless you introduce another coding problem when doing so.

4) Your code causes a leak, since the result of a malloc() call is not matched with a free().

Still a memory leak.

One characteristic of your code is that it is working with arrays, but obscuring that behind pointer syntax. The code can probably made more readable by using array syntax.

Having expressions with multiple side-effects also makes things less readable - for little or no benefit.

You might also want to look up the islower() function.

Originally Posted by esbo

I don't think the memory 'leak' will be a problem for the OP's code.
Windows programs release memory on program termination, however it's good practise to release memory when you don't
need it as it may cause problems in the future if the code is modified.
However it's going to take a lot of strings to fill up 2gig+ of memory!!!

That sort of rubbish (note that I didn't use an expletive, even though I consider it warranted) and lazy attitude is why so many memory leaks occur in production code. It's not a problem, until the same thing is done in a setting where it is a problem. But, having been told it's not a problem, the programmer overlooks it.

Not all programs run on top of a windows or linux operating system, and not all terminate immediately after leaking so the operating system can clean up. There is probably more code being written for embedded devices (some with and some without any host operating system at all) or for "apps" that never terminate, so their memory leaks are never cleaned up.

Originally Posted by coffee_cup

Hm did I misuse pointers with char arrays in some way? Or did you just mean that this prog could have been done without pointers too?

By definition, if a program works as intended with pointers, they are not being misused. But, yes, the program could have been done without using pointer syntax. Given a choice of approaches that each produce a required result, it is usually a good idea to pick the one that is more likely to be understood by most people. Bear in mind that more people have difficulty understanding pointers properly than they do understanding arrays).

Originally Posted by coffee_cup

which ones?

There is one assignment, two pointer dereferences, and two side effects in this statement

Code:

    *(ptrA++)=*(s++);

Originally Posted by coffee_cup

Hm did I misuse pointers with char arrays in some way? Or did you just mean that this prog could have been done without pointers too?

When a function allocates memory, one helpful convention is to decorate the function in some way so that you remember to free it. Here is one example

Code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* newLowString(char* s);
void delLowString(char* s);

int main()
{
	char string[]="This is a TestString";
	char *t = newLowString(string);
	printf("%s", t);
	delLowString(t);
	return(0);
}

char* newLowString(char* s)
{
	char *retval=malloc(strlen(s)+1);
	char *ptrA = retval;

	while (*s!='\0')
	{
		if (*s >= 'a' && *s <= 'z')
		{
			*(ptrA++)=*(s++);
		} else {
			s++;
		}
	} 
	*ptrA='\0';

	return retval;
}

void delLowString(char *s) {
	free(s);
}

Now one can look at the code from main and see that it is correct, without considering the details of what goes on inside of your functions. Whenever you call newLowString, you must eventually call delLowString, and that is a simple rule to follow. You can see a similar idiom in many libraries. For example, if you do fopen(), you should follow it with fclose() later. Don't make excuses like that the OS will do it for you. Be a good boy or girl and clean up after yourself.