Confused with pointers and pass by reference

I never seem to be certain when to use the asterisk or the ampersand. I simply want the "new_mysql_connection" function to set the *conn in the main. So I am passing *conn to the function by reference. What am I doing wrong?

Code:

void new_mysql_connection(MYSQL *new_connection){
        char *server = "localhost";
        char *user = "myuser";
        char *password = "mypassword";
        char *database = "mydb";
        new_connection = mysql_init(NULL);
        /* Connect to database */
        if (!mysql_real_connect(new_connection, server,user, password, database, 0, NULL, 0))
        {
                        exit(1);
        }
}


main()
{
        MYSQL *conn;
        MYSQL_RES *result;
        MYSQL_ROW row;
        int num_fields;
        int i;


        new_mysql_connection(&conn);




        mysql_query(conn, "show tables");
        result = mysql_store_result(conn);


        num_fields = mysql_num_fields(result);


        while ((row = mysql_fetch_row(result)))
        {
                for(i = 0; i < num_fields; i++)
                {
                        printf("%s ", row[i] ? row[i] : "NULL");
                }
                printf("\n");
        }


        mysql_free_result(result);
        mysql_close(conn);
}

This function is expecting a pointer:

Code:

void new_mysql_connection(MYSQL *new_connection)

You declare that type of pointer in "main()":

Code:

MYSQL *conn;

So you should be sending the pointer to that function, not the address of that pointer:

Code:

new_mysql_connection(&conn);  // <--- remove the "address-of" operator (&)

Should I change the function to expect an address then? So that I can pass conn as an address...

By writing

Code:

new_mysql_connection(&conn);

it is like 'killing' the pointer
Remember that & 'kills' the *

Originally Posted by 50tonrobot

Should I change the function to expect an address then? So that I can pass conn as an address...

What is the problem if you pass it as Matticus said?

new_mysql_connection expects a pointer to MYSQL.
conn is a ponter to MYSQL.
Thus you wouldn't need the & operator and just pass conn (without &).

The problem is that pointers are also just passed by value. Thus if you change the pointer in the function, the pointer in main isn't changed.
There are 2 possibilities:
1) return the changed pointer from the function
2) rewrite the function so that it expects a pointer to a pointer to MYSQL (MYSQL **new_connection) and pass from main a pointer to conn (&conn). Of course you have to change all uses of new_connection inside the function too (you need to dereference it).

Bye, Andreas

Originally Posted by 50tonrobot

Should I change the function to expect an address then? So that I can pass conn as an address...

The function already does expect an address - and the pointer you declared in "main()" is the address. So send the pointer (which is an address) and not the address of that pointer (which would be the address of the variable which contains an address).

When I remove the ampersand; I get a segmentation fault at execution.

I would focus on line 6.It mays needs an *

I think option two works thanks!

Originally Posted by std10093

By writing

Code:

new_mysql_connection(&conn);

it is like 'killing' the pointer
Remember that & 'kills' the *

I think "killing the pointer" is misleading. If you use the & operator you construct a pointer to the object, in this case a pointer to a pointer.
& and * are complementary: & adds one "pointer level", * reduces one.

Bye, Andreas

Code:

int x;     // integer variable
int *ptr;  // integer pointer variable

ptr = &x;  // "ptr" is a pointer (to an address), so it should contain an address to point to;
           // the address of 'x' in this case

foo(ptr);  // for function:  void foo(int *pInt);
           // this function wants an integer pointer (which is an address), so we're sending it one;
           // "ptr" already contains the address of 'x'

foo(&x);   // this will do the same exact thing, because "ptr = &x"
           // we're sending it the address of 'x' just like the above example

Originally Posted by AndiPersti

I think "killing the pointer" is misleading. If you use the & operator you construct a pointer to the object, in this case a pointer to a pointer.
& and * are complementary: & adds one "pointer level", * reduces one.

Bye, Andreas

Could you explain a bit more please?With an example perhaps?

This seems to be the solution...

Code:

void new_mysql_connection(MYSQL **new_connection){
        char *server = "localhost";
        char *user = "myuser";
        char *password = "mypassword";
        char *database = "mydb";
        *new_connection = mysql_init(NULL);
        /* Connect to database */
        if (!mysql_real_connect(*new_connection, server,user, password, database, 0, NULL, 0))
        {
                        exit(1);
        }
}


main()
{
        MYSQL *conn;
        MYSQL_RES *result;
        MYSQL_ROW row;
        int num_fields;
        int i;


        new_mysql_connection(&conn);




        mysql_query(conn, "show tables");
        result = mysql_store_result(conn);


        num_fields = mysql_num_fields(result);


        while ((row = mysql_fetch_row(result)))
        {
                for(i = 0; i < num_fields; i++)
                {
                        printf("%s ", row[i] ? row[i] : "NULL");
                }
                printf("\n");
        }


        mysql_free_result(result);
        mysql_close(conn);
}

Originally Posted by std10093

Could you explain a bit more please?With an example perhaps?

Code:

#include <stdio.h>

int main(void)
{
    int i, *ptr1, **ptr2, ***ptr3;

    i = 10;
    ptr1 = &i;
    ptr2 = &ptr1;
    ptr3 = &ptr2;

    printf("%d\n", i == **ptr2);
    printf("%d\n", i == **&ptr1);
    printf("%d\n", *&i == ***ptr3);
    printf("%d\n", &i == **&*&ptr2);

    return 0;
}

If you can follow, you understand the relationship between * and & :-)

Basically *&i == i, because & and * cancel. For every & you add to an object, you need a * to get back.

EDIT: I just want to add that you can't use two adjacent &'s like &&i because & needs a lvalue but returns a rvalue (see this article for a discussion of lvalues and rvalues)

Bye, Andreas