All geek questions in one place

C ++ multiple inheritance and Objective-C. Is this a bug in GCC?

Yesterday, I came across the following strange behavior. It seems like a compiler error for me or is there something I missed? I exchanged Facebook Connect classes for iPhone Objective-C with Objective-C classes in C ++ so that they can be used more conveniently from our own OpenGL / C ++ code.

The following code shows the problem. In the first version below, the compiler compiles, but confuses vtables, and therefore the wrong method is called. In the second option, we get a compiler error that indicates that gcc is confused.

Comments try to explain the situation in more detail.

#include <iostream>
#import <Foundation/Foundation.h>

// An abstract C++ interface
class Foo_cpp {
public:
    virtual void foo() = 0;
};

// Another abstract C++ interface
class Bar_cpp {
public:
    virtual void bar() = 0;
};


// An Objective-C to C++ adaptor. 
// It takes a C++ interface Foo. When it do_foo method is called it
// delegates call to Foo::foo.
@interface Foo_objc : NSObject {
    Foo_cpp* foo_cpp_;
}
@end

@implementation Foo_objc

- (id)init:(Foo_cpp*)foo {
    self = [super init];
    if (self) {
        foo_cpp_ = foo;
    } 
    return self;
}

- (void) do_foo {
    std::cout << "do_foo: ";
    foo_cpp_->foo();
}
@end 

// Another Objective-C to C++ adaptor. 
@interface Bar_objc : NSObject{
    Bar_cpp* bar_cpp_;
}
@end 

@implementation Bar_objc

- (id)init:(Bar_cpp*)bar {
    self = [super init];
    if (self) {
        bar_cpp_ = bar;
    }
    return self;
}

- (void) do_bar {
    std::cout << "do_bar: ";
    bar_cpp_->bar();
}
@end 

// Main class implements both abstract C++ interfaces (which will
// confuse the compiler as we shall see). 
// It constructs two Objective-C to C++ adaptors as a members and
// tries to pass itself as a C++ delegate for these adaptors.
class Main : public Foo_cpp, public Bar_cpp {
public:
    Foo_objc* foo_;
    Bar_objc* bar_;

    Main() {
        // We try to construct two objective-c to c++ adaptors Foo_objc and
        // Bar_objc. 
        // 
        // We expect output of 
        // [foo_ do_foo];
        // [bar_ do_bar];
        // to be
        //   do_foo: foo
        //   do_bar: bar
#if 0
        // This variant compiles but the compiler messes up
        // the vtables. When do_bar() is called, we expect
        // bar() to be called via Bar_objc, but instead
        // foo() is called from both adaptors.
        // Output is
        //    do_foo: foo
        //    do_bar: foo  !!!! Calls wrong method !!!!
        foo_ = [[Foo_objc alloc] init:this];
        bar_ = [[Bar_objc alloc] init:this];

        [foo_ do_foo];
        [bar_ do_bar];
#else 
        // Now, this variant tries to help the compiler by passing 
        // |this| via a variable of the correct interface type.
        // It actually reveals the confusion that the compiler
        // is having. Seems like a bug in the compiler.
        Foo_cpp* iface = this;
        foo_ = [[Foo_objc alloc] init:iface];

        Bar_cpp* iface2 = this;
        // Error we get is on the next code line.
        //   $ g++ -x objective-c++ -lobjc mheritance_test.mm
        //   mheritance_test.mm: In constructor ‘Main::Main()’:
        //   mheritance_test.mm:107: error: cannot convert ‘Bar_cpp*’ to ‘Foo_cpp*’ in argument passing
        bar_ = [[Bar_objc alloc] init:iface2];

        [foo_ do_foo];
        [bar_ do_bar];
#endif

    }

    ~Main() {
        delete foo_;
        delete bar_;
    }

    virtual void foo() {
        std::cout << "foo" << std::endl;
    }

    virtual void bar() {
        std::cout << "bar" << std::endl;
    }

};

int main() {
    Main m;
}

The problem occurs with the iPhone SDK and Mac with g ++ and versions 4.0.1 and 4.2. Is there something I misunderstood or is this a bug in g ++?

UPDATE , , . .

#include <iostream>
#import <Foundation/Foundation.h>

// An abstract C++ interface
class Foo_cpp {
public:
    virtual void foo() = 0;
};

// Another abstract C++ interface
class Bar_cpp {
public:
    virtual void bar() = 0;
};

// An Objective-C to C++ adaptor. 
// It takes a C++ interface Foo. When it do_foo method is called it
// delegates call to Foo::foo.
@interface Foo_objc : NSObject {
    Foo_cpp* foo_cpp_;
}
@end

@implementation Foo_objc

- (id)init:(Foo_cpp*)foo {
    self = [super init];
    if (self) {
        foo_cpp_ = foo;
    } 
    return self;
}

- (void) do_foo {
    std::cout << "do_foo: ";
    foo_cpp_->foo();
}
@end 

// Another Objective-C to C++ adaptor. 
@interface Bar_objc : NSObject{
    Bar_cpp* bar_cpp_;
}
@end 

@implementation Bar_objc

- (id)init:(Bar_cpp*)bar {
    self = [super init];
    if (self) {
        bar_cpp_ = bar;
    }
    return self;
}

- (void) do_bar {
    std::cout << "do_bar: ";
    bar_cpp_->bar();
}
@end 

class Main : public Foo_cpp, public Bar_cpp {
    void foo() { 
        std::cout << "foo" << std::endl;
    }
    void bar() {
        std::cout << "bar" << std::endl;
    }
};

int main() {
    Main* m = new Main;    
#if 0 
    // Compiles but produces
    //   do_foo: foo
    //   do_bar: foo !!! incorrect method called !!!
    Foo_objc* fo = [[Foo_objc alloc] init:m];
    Bar_objc* bo = [[Bar_objc alloc] init:m];
#else 
    // Doesn't compile
    Foo_objc* fo = [[Foo_objc alloc] init:(Foo_cpp*)m];
    Bar_objc* bo = [[Bar_objc alloc] init:(Bar_cpp*)m];
    // A line above produces following error
    //    mheritance_test2.mm: In function ‘int main()’:
    //    mheritance_test2.mm:82: error: cannot convert ‘Bar_cpp*’ to ‘Foo_cpp*’ in argument passing
#endif
    [fo do_foo];
    [bo do_bar];
}

2 init: Fooobjc Barobjc initfoo: initbar: , , . , Objective-C ?

+3
4

, ; -)

Objective-C, , , , . , , Foo* Bar* , main():

Bar_objc *bo = [[Bar_objc alloc] init:(Bar_cpp*)0];

, , - alloc. :

Bar_objc *bo = [Bar_objc alloc]; [bo init:(Bar_cpp*)0];

. alloc (. ). , ( ) . , alloc. .

( - /public , , delete dealloc , , - ):

#include <iostream>
#import <Foundation/Foundation.h>

struct Foo_cpp { virtual void foo() = 0; };
struct Bar_cpp { virtual void bar() = 0; };

@interface Foo_objc : NSObject {
    Foo_cpp* foo_cpp_;
}
- (id)init:(Foo_cpp*)foo;
- (void)do_foo;
@end
@implementation Foo_objc : NSObject {
    Foo_cpp* foo_cpp_;
}
- (id)init:(Foo_cpp*)foo {
    if( self = [super init] ) foo_cpp_ = foo;
    return self;
}
- (void) do_foo { std::cout << "do_foo: "; foo_cpp_->foo(); }
@end 

@interface Bar_objc : NSObject {
    Bar_cpp* bar_cpp_;
}
- (id)init:(Bar_cpp*)bar;
- (void)do_bar;
@end 
@implementation Bar_objc : NSObject {
    Bar_cpp* bar_cpp_;
}
- (id)init:(Bar_cpp*)bar {
    if( self = [super init] ) bar_cpp_ = bar;
    return self;
}
- (void) do_bar { std::cout << "do_bar: "; bar_cpp_->bar(); }
@end 


struct Main : public Foo_cpp, public Bar_cpp {
    Foo_objc* foo_;
    Bar_objc* bar_;

    Main() {
        foo_ = [(Foo_objc*)[Foo_objc alloc] init:this];
        bar_ = [(Bar_objc*)[Bar_objc alloc] init:this];
    }

    ~Main() { [foo_ dealloc]; [bar_ dealloc]; }

    virtual void foo() { std::cout << "foo" << std::endl; }
    virtual void bar() { std::cout << "bar" << std::endl; }
};

int main() {
    Main m;
    [m.foo_ do_foo];
    [m.bar_ do_bar];
}

:

do_foo: foo
do_bar: bar

: - , , .

+6

undefined .

foo(), bar() Main(), , . , , . :

int main()
{
    Main m;
    [m.foo_ do_foo];
    [m.bar_ do_bar];
}
+3

Apple :

, call -init: . + Alloc (id), , -init: . , .

-Wstrict-selector-match , . .

-initWithFoo: -initWithBar: . - + alloc -init:.

@hacker , , . -Wstrict-selector-match - .

+3

, .

, ,

[foo_ do_foo];
[bar_ do_bar];

, .

. 9 ++ :   .

Meyster, , , ( 7).

, Meyers , , !

+2

Source: https://habr.com/ru/post/1718250/

More articles:


All Articles