Pointers vs. Pointers to pointers

I keep seeing code that uses the the same function twice, but one copy of the function will use pointers to an array, and another will use pointers to pointers to an array.

Is there a difference in execution between these two methods, or is it just preference?

Please show some examples to illustrate your question.

Jim

Code:

      int compA(const void* item1, const void* item2) {
      const Emp* emp1 = (const Emp*) item1;
      const Emp* emp2 = (const Emp*) item2;
      
      unsigned char buff1[BuffSize + 1];
      unsigned char buff2[BuffSize + 1];
    
      strcpy(buff1, emp1->lname);
      strcat(buff1, emp1->fname);
      strcpy(buff2, emp2->lname);
      strcat(buff2, emp2->fname);
   
      return strcmp(buff1, buff2);
    }

and

Code:

    int compB(const void* item1, const void* item2) {
      const Emp** emp1 = (const Emp**) item1;
      const Emp** emp2 = (const Emp**) item2;
    
   unsigned char buff1[BuffSize + 1];
   unsigned char buff2[BuffSize + 1];
   
      strcpy(buff1, (*emp1)->lname);
      strcat(buff1, (*emp1)->fname);
      strcpy(buff2, (*emp2)->lname);
      strcat(buff2, (*emp2)->fname);
    
      return strcmp(buff1, buff2);
   }

Or

Code:

 void dump_emps1(Emp a[ ], unsigned n) {
   102   int i;
        char buffer[BuffSize + 1];
        for (i = 0; i < n; i++) {
        to_string(&a[i], buffer);
        printf("%s\n", buffer);
      }  
    }

and

Code:

       void dump_emps2(Emp* a[ ], unsigned n) {
       int i;
       char buffer[BuffSize + 1];
       for (i = 0; i < n; i++) {
       to_string(a[i], buffer);
       printf("%s\n", buffer);
      }
   }

In the examples it looks like one set of functions is for an array of Emp pointers. The other set of functions is for an array of Emp. Since the data structures are different--an array of things is not the same as an array of pointers to things--the correct function to use is not just a preference, or a matter of performance. What matters is how the Emp structures are allocated. If the Emp structures are allocated separately from the array data structure so that each array element points to a structure, then only compB and dump_emps2 will work. If you just allocate an array of structures, then only compA and dump_emps1 will work.

In this instance I would probably replace compB with:

Code:

int compB(const void* item1, const void* item2)
{
    return compA(*(const void**)item1, *(const void**)item2);
}

etc

Eww.

Originally Posted by whiteflags

Eww.

Was that in response to my comment?

Do you not feel "Eww" about the original code duplication?
How was that not the ideal solution, care to elaborate?

>> Do you not feel "Eww" about the original code duplication?
>> How was that not the ideal solution, care to elaborate?

I'd rather just decide on one way to allocate Emp structures, to be honest. Other than that, nothing is wrong.

Oh right, gotcha.
Yes I would question the reasons for doing it as well.