Hi friends! I would like to do something but I have a big doubts. I am making this thing: I have an interface named I that contains the (template) method run() like this template <class T> run() . I have two classes CI1 and CI2 that implements this interface I. I would like that run() of CI1 returns a list of some class objects and run() of CI2 returns a void. Is this coherent ? I am very beginner in c++. Then I need help , Can someone help ?

to override methods it needs to be virtual but template functions can't be virtual you could either make use of CRTP or the pimpl idiom, depending on what you are trying to achieve

to override methods it needs to be virtual but template functions can't be virtual you could either make use of CRTP or the pimpl idiom, depending on what you are trying to achieve

Why template functions can't be virtual?!

When a method is declared virtual it's expected to be implemented in another point of the application. Though, template parameters can't be linked to other template definitions (T in something.cxx wouldn't be the same T in else.cxx)

Dynamically dispatched?!

This not true, virtual tells the function needs to be dynamically dispatched

From C++ Templates - the complete Guide Member function templates cannot be declared virtual. This constraint is imposed because the usual implementation of the virtual function call mechanism uses a fixed-size table with one entry per virtual function. However, the number of instantiations of a member function template is not fixed until the entire program has been translated. Hence, supporting virtual member function templates would require support for a whole new kind of mechanism in C++ compilers and linkers. In contrast, the ordinary members of class templates can be virtual because their number is fixed when a class is instantiated

Hm, so I was right

From C++ Templates - the complete Guide Member function templates cannot be declared virtual. This constraint is imposed because the usual implementation of the virtual function call mechanism uses a fixed-size table with one entry per virtual function. However, the number of instantiations of a member function template is not fixed until the entire program has been translated. Hence, supporting virtual member function templates would require support for a whole new kind of mechanism in C++ compilers and linkers. In contrast, the ordinary members of class templates can be virtual because their number is fixed when a class is instantiated

I wouldn't say so unless I got your explanation wrong

What does he mean by number of instantiations of a member function?

For every template parameters a instantiation is made. For example let's say you call your method with int, float and char so you will have 3 instantiations

I guessed that since template parameters represent non-concrete types (you don't actually know what T is) you can't compare the prototypes in all of the potentially infinite virtual implementations of the method. The templates represent different things and can't be linked

For every template parameters a instantiation is made. For example let's say you call your method with int, float and char so you will have 3 instantiations

When linking you know exactly what T is replaced with

So the fixed-size table depends on the instantiation of the its virtual function's parameters!!

.

Let's say we have a template function template <class T> void foo(T&&) {}; and we call it with foo(1); foo('1'); foo(1.0); the compiler generates three instantiations of the function foo, e.g. void foo<int>(int&&): ret void foo<char>(char&&): ret void foo<double>(double&&): ret ——————————————————————————- Now for "vtables". Let's say we have a class A and B class A { public: virtual void foo() {} }; class B : public A { public: void foo() override {} }; The compiler generates "vtables" which store the function to be called vtable for B: .quad 0 .quad typeinfo for B .quad B::foo() vtable for A: .quad 0 .quad typeinfo for A .quad A::foo() The code B b; A& rb = b; rb.foo(); results in a call to the function stored at OFFSET FLAT:vtable for B+16 which is in this case B::foo. Since the function to call is lookep up this is called "dynamic dispatch" or "late dispatch" * Note: The C++ standard does not define the term "vtable" or require them, that's the current implementation used by all common vendors.

What does .quad 0 means

Let's say we have a template function template <class T> void foo(T&&) {}; and we call it with foo(1); foo('1'); foo(1.0); the compiler generates three instantiations of the function foo, e.g. void foo<int>(int&&): ret void foo<char>(char&&): ret void foo<double>(double&&): ret ——————————————————————————- Now for "vtables". Let's say we have a class A and B class A { public: virtual void foo() {} }; class B : public A { public: void foo() override {} }; The compiler generates "vtables" which store the function to be called vtable for B: .quad 0 .quad typeinfo for B .quad B::foo() vtable for A: .quad 0 .quad typeinfo for A .quad A::foo() The code B b; A& rb = b; rb.foo(); results in a call to the function stored at OFFSET FLAT:vtable for B+16 which is in this case B::foo. Since the function to call is lookep up this is called "dynamic dispatch" or "late dispatch" * Note: The C++ standard does not define the term "vtable" or require them, that's the current implementation used by all common vendors.

You do mean A& rb = b Right?!

Let's say we have a template function template <class T> void foo(T&&) {}; and we call it with foo(1); foo('1'); foo(1.0); the compiler generates three instantiations of the function foo, e.g. void foo<int>(int&&): ret void foo<char>(char&&): ret void foo<double>(double&&): ret ——————————————————————————- Now for "vtables". Let's say we have a class A and B class A { public: virtual void foo() {} }; class B : public A { public: void foo() override {} }; The compiler generates "vtables" which store the function to be called vtable for B: .quad 0 .quad typeinfo for B .quad B::foo() vtable for A: .quad 0 .quad typeinfo for A .quad A::foo() The code B b; A& rb = b; rb.foo(); results in a call to the function stored at OFFSET FLAT:vtable for B+16 which is in this case B::foo. Since the function to call is lookep up this is called "dynamic dispatch" or "late dispatch" * Note: The C++ standard does not define the term "vtable" or require them, that's the current implementation used by all common vendors.

Let's say we have a template function template <class T> void foo(T&&) {}; and we call it with foo(1); foo('1'); foo(1.0); the compiler generates three instantiations of the function foo, e.g. void foo<int>(int&&): ret void foo<char>(char&&): ret void foo<double>(double&&): ret ——————————————————————————- Now for "vtables". Let's say we have a class A and B class A { public: virtual void foo() {} }; class B : public A { public: void foo() override {} }; The compiler generates "vtables" which store the function to be called vtable for B: .quad 0 .quad typeinfo for B .quad B::foo() vtable for A: .quad 0 .quad typeinfo for A .quad A::foo() The code B b; A& rb = b; rb.foo(); results in a call to the function stored at OFFSET FLAT:vtable for B+16 which is in this case B::foo. Since the function to call is lookep up this is called "dynamic dispatch" or "late dispatch" * Note: The C++ standard does not define the term "vtable" or require them, that's the current implementation used by all common vendors.

Why B+16?!

/report

thanks

In this case its quadword so 64bits, make sense using a 64bit system.

Thank you olli

If it's 32 bit system??

the VTable contains 3x 8 Byte values, the first 0, then a pointer to the typeinfo for the class and a pointer to the function to be called. 16 is the offset for the third entry into the table (the location of the function to be called)

If you have a 2 virtual functions The table will be 4x 8 bytes?!

Most likely yes. Although all the "vtables" are completely implementation dependant

.long

Then What 0-7 refers to?!

Can we perform arithmetic operation on struct object in c

The Itanium ABI specifies the first byte is an offset value that is useful when dynamic casting between objects.

Can we perform arithmetic operation on struct object in c

Okay What is itanium ABI XD?!

Sorry for a lot of questions

Okay What is itanium ABI XD?!

quad determines the size of the "storage block", 0 is the value for it.. this is completely implementation specific

Then What 0-7 refers to?!

Can i know which one you refer too?? I am new to group and 8 -15??

I dunno here But he said that itanium ABI specifies it when dynamic casting

To store the 0 or the pointer to the functions and typeinfo. .quad 0 basically means "here are 64 bits all set to 0"