How to solve pointer errors?

You need to alloc memory for pointers. This code should work:

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

int sum(int *a ,  int *b);
int main()
{
    int *p = (int*) malloc(sizeof(int));
    int *q = (int*) malloc(sizeof(int));
    if (p != NULL && q != NULL)
    {
        *p =10;
        *q =10;
        int c = sum(p,q);
        printf("%d", c);
        free(p);
        free(q);
    }
    else
    {
         printf("Could not allocate enough memory");
         return 1;
    }

    return 0;
}

int sum(int *a , int *b)
{
    return (*a) + (*b);
}

Hope this helps!

A pointer is a variable that holds the address of another variable, and this seems clear to you. But what seems not still very clear is that when you create a pointer the compiler doesn't automagically create also a variable to point to...

In code:

int *p;
int *q;
*p =10;
*q =10;

You are defining p and q as pointers to int, but to which variables of type int they point? They have a garbage inside and can point anywhere, so when assigning 10 to what they point to, in reality, you are spamming somewhere in memory.

Under these conditions when you call sum I would expect more a memory fault than a strange value (255), but everything can happen with bad pointers, even to access an existing memory.

The correct code is:

int sum(int *a ,  int *b);

int main()
{
    int i1, i2;      //Allocate 2 int variables
    int *p = &i1;    //Create pointers and assign them
    int *q = &i2;    //the address of int vars i1 and i2
    *p =10;          //Initialize variables pointed by pointers with 10
    *q =10;
    int c = sum(p,q);
    printf("%d",c);
}

int sum(int *a , int *b)
{
    return((*a)+ (*b));
}

A pointer needs to be assign the address of some valid memory to point to before it may be dereferenced of the *-operator and gets written some data to where it points to.

You miss those very assignments.

Dereferencing a pointer implies reading out its value. If no value ever had been assigned to a pointer variable, already reading out its value might invoke the infamous Undefined Behaviour, anything can happen after this.

So your result could also have been just the famous 42.

Lesson learned: Never apply any operator to a variable which had not been properly been initialised.

Another approach. I think it may be useless for return function but it can help you about pointers It is passing pointer to the sum function

#include <stdio.h>

int sum(int *a ,  int *b);
int main()
{
    int p = 10;
    int q = 10;

    int c = sum(&p,&q);
    printf("%d",c);
}
int sum(int *a , int *b)
{

    return((*a)+ (*b));
}

You're getting 255 is because of random luck. I get 20 when I compile it, but that's also random luck. The technical term is "undefined behavior", and this is undefined because you never initialized your int *p and int *q pointers.

What's inside your pointer variables? You don't know, I don't know, nobody does. Since you never initialized them, their contents are whatever bits were there before initialization. It's like moving into a house and getting whatever junk the previous tenants left for you.

If the contents of the pointers are addresses in memory (and they don't overlap), then the value returned should be 20 (by random luck). But if one of them contains a null address, who knows what you'll get!

If you want to get 20 reliably, you need to allocate memory:

In C++:

int * p = new int;
int * q = new int;

In C:

int * p = (int*)malloc(sizeof(int))
int * q = (int*)malloc(sizeof(int))