C++ Build warning in GCC ARM but not MS x86

Question

I use the Airplay SDK which is a platform for building C++ apps for smartphones. It also has a x86 simulator which uses MS Visual C++ IDE + compiler.

Now, I have this class :

namespace Fair {

    class Bitmap : public Sprite {

    public:

        const CIw2DImage* const& getBitmapData() { return bitmapData; }; // warning: returning reference to temporary

    private:

        CIw2DImage* bitmapData;
    };

}

I get the above warning if I build with GCC (ARM) Debug. I don't get a warning with (x86) Debug.

I asked elsewhere and I got this reply :

Because `const CIw2DImage* const' is a const pointer to const CIw2DImage, and Bitmap::bitmapData is a pointer to non-const CIw2DImage compiler automatically casts pointer to non-const to const, so here's a temporary. The following code might be generated by a "typical" compiler:
const CIw2DImage* const& getBitmapData() {
    const CIw2DImage* const tmp = bitmapData;
    return tmp;
}
Probably (x86) compiler doesn't detect this problem.

You might want to remove reference symbol (&) from the prototype (why do you want use a reference in this case?)

If a compiler does that, then it's totally wrong practice..? Making the value returned more "strict" is simply at compiler-level, to prevent "abuse". (x86) doesn't detect because it doesn't "cause" the problem in the 1st case..?

I return a reference to a pointer for the sole reason to "save" 32 bits of memory, i.e. use the same block of memory as the bitmapData pointer but within a different context.

Any comments please?

Re: "I return a reference to a pointer for the sole reason to "save" 32 bits of memory" - a reference is (almost certainly) the same size as a pointer. It's usually more efficient to pass simple types by value. — Mike Seymour, Feb 12 '11 at 12:30
When you pass a constant reference to a pointer, aren't you in fact passing the pointer itself? I.e no more memory is reserved for YAP (yet another pointer). — Bill Kotsias, Feb 12 '11 at 12:35
no, passing by reference passes by reference. Even if the reference is to a constant object, it's possible to use `const_cast` to change the object, so the indirection is needed. — Mike Seymour, Feb 12 '11 at 12:46

score 2 · Answer 1 · answered Feb 12 '11 at 12:52

2

The compiler is quite correct to do that. A reference must refer to an object of the correct type; here you have an object of type CIw2DImage*, and you need a reference to a different type, const CIw2DImage*. The only way to do this is to create a temporary of the correct type (which is possible here, since const T* can be implicitly converted to T*), and return a reference to that.

Unfortunately, that results in a reference to a temporary object in the scope of the function, which is no longer valid once the function returns.

The simplest solution is to return the pointer by value; this will be more efficient (as it avoids an unnecessary level of indirection), as well as avoiding this problem.

answered Feb 12 '11 at 12:52

Mike Seymour

249,747
28
448
644

I still don't get it. The return value is const CIw2DImage* CONST, it's the SAME pointer but with added restrictions i.e can't change it at all. I still don't see a reason why a copy of it should be made anyway. I don't think the MS x86 would be so dumb as to allow this with no warnings, I suspect it simply optimizes it (as it should). – Bill Kotsias Feb 12 '11 at 13:06
@Bill: no, the return type is `const CIw2DImage* const&`, a reference to a pointer. Even though it is a reference to a const type, C++ allows you to use `const_cast` to modify the object, so it really does have to be a reference. It can't be a reference to the class member, since that is a different type. MSVC must either be allowing the reference to refer to an object of incompatible type (which is nonconformant, but probably harmless), or silently returning a reference to a temporary (which is nasty). – Mike Seymour Feb 12 '11 at 13:17

Puppy · Accepted Answer · 2011-02-12T13:02:17.253

0

You won't save any memory at all returning a reference, it's just a pointer internally. In addition, const occurs completely at compile-time, there's no reason for any temporary to be produced- and even if it was, a const reference to it would be valid.

That code looks terrible to me personally but it's not undefined in any way.

edited Feb 12 '11 at 13:02

answered Feb 12 '11 at 12:34

Puppy

144,682
38
256
465

1) It's yet another pointer, or is it the original pointer itself? 2) No reason for temp, I agree, so it's a GCC bug? Wrongly produced code? – Bill Kotsias Feb 12 '11 at 12:36
"const occurs completely at compile-time" - no, `T *` and `T const *` are two different types, so a reference to one can't refer to the other. That is why you need a temporary of the correct type for the reference. – Mike Seymour Feb 12 '11 at 12:42
"a const reference to it would be valid" - only within the scope of the temporary. It won't be valid after returning from the function. – Mike Seymour Feb 12 '11 at 12:43

C++ Build warning in GCC ARM but not MS x86

2 Answers2