Bdtjtk

I have two functions in my main function.

I've tried to accomplish this problem with pointers, but as a beginner, it is very complicated to work with this.

int main(){

  int *p;



  p = function_A();

  function_B(p);



  return 0; 

}



int function_A(){

  static int myArray[3];

  myArray[0] = 11;

  myArray[1] = 22;

  myArray[2] = 33;



  return myArray;

}



int function_B(int *myPointer){

  // Here I just want to print my array I've got from function_A() to the 

  // console



  printf("%d", *myPointer)

  return 0;

}

function_A should return a array and function_B should take this array.

Thanks!

Note: a reference to an array degrades to the address of the first byte of the array.

the following proposed code:

1. cleanly compiles


2. incorporates the comments to the question


3. assumes the programmer already knows the size of the array


4. performs the desired functionality


5. appended 'n' to format string of calls to printf() so output on separate lines

and now, the proposed code:

#include <stdio.h>





int * function_A( void );

void  function_B(int *myPointer);



int main( void )

{

  int *p;



  p = function_A();

  function_B(p);



  return 0; 

}





int * function_A()

{

  static int myArray[3];

  myArray[0] = 11;

  myArray[1] = 22;

  myArray[2] = 33;



  return myArray;

}



void function_B(int *myPointer)

{

  printf("%dn", myPointer[0]);

  printf("%dn", myPointer[1]);

  printf("%dn", myPointer[2]);

}

a run of the program produces the following output:

11

22

33

There are some issues your compiler will already have told you.
First, you should define the functions before calling them, or at least forward declare them.

Second, to return an array, you need to return a pointer to the first element of this array, i.e. return type is int * and not int.

Third, as FredK pointed out, when you receive just a pointer, you have no chance to determine how many elements are in the array it points to. You can either terminate the array with a specific value, e.g. 0, or you need to return the size of the array, too.

See the following adaptions made to your program:

int* function_A(int *size){

    static int myArray[3];

    myArray[0] = 11;

    myArray[1] = 22;

    myArray[2] = 33;



    if (size) {

        *size = 3;

    }

    return myArray;

}



void function_B(int *myPointer, int size){

    for (int i=0; i<size; i++) {

        printf("%dn", myPointer[i]);

    }

}



int main(){

    int *p;



    int size=0;

    p = function_A(&size);

    function_B(p,size);



    return 0;

}

Let's say you have a function that creates an array of ints:

int *create_int_array(const size_t num)

{

    int    *iarray;

    size_t  i;



    if (num < 1)

        return NULL; /* Let's not return an empty array. */



    iarray = malloc(num * sizeof iarray[0]);

    if (!iarray)

        return NULL; /* Out of memory! */



    /* Fill in the array with increasing integers. */

    for (i = 0; i < num; i++)

        iarray[i] = i + 1;



    return iarray;

}

Let's say tou have a function that calculates the sum of the integers in the array. If we ignore any overflow issues, it could look like this:

int sum_int_array(const int *iarray, const size_t num)

{

    int    sum = 0;

    size_t i;



    /* Sum of an empty array is 0. */

    if (num < 1)

        return 0;



    for (i = 0; i < num; i++)

        sum += iarray[i];



    return sum;

}

Note that sizeof is not a function, but a C language keyword. Its argument is only examined for its size. Thus, sizeof iarray[0] yields the size of each element in iarray, and is completely safe and valid even if iarray is undefined or NULL at that point. You see that idiom a lot in C programs; learn to read it as "size of first element of iarray", which is the same as "size of each element in iarray", because all C array elements have the exact same size.

In your main(), you could call them thus:

#ifndef  NUM

#define  NUM  5

#endif



int main(void)

{

    int  *array, result;



    array = create_int_array(NUM);

    if (!array) {

        fprintf(stderr, "Out of memory!n");

        exit(EXIT_FAILURE);

    }



    result = sum_int_array(array, NUM);



    printf("Sum is %d.n", result);



    free(array);



    return EXIT_SUCCESS;

}

As you can see, there is really not much to it. Well, you do need to get familiar with the pointer syntax.

(The rule I like to point out is that when reading pointer types, read the specifiers from right to left, delimited by * read as a pointer to. Thus, int *const a reads as "a is a const, a pointer to int", and const char **b reads as "b is a pointer to a pointer to const char".)

In this kind of situations, a structure describing an array makes much more sense. For example:

typedef struct {

    size_t  max;   /* Maximum number of elements val can hold */

    size_t  num;   /* Number of elements in val */

    int    *val;

} iarray;

#define  IARRAY_INIT  { 0, 0, NULL }

The idea is that you can declare a variable of iarray type just as you would any other variable; but you also initialize those to an empty array using the IARRAY_INIT macro. In other words, thus:

    iarray  my_array = IARRAY_INIT;

With that initialization, the structure is always initialized to a known state, and we don't need a separate initialization function. We really only need a couple of helper functions:

static inline void iarray_free(iarray *array)

{

    if (array) {

        free(array->val);

        array->max = 0;

        array->num = 0;

        array->val = NULL;

    }

}



/* Try to grow the array dynamically.

   Returns the number of elements that can be added right now. */

static inline size_t iarray_need(iarray *array, const size_t more)

{

    if (!array)

        return 0;



    if (array->num + more > array->max) {

        size_t  max = array->num + more;

        void   *val;



        /* Optional: Growth policy. Instead of allocating exactly

                     as much memory as needed, we allocate more,

                     in the hopes that this reduces the number of

                     realloc() calls, which tend to be a bit slow.

                     However, we don't want to waste too much

                     memory by allocating and then not using it. */

        if (max < 16) {

            /* Always allocate at least 16 elements, */

            max = 16;  

        } else

        if (max < 65536) {

            /* up to 65535 elements add 50% extra, */

            max = (3*max) / 2;

        } else {

            /* then round up to next multiple of 65536, less 16. */

            max = (max | 65535) + 65521;

        }



        val = realloc(array->val, max * sizeof array->val[0]);

        if (!val) {

            /* We cannot grow the array. However, the old

               array is still intact; realloc() does not

               free it if it fails. */

            return array->max - array->num;

        }



        /* Note: the new elements in array->val,

                 array->val[array->max] to

                 array->val[max-1], inclusive,

                 are undefined. That is fine, usually,

                 but might be important in some special

                 cases like resizing hash tables or such. */



        array->max = max;

        array->val = val;

    }



    return array->max - array->num;

}



/* Optional; same as initializing the variable to IARRAY_INIT. */

static inline void iarray_init(iarray *array)

{

    array->max = 0;

    array->num = 0;

    array->val = NULL;

}

The static inline bit means that the functions are only visible in this compilation unit, and the compiler is free to implement the function directly at the call site. Basically, static inline is used for macro-like functions and accessor functions. If you put the structure in a header file (.h), you'd put the related static inline helper functions in it as well.

The growth policy part is only an example. If you omit the growth policy, and always reallocate to array->num + more elements, your code will call realloc() very often, potentially for every int appended. In most cases, doing it that often will slow down your program, because realloc() (as well as malloc(), calloc()) is kind-of slow. To avoid that, we prefer to pad or round up the allocation a bit: not too much to waste allocated but unused memory, but enough to keep the overall program fast, and not bottlenecked on too many realloc() calls.

A "good growth policy" is very much up to debate, and really depends on the task at hand. The above one should work really well on all current operating systems on desktop machines, laptops, and tablets, when the program needs only one or only a handful of such arrays.

(If a program uses many such arrays, it might implement an iarray_optimize() function, that reallocates the array to exactly the number of elements it has. Whenever an array is unlikely to change size soon, calling that function will ensure not too much memory is sitting unused but allocated in the arrays.)

Let's look at an example function that uses the above. Say, the obvious one: appending an integer to the array:

/* Append an int to the array.

   Returns 0 if success, nonzero if an error occurs.

*/

int iarray_append(iarray *array, int value)

{

    if (!array)

        return -1; /* NULL array specified! */



    if (iarray_need(array, 1) < 1)

        return -2; /* Not enough memory to grow the array. */



    array->val[array->num++] = value;



    return 0;

}

Another example function would be one that sorts the ints in an array by ascending or descending value:

static int cmp_int_ascending(const void *ptr1, const void *ptr2)

{

    const int  val1 = *(const int *)ptr1;

    const int  val2 = *(const int *)ptr2;

    return (val1 < val2) ? -1 :

           (val1 > val2) ? +1 : 0;

}



static int cmp_int_descending(const void *ptr1, const void *ptr2)

{

    const int  val1 = *(const int *)ptr1;

    const int  val2 = *(const int *)ptr2;

    return (val1 < val2) ? +1 :

           (val1 > val2) ? -1 : 0;

}



static void iarray_sort(iarray *array, int direction)

{

    if (array && array->num > 1) {

        if (direction > 0)

            qsort(array->val, array->num, sizeof array->val[0],

                  cmp_int_ascending);

        else

        if (direction < 0)

            qsort(array->val, array->num, sizeof array->val[0],

                  cmp_int_descending);

    }

}

Many new programmers do not realize that the standard C library has that nifty and quite efficient qsort() function for sorting arrays; all it needs is a comparison function. If the direction is positive for iarray_sort(), the array is sorted in ascending order, smallest int first; if direction is negative, then in descending order, largest int first.

A simple example main() that reads in all valid ints from standard input, sorts them, and prints them in ascending order (increasing value):

int main(void)

{

    iarray  array = IARRAY_INIT;

    int     value;

    size_t  i;



    while (scanf(" %d", &value) == 1)

        if (iarray_append(&array, value)) {

            fprintf(stderr, "Out of memory.n");

            exit(EXIT_FAILURE);

        }



    iarray_sort(&array, +1); /* sort by increasing value */



    for (i = 0; i < array.num; i++)

        printf("%dn", array.val[i]);



    iarray_free(&array);



    return EXIT_SUCCESS;

}

If size of array is indeed 3 (or other small fixed value), then you can simply use structs as values, something like:

struct ints3 {

  int values[3];

  // if needed, can add other fields

}



int main(){

  struct ints3 ints;



  ints = function_A();

  function_B(&ints);



  return 0; 

}



// note about function_A signature: void is important,

// because in C empty () means function can take any arguments...

struct ints3 function_A(void) {

  // use C designated initialiser syntax to create struct value,

  // and return it directly

  return (struct ints3){ .values = { 11, 22, 33 } };

}



int function_B(const struct ints3 *ints) {

  // pass struct as const pointer to avoid copy,

  // though difference to just passing a value in this case is insignificant



  // could use for loop, see other answers, but it's just 3 values, so:

  printf("%d %d %dn", ints->values[0], ints->values[1], ints->values[2]);

  return 0; // does this function really need return value?

}