Thread: mallocing with outside pointers

Use a pointer to a pointer:

Code:

int foo( int ** v )
{
    *v = malloc( ... );
}

Or do it the same way malloc does, and return the pointer.

[edit] Fixed variable name mismatch. Damn phones anyway... [/edit]

Quzah.

Code:

// This is where you want to double pointer.
int html_createstarttag(char **dest, char tag[]) {
    *dest = malloc( strlen(tag) + 3 );

    // Notice we have to dereference the pointer-pointer to get the pointer to the char data (the string).
    sprintf(*dest, "<%s>", tag);

    return 0;
}

// why is src a double pointer? I think you meant just one.
int html_findstarttag(char **src, char tag[]) {
    char *search;
    int tmp;
    
    html_createstarttag(&search, tag);
    tmp = str_whereisstring(src, search);
    free(search);
    
    return tmp;
}

Code:

int html_createstarttag(char *dest, char tag[]) {
    *dest = malloc( strlen(tag) + 3 );

    sprintf(**dest, "<%s>", tag);

You are trying to do two different things. First off, your function only takes a pointer to a char. Then you try to malloc to that char, which is really only a reference to the original pointer. It will not update what the original pointer points to.

Use this example:

Code:

void fun( char ** c )
{
    *c = malloc( 30 );

    sprintf( *c, "hello!" );
}

int main( void )
{
    char *ptr;

    fun( &ptr );
    printf("Outside 'fun': %s\n", ptr );
    free( fun );

    return 0;

}

That should illustrate what you need.

Quzah.

Because that's the way it works. It's just like when you pass a variable by value. It makes a copy of it and passes it to the function. Pointers basicly work the same way. Getting the address of a variable which is the argument of a function won't give you the same one as the non-local variable.

As such, you cannot update what the pointer points at. Consider the following:

Code:

void foo( char * ptr )
{
    printf("The address of ptr is %p.\n", &ptr );
}

int main( void )
{
    char * c;

    foo( c );
    printf("The address of c is %p.\n", &c );
    return 0;
}

There's your answer.

[edit] Damnit, that's twice I've been beaten to the reply. [/edit]

Quzah.

Look at my example again. If you are trying to set a pointer outside a function, to something new inside the function, then you need to pass a pointer to the pointer you want to change. Otherwise, you cannot change what the pointer is pointing at.

Code:

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


void fun1( char * c )
{
	c = malloc( 6 );
	strncpy( c, "hello", 6 );

	printf("%s\n", c );
	printf("'c' outside of this function still points to NULL.\n");
	printf("Memory leak in progress...\n");
}

void fun2( char **c )
{
	*c = malloc( 6 );
	strncpy( *c, "Hola!", 6 );
	printf("%s\n", *c );
	printf("'c' outside of this function now points to allocated memory.\n");
}

int main ( void )
{
	char *c = NULL;

	printf("'c' points to %p\n", c );
	printf("Calling fun1.\n");
	fun1( c );

	printf("\n'c' points to %p\n", c );
	printf("Calling fun2.\n");
	fun2( &c );

	printf("'c' points to %p\n\n", c );
	printf("'c' is %s\n", c );
	free( c );

	return 0;
}

In the first function, you just pass a pointer. The pointer doesn't point at anything. You try and make it, but since you're really using a copy of the pointer, you can't change the actual pointer itself.

This is exactly the same thing that happens with any other variable passed by reference. You cannot change that variable. The difference, and your source of confusion, is that with a pointer, you can change what that pointer points at.

Since this pointer has nothing it points to, there is nothing to change.

The second function, we pass a pointer to that pointer. Now you can make that pointer point to something else, because you're using a pointer to it to do it.

Remember above: you can change what a pointer points at.

Since you have a pointer that points at another, you change what it points to. Here, we make that pointer point to newly allocated memory.

Quzah.