C++ by-reference argument and c linkage

Question

Hi,

I have encountered a working (with XLC8 and MSFT9 compilers) piece of code, containing a c++ file with a function defined with c linkage and a reference argument. This bugs me, as references are c++ only. The function in question is called from c code, where it is declared as taking a pointer argument to the same type in place of the reference argument.

Simplified example:

c++ file:

extern "C" void f(int &i)
{
  i++;
}

c file:

void f(int *);

int main()
{
  int a = 2;
  f(&a);
  printf("%d\n", a);  /* Prints 3 */
}

Now, the word on the street is that most c++ compilers, under the hood, implement references just like a pointer. Is that and just pure luck the reason this code works or does it say somewhere in the c++ specification what the result is when you define a function with a reference argument and c linkage? I haven't been able to find any info on this.

Answer 1

In many cases, but not all, a reference can be implemented with an 'auto-dereferenced' pointer. That any particular compiler treats a function with C linkage and a reference parameter this way is not guaranteed in the C++ standard, and you should treat it as an implementation detail.

It isn't hard to write a forwarding function that takes a pointer and calls your function, if you need to do this without relying on implementation details:

void real_f(int& n) {
  n++;
}
extern "C" void f(int* p) { // called from C code
  real_f(*p);
}

Answer 2

A reference is an alternate name for an object. Technically, there is nothing in C that could map directly to a C++ reference.

The obvious implementation of a reference is as a (constant) pointer that is dereferenced each time it is used. So, depending on how your compiler implements references, your code might work. But it is not correct.

The solution is to write a C function that receives either a real object or a pointer to that object and call the C++ function from this.

Answer 3

That's what Bjarne Stroustrup has to say about references:

"Most references are implements are implemented using a pointer variable; that it a reference usually takes up one word of memory. However, a reference that is used purely locally can - and often is - eliminated by the optimizer".

For example:

 struct S 
 { 
    int a;
    int b[100]; 
 };  // just an example

 void do_something(const vector<S>& v)
 {
    for (int i=0; i<v.size(); ++i)
    {
        int(&p)[100] = v[i].b;
        for (int j=0; j<100; ++j) 
           cout <<p[j];
    }
 }

In this case, p needs not be stored in memory (maybe it just exists in a register, maybe it disappears into the instructions).