Learning C: what's wrong in my pointer code?

Here's a corrected version of the program with some annotation:

#include <stdio.h>

int main(void) // int and (void) for standard mains.
{
  int k = 10;
  char *string; // a C string is a char array, you need a pointer to point to it
  char *sptr;
  int *ptr;

  string = "hello!";

  sptr = string;
  ptr = &k;

  printf("%s \n", sptr); // no &. The %s format expects a char*.
  printf("Sending pointer.\n");

  // sendptr(ptr, sptr);  // don't know what this function is, ignoring

  return 0;
}

In C language, the & operator means you want to use the address of the variable (ie & = "the address of the variable").

int an_integer=2; // an_integer is a memory part where you want to store 2 ;)

printf("%d", &an_integer); // here you will print the address of the memory part where an_integer is stored (not 2, more  something like 2510849).

The * operator in a declaration of variable means that you want to have a pointer to a memory part, when using it in the code, it means the "the value contained at the address of"

int an_integer=2;
int *ptr_integer; // you declare a pointer to an integer

ptr_integer = &an_integer; // here you set the pointer ptr_integer to the address of an_integer

printf("%d", *ptr_integer); // here you print the value contained at the memory address stored in the ptr_integer

The [] operator means you want to store an array of something. In C, an array can be seen as a pointer to a memory space.

int an_integer[2]; // you declare an array of 2 integers
int *ptr_integer; // you declare a pointer to an integer

ptr_integer = (int *)an_integer; // here you set the value of the pointer to the address of the array, you have to cast it into an (int *) to avoid compilation warnings.

For a start, I would suggest changing:

char string;

to:

char *string;

It's pretty clear that you want the string variable to be a string rather than a single character.

In addition, you probably want to change the two lines:

sptr = &string;
printf("%s \n", &sptr);

to:

sptr = string;
printf("%s \n", sptr);

but you could equally well just pass string itself to printf.

As for the sendptr(ptr, sptr);, we can't help that much without knowing more details about it.

To fix your second function (from your edit), change:

char fnamn[] = &fname;

to:

char *fnamn = fname;

or just use fname directly. You don't have to make a copy of the pointer and the former is for things like:

char fnamn[] = "I am a string literal";

I thought it might be helpful to adding something about the difference between a char array and a pointer to a string.

In function1 below, the local variable stringPtr is a pointer to memory which contains the string "hello!". The memory containing this string will be located in a read-only section of the program. The compiler decides where to place the string "hello!" and ensures that your local variable is initialised with this memory address.

You can modify the pointer stringPtr and change it to point somewhere else. But you cannot modify the memory it points at.

Also, it is perfectly valid to use the array access notation stringPtr[2] even though it is a pointer.

In function2 the compiler will set aside 9 bytes of space on the stack for the local variable stringArray and it will ensure that this array is initialised with the string "Goodbye!". As this memory is on the stack you can modify the contents of the array.

#include <stdio.h>

void function1(void)
{
  char *stringPtr = "hello!";

  printf("The first char is %c\n", stringPtr[0]);

  printf("The next char is %c\n", *(stringPtr+1));

      // This would cause a segmentation fault, stringPtr points to read-only memory
      // stringPtr[0] = 'H';
}

void function2(void)
{
  char stringArray[] = "Goodbye!"; 
  printf("The first char is %c\n", stringArray[0]);
}

int main(void)
{
  function1();
  function2();
  return 0;
}

First of all, the return type for main should be int, not void. void main() is only well-defined if your compiler documentation explicitly lists it as a legal signature. Otherwise you invoke undefined behavior. Use int main(void) instead.

Secondly, it's time for a quick crash course on strings, arrays, and pointers.

Unlike Java, C doesn't have a dedicated string datatype; rather, strings are represented as sequences of char values terminated by a 0. They are stored as arrays of char. The string literal "hello" is stored as a 6-element array of char (const char in C++). This array has static extent, meaning it is allocated at program startup and held until the program terminates. Attempting to modify the contents of a string literal invokes undefined behavior; it's best to act as though they're unwritable.

When an array expression appears in most contexts, the type of the expression is converted from "N-element array of T" to "pointer to T", and the value of the expression is the address of the first element of the array. That's one of the reasons the string = "hello"; statement doesn't work; in that context, the type of the expression "hello" is converted from "6-element array of char" to "pointer to char", which is incompatible with the target type (which, being char, isn't the correct type anyway). The only exceptions to this rule are when the array expression is an operand of either the sizeof or unary & operators, or if it is a string literal being used to initialize another array in a declaration.

For example, the declaration

char foo[] = "hello";

allocates foo as a 6-element array of char and copies the contents of the string literal to it, whereas

char *bar = "hello";

allocates bar as a pointer to char and copies the address of the string literal to it.

If you want to copy the contents of one array to another, you need to use a library function like strcpy or memcpy. For strings, you'd use strcpy like so:

char string[MAX_LENGTH];
strcpy(string, "hello");

You'll need to make sure that the target is large enough to store the contents of the source string, along with the terminating 0. Otherwise you'll get a buffer overflow. Arrays in C don't know how big they are, and running past the end of an array will not raise an exception like it does in Java.

If you want to guard against the possibility of a buffer overflow, you'd use strncpy, which takes a count as an additional parameter, so that no more than N characters are copied:

strncpy(string, "hello", MAX_LEN - 1);

The problem is that strncpy won't append the 0 terminator to the target if the source is longer than the destination; you'll have to do that yourself.

If you want to print the contents of a string, you'd use the %s conversion specifier and pass an expression that evaluates to the address of the first element of the string, like so:

char string[10] = "hello";
char *p = string;

printf("%s\n", "hello");  // "hello" is an array expression that decays to a pointer
printf("%s\n", string);   // string is an array expression that decays to a pointer
printf("%s\n", p);        // p is a pointer to the beginning of the string

Again, both "hello" and string have their types converted from "N-element array of char" to "pointer to char"; all printf sees is a pointer value.

Here's a handy table showing the types of various expressions involving arrays:

Declaration: T a[M];

Expression         Type            Decays to
----------         ----            ---------
         a         T [M]           T *
        &a         T (*)[M]
        *a         T
      a[i]         T
     &a[i]         T *

Declaration: T a[M][N];

Expression         Type            Decays to
----------         ----            ---------
         a         T [M][N]        T (*)[N]
        &a         T (*)[M][N]     
        *a         T [N]           T *
      a[i]         T [N]           T *
     &a[i]         T (*)[N]
     *a[i]         T 
   a[i][j]         T
  &a[i][j]         T *

Remember that the unary & operator will yield the address of its operand (provided the operand is an lvalue). That's why your char fnamn[] = &fname; declaration threw up the "invalid initializer" error; you're trying to initialize the contents of an array of char with a pointer value.

The unary * operator will yield the value of whatever its operand points to. If the operand isn't pointing anywhere meaningful (it's either NULL or doesn't correspond to a valid address), the behavior is undefined. If you're lucky, you'll get a segfault outright. If you're not lucky, you'll get weird runtime behavior.

Note that the expressions a and &a yield the same value (the address of the first element in the array), but their types are different. The first yields a simple pointer to T, where the second yields a pointer to an array of T. This matters when you're doing pointer arithmetic. For example, assume the following code:

int a[5] = {0,1,2,3,4};
int *p = a;
int (*pa)[5] = &a;

printf("p = %p, pa = %p\n", (void *) p, (void *) pa);
p++;
pa++;
printf("p = %p, pa = %p\n", (void *) p, (void *) pa);

For the first printf, the two pointer values are identical. Then we advance both pointers. p will be advanced by sizeof int bytes (i.e., it will point to the second element of the array). pa, OTOH, will be advanced by sizeof int [5] bytes, so that it will point to the first byte past the end of the array.

#include <stdio.h>

void main()
{
  int k = 10;
  char string;
  char *sptr;
  sptr = "hello!";  

  int *ptr;

  ptr = &k; 
  printf("%s \n", sptr);
  printf("Sending pointer.\n");

  sendptr(ptr, sptr);
}