Error only virtual member functions can be marked override

grpc_version = "80e834abab5dff45e16e9a1e3b98f20eae5f91ad"

git_repository(
    name = "com_github_grpc_grpc",
    commit = grpc_version,
    remote = "https://github.com/grpc/grpc.git",
)

load("@com_github_grpc_grpc//bazel:grpc_deps.bzl", "grpc_deps")

grpc_deps()

load("@com_github_grpc_grpc//bazel:grpc_extra_deps.bzl", "grpc_extra_deps")

grpc_extra_deps()

build --verbose_failures
build --cxxopt='-std=c++17'
build --cxxopt='-Wall'
build --cxxopt='-Wextra'
build --cxxopt='-Wpedantic'
build --cxxopt='-Werror=unused'
build --cxxopt='-Werror=uninitialized'
build --compilation_mode=dbg
build --strip=never

INFO: Analyzed 104 targets (0 packages loaded, 0 targets configured).
INFO: Found 104 targets...
...
Use --sandbox_debug to see verbose messages from the sandbox
In file included from external/com_github_grpc_grpc/src/compiler/cpp_plugin.cc:21:
In file included from external/com_github_grpc_grpc/src/compiler/cpp_plugin.h:29:
In file included from external/com_github_grpc_grpc/src/compiler/protobuf_plugin.h:24:
In file included from external/com_github_grpc_grpc/src/compiler/python_generator_helpers.h:29:
external/com_github_grpc_grpc/src/compiler/python_generator.h:47:41: error: only virtual member functions can be marked 'override'
  uint64_t GetSupportedFeatures() const override;
                                        ^~~~~~~~
In file included from external/com_github_grpc_grpc/src/compiler/cpp_plugin.cc:21:
external/com_github_grpc_grpc/src/compiler/cpp_plugin.h:37:41: error: only virtual member functions can be marked 'override'
  uint64_t GetSupportedFeatures() const override {
                                        ^~~~~~~~~
external/com_github_grpc_grpc/src/compiler/cpp_plugin.h:38:12: error: use of undeclared identifier 'FEATURE_PROTO3_OPTIONAL'
    return FEATURE_PROTO3_OPTIONAL;
           ^
3 errors generated.
INFO: Elapsed time: 2.072s, Critical Path: 1.95s
INFO: 10 processes: 10 darwin-sandbox.
FAILED: Build did NOT complete successfully

У меня проблема с компиляцией этого кода g++ -std=c++11 аргумент:

#include <iostream>
#include <unordered_map>
#include <functional>
#include <iostream>
using namespace std;;

template <typename T> class opt {
public:
opt() {};
~opt() {};
virtual int isEmpty() = 0;
virtual T getObject() = 0;
};

template <typename T> class oopt : public opt<T> {
private:
T ret;
public:
oopt(T obj) { ret = obj; };
~oopt() override;
int isEmpty() { return 0; };
T getObject() { return ret; };
};
int main(void) {

function<opt<int>(int)> fu = [](int j) { return (oopt<int>(10)); };

return 1;
}

Этот код возвращает следующую ошибку:

assoc_array.cc: In instantiation of ‘class oopt<int>’:
assoc_array.cc:68:63:   required from here
assoc_array.cc:29:3: error: ‘oopt<T>::~oopt() [with T = int]’ marked override, but does not override
In file included from assoc_array.cc:3:0:
/usr/include/c++/4.7/functional: In instantiation of ‘static _Res std::_Function_handler<_Res(_ArgTypes ...), _Functor>::_M_invoke(const std::_Any_data&, _ArgTypes ...) [with _Res = opt<int>; _Functor = main()::<lambda(int)>; _ArgTypes = {int}]’:
/usr/include/c++/4.7/functional:2298:6:   required from ‘std::function<_Res(_ArgTypes ...)>::function(_Functor, typename std::enable_if<(! std::is_integral<_Functor>::value), std::function<_Res(_ArgTypes ...)>::_Useless>::type) [with _Functor = main()::<lambda(int)>; _Res = opt<int>; _ArgTypes = {int}; typename std::enable_if<(! std::is_integral<_Functor>::value), std::function<_Res(_ArgTypes ...)>::_Useless>::type = std::function<opt<int>(int)>::_Useless]’
assoc_array.cc:68:67:   required from here
/usr/include/c++/4.7/functional:1909:7: error: invalid abstract return type for function ‘static _Res std::_Function_handler<_Res(_ArgTypes ...), _Functor>::_M_invoke(const std::_Any_data&, _ArgTypes ...) [with _Res = opt<int>; _Functor = main()::<lambda(int)>; _ArgTypes = {int}]’
assoc_array.cc:7:29: note:   because the following virtual functions are pure within ‘opt<int>’:
assoc_array.cc:11:15: note:     int opt<T>::isEmpty() [with T = int]
assoc_array.cc:12:13: note:     T opt<T>::getObject() [with T = int]
In file included from assoc_array.cc:3:0:
/usr/include/c++/4.7/functional:1912:40: error: cannot allocate an object of abstract type ‘opt<int>’
assoc_array.cc:7:29: note:   since type ‘opt<int>’ has pure virtual functions
In file included from assoc_array.cc:3:0:
/usr/include/c++/4.7/functional:1743:2: error: ‘static _Functor* std::_Function_base::_Base_manager<_Functor>::_M_get_pointer(const std::_Any_data&) [with _Functor = main()::<lambda(int)>]’, declared using local type ‘main()::<lambda(int)>’, is used but never defined [-fpermissive]

Где моя ошибка при использовании замыканий со статическим приведением к интерфейсу? Я уже читал похожие ответы (C ++ и наследование в абстрактных классах, C ++ — «Функция-член не объявлена» в производном классе), но, похоже, во время компиляции не выдается никакой ошибки, если я удаляю определение замыкания. Заранее спасибо.

РЕДАКТИРОВАТЬ

Даже со следующим кодом:

#include <iostream>
#include <unordered_map>
#include <functional>
#include <iostream>
using namespace std;;

template <typename T> class opt {
public:
opt<T>(T) {};
~opt<T>() {};
virtual int isEmpty() = 0;
virtual T getObject() = 0;
};

template <typename T> class oopt : public opt<T> {
private:
T ret;
public:
oopt<T>(T obj) { ret = obj; };
~oopt<T>() override;
int isEmpty() { return 0; };
T getObject() { return ret; };
};
int main(void) {

function<opt<int>(int)> fu = [](int j) { return (oopt<int>(10)); };

return 1;
}

У меня все еще есть следующие проблемы компиляции:

assoc_array.cc: In instantiation of ‘class oopt<int>’:
assoc_array.cc:26:64:   required from here
assoc_array.cc:20:4: error: ‘oopt<T>::~oopt() [with T = int]’ marked override, but does not override
assoc_array.cc: In instantiation of ‘oopt<T>::oopt(T) [with T = int]’:
assoc_array.cc:26:64:   required from here
assoc_array.cc:19:19: error: no matching function for call to ‘opt<int>::opt()’
assoc_array.cc:19:19: note: candidates are:
assoc_array.cc:9:4: note: opt<T>::opt(T) [with T = int]
assoc_array.cc:9:4: note:   candidate expects 1 argument, 0 provided
assoc_array.cc:7:30: note: constexpr opt<int>::opt(const opt<int>&)
assoc_array.cc:7:30: note:   candidate expects 1 argument, 0 provided
In file included from assoc_array.cc:3:0:
/usr/include/c++/4.7/functional: In instantiation of ‘static _Res std::_Function_handler<_Res(_ArgTypes ...), _Functor>::_M_invoke(const std::_Any_data&, _ArgTypes ...) [with _Res = opt<int>; _Functor = main()::<lambda(int)>; _ArgTypes = {int}]’:
/usr/include/c++/4.7/functional:2298:6:   required from ‘std::function<_Res(_ArgTypes ...)>::function(_Functor, typename std::enable_if<(! std::is_integral<_Functor>::value), std::function<_Res(_ArgTypes ...)>::_Useless>::type) [with _Functor = main()::<lambda(int)>; _Res = opt<int>; _ArgTypes = {int}; typename std::enable_if<(! std::is_integral<_Functor>::value), std::function<_Res(_ArgTypes ...)>::_Useless>::type = std::function<opt<int>(int)>::_Useless]’
assoc_array.cc:26:68:   required from here
/usr/include/c++/4.7/functional:1909:7: error: invalid abstract return type for function ‘static _Res std::_Function_handler<_Res(_ArgTypes ...), _Functor>::_M_invoke(const std::_Any_data&, _ArgTypes ...) [with _Res = opt<int>; _Functor = main()::<lambda(int)>; _ArgTypes = {int}]’
assoc_array.cc:7:30: note:   because the following virtual functions are pure within ‘opt<int>’:
assoc_array.cc:11:16: note:     int opt<T>::isEmpty() [with T = int]
assoc_array.cc:12:14: note:     T opt<T>::getObject() [with T = int]
In file included from assoc_array.cc:3:0:
/usr/include/c++/4.7/functional:1912:40: error: cannot allocate an object of abstract type ‘opt<int>’
assoc_array.cc:7:30: note:   since type ‘opt<int>’ has pure virtual functions
In file included from assoc_array.cc:3:0:
/usr/include/c++/4.7/functional:1743:2: error: ‘static _Functor* std::_Function_base::_Base_manager<_Functor>::_M_get_pointer(const std::_Any_data&) [with _Functor = main()::<lambda(int)>]’, declared using local type ‘main()::<lambda(int)>’, is used but never defined [-fpermissive]

1

поскольку gcc является стандартным компилятором, его ошибки не самые очевидные, даже с C ++, чем с C, так что я обычно компилирую все с помощью clang и gcc просто для уверенности.
составлено с лязгом:
у меня есть это с кодом Ааронмана, т

clang++ -std=c++11 test.cc                                                                                                                                                                              ~
test.cc:20:20: error: only virtual member functions can be marked 'override'
~oopt<T>() override;
^~~~~~~~
test.cc:26:54: note: in instantiation of template class 'oopt<int>' requested here
function<opt<int>(int)> fu = [](int j) { return (oopt<int>(10)); };
^
test.cc:19:9: error: constructor for 'oopt<int>' must explicitly initialize the base class 'opt<int>' which does not have a default constructor
oopt<T>(T obj) { ret = obj; };
^
test.cc:26:54: note: in instantiation of member function 'oopt<int>::oopt' requested here
function<opt<int>(int)> fu = [](int j) { return (oopt<int>(10)); };
^
test.cc:7:29: note: 'opt<int>' declared here
template <typename T> class opt {
^
2 errors generated.

и это для вашего первого:

clang++ -std=c++11 test2.cc                                                                                                                                                                             ~
test2.cc:20:17: error: only virtual member functions can be marked 'override'
~oopt() override;
^~~~~~~~
test2.cc:26:54: note: in instantiation of template class 'oopt<int>' requested here
function<opt<int>(int)> fu = [](int j) { return (oopt<int>(10)); };
^
1 error generated.

после исправления этих ошибок Clang дал мне это во время ссылки:

clang++ -o -std=c++11 test2.o -Wall -Werror                                                                                                                                                             ~
test2.o: In function `std::_Function_handler<opt<int> (int), main::$_0>::_M_invoke(std::_Any_data const&, int)':
test2.cc:(.text+0x1a7): undefined reference to `oopt<int>::~oopt()'
test2.o:(.rodata._ZTV4ooptIiE[_ZTV4ooptIiE]+0x10): undefined reference to `oopt<int>::~oopt()'
test2.o:(.rodata._ZTV4ooptIiE[_ZTV4ooptIiE]+0x18): undefined reference to `oopt<int>::~oopt()'
clang: error: linker command failed with exit code 1 (use -v to see invocati

на)

это не точный ответ, но это может очень помочь

1

Хорошо, сначала избавимся от переопределения и сделаем деструктор виртуальным (они всегда должны быть при наследовании). Также деструктор не реализован в базовом классе

#include <iostream>
#include <unordered_map>
#include <functional>
#include <iostream>
using namespace std;;

template <typename T> class opt {
public:
opt() {};
virtual ~opt() {};
virtual int isEmpty() = 0;
virtual T getObject() = 0;
};

template <typename T> class oopt : public opt<T> {
private:
T ret;
public:
oopt(T obj) { ret = obj; };
~oopt(){};
int isEmpty() { return 0; };
T getObject() { return ret; };
};
int main(void) {

function<opt<int>(int)> fu = [](int j) { return (oopt<int>(10)); };

return 1;
}

Это компилируется сейчас. Что касается ошибок, которые вы получали изначально, я не могу сказать, откуда они исходили, так как я их не получил

0

Хорошо, надеюсь, что мое решение верное: по крайней мере, оно компилируется :). Я оставлю это как ответ, чтобы получить дополнительные комментарии относительно решения. Еще раз спасибо.

#include <iostream>
#include <unordered_map>
#include <functional>
#include <iostream>
#include <memory>

using namespace std;

//I need shared_pointers in order to gain the C++ dynamic casting
template <typename T> class Ptr {
shared_ptr<T> ptr;

public:
Ptr(T* obj) : ptr{obj} {};
Ptr(shared_ptr<T> obj) : ptr{obj} {};

~Ptr() {  };

template <typename U> Ptr<U> Cast();

T* operator->() const  {return &(*this->ptr);}
operator T() const { return (*this->ptr); };

};

template <typename T> template <typename U> Ptr<U> Ptr<T>::Cast(){
return Ptr<U>{dynamic_pointer_cast<U>(ptr)};
};template <typename T> class opt {
protected:
T ret;
public:
~opt() {};
virtual int isEmpty() = 0;
virtual T* getObject() = 0;
operator T() const { return ret; };
};

template <typename T> class oopt : public opt<T> {
public:
oopt(T obj) {
this->ret = obj;
};
int isEmpty() { return 1; };
T* getObject() { return &this->ret; }
};

template <typename T> class eopt : public opt<T> {
public:
eopt() { };  //for downcasting matters
T* getObject() { return nullptr; } //
int isEmpty() { return 1; };
};

int main(void) {

Ptr<oopt<int>> u(new oopt<int>(500));
Ptr<opt<int>> w = u.Cast<opt<int>>();
cout << (*(w->getObject())) << "n" ;

Ptr<opt<int>> none(new eopt<int>());
w = none.Cast<opt<int>>();
if ((w->getObject()) == nullptr) {
cout << "null" << "n";
}

return 1;

}

0

• Forum
• General C++ Programming
• Base class function is executed despite

Base class function is executed despite of overriding

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

class Dog
{
public:
    void bark()
    {
        cout << "A generic dog has spoken" << endl;
    }

    void seeCat()
    {
        bark();
    }
};

class GentleDog : public Dog
{
public:
    void bark()
    {
	cout << "woof-woof I won't eat you woof-woof!" << endl;
    }
};

1
2

GentleDog pet;   
pet.seeCat();

1
2

GentleDog pet;
pet.bark();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#include <iostream>

namespace one
{
    struct Dog
    {
        void bark()
        { std::cout << "A generic dog has spokenn" ; }
    } ;

    struct GentleDog : public Dog
    {
        void bark() override // *** oops: not virtual
                             // *** error: only virtual member functions can be marked 'override'
        { std::cout << "woof-woof I won't eat you woof-woof!n" ; }
    };
}

namespace two
{
    struct Dog
    {
        virtual void bark() const
        { std::cout << "A generic dog has spokenn" ; }
    } ;

    struct GentleDog : public Dog
    {
        virtual void bark() override // *** oops: forgot the const
                                     // *** error: 'bark' marked 'override' but does not override any member functions
        { std::cout << "woof-woof I won't eat you woof-woof!n" ; }
    };
}

Topic archived. No new replies allowed.