将方法添加到现有的C++；在其他文件中初始化 < C++ >是否可以在不编辑原始类文件的情况下扩展一个不同的源文件中的一个类（添加方法）？< /p>
在obj-c中，可以通过编写另一个接口AbcClass（ExtCategory）@结束 我在尝试以下操作时出现编译时错误：将方法添加到现有的C++；在其他文件中初始化 < C++ >是否可以在不编辑原始类文件的情况下扩展一个不同的源文件中的一个类（添加方法）？< /p>,c++,C++,在obj-c中，可以通过编写另一个接口AbcClass（ExtCategory）@结束 我在尝试以下操作时出现编译时错误： //Abc.h class Abc { //This class is from a 3rd party library.... // ...I don't want to edit its source file. void methodOne(); void methodTwo();
//Abc.h
class Abc { //This class is from a 3rd party library....
// ...I don't want to edit its source file.
void methodOne();
void methodTwo();
}
//Abc+Ext.h
class Abc { // ERROR: Redefinition of 'Abc'
void methodAdded();
}
有办法做到这一点吗？在编写C++代码时我是新手。我熟悉它的一些语法，但知道的不多。不。这种类扩展在
C++//Abc.h
class Abc {
void methodOne();
void methodTwo();
};
//Abc+Ext.h
class AbcExt : public Abc {
void methodAdded();
};
std::unique_ptr<AbcExt> obj = std::make_unique<AbcExt>();
obj->methodOne(); // by the virtue of base class
obj->methodAdded(); // by the virtue of derived class
std:：unique_ptr obj=std:：make_unique（）；
obj->methodOne（）；//凭借基础阶级的力量
obj->methodAdded（）；//借助于派生类
在当前C++中，没有直接的机制来做这件事，但是有几种方法可以以某些锅炉板工作为代价来实现它：
方法1：
// foo.h
class Foo {
private: // stuff
public: // stuff
private:
// All this crap is private. Pretend like I didn't expose it.
// yeah, I know, you have to compile it, and it probably adds
// dependencies you don't want to #include, like <string>
// or boost, but suck it up, cupcake. Stroustrup hates life.
void internalHelper(std::string&, std::vector&, boost::everything&);
};
方法3：
// foo.h
class Foo {
private: // stuff
public: // stuff
// For the private api: this is the worst approach, since it
// exposes stuff and forces include/cruft on consumers.
friend void foo_internalHelper(std::string&, std::vector&, boost::everything&);
};
// foo.cpp
// don't make it static or anyone can make their own as a way to
// back door into our class.
void foo_internalHelper(...);
方法4：
// foo.h
class Foo {
private: // stuff
public: // stuff
// No dependencies, but nothing stops an end-user from creating
// a FooPrivate themselves...
friend class FooPrivate;
};
// foo1.cpp
class FooPrivate {
public:
void fooInternalHelper(Foo* f) {
f->m_privateInternalYouCantSeeMe = "Oh, but I can";
}
};
您不能扩展类Abc
，句点
唯一的出路是独立的功能，如
Abc add(const Abc& a, int b);
有一种方法可以做到这一点，但它需要编译器支持#include_next
。GCC有这个功能，不知道其他编译器。它还需要至少支持C++11
我不认为这个把戏很漂亮，但它确实起到了作用
确保您的包含路径在原始代码所在的目录之前包含“扩展名”文件所在的目录（即，如果原始Abc.hpp
位于src
，则将其移动到src/some\u dir
）。因此，在本例中，您的include dir将是-Isrc-Isrc/some_dir
您的“扩展名”代码应该位于与原始代码名称完全相同的文件中。因此，对于这个例子，它是Abc.hpp#ifndef ABC_EXT_HPP_
#define ABC_EXT_HPP_
#include <utility>
namespace evil {
// Search the include path for the original file.
#include_next "Abc.hpp"
}
class Abc : public evil::Abc {
public:
/*
// Inherit all constructors from base class. Requires GCC >=4.8.
using evil::Abc::Abc;
*/
/* Use the solution below if your compiler supports C++11, but not
* inheriting constructors.
*/
template <class... Args>
Abc (Args... args) : evil::ABC(std::forward<Args...>(args...)) { }
~Abc () { }
void methodAdded () { /* Do some magic. */ }
};
#endif // ABC_EXT_HPP_
\ifndef ABC\u EXT\u水电站_
#定义ABC_EXT_水电站_
#包括
名称空间邪恶{
//搜索原始文件的包含路径。
#包括下一个“Abc.hpp”
}
Abc类：公害：：Abc{
公众：
/*
//从基类继承所有构造函数。要求GCC>=4.8。
使用邪恶：：Abc：：Abc；
*/
/*如果您的编译器支持C++11，但不支持
*继承构造函数。
*/
模板
Abc（Args…Args）：邪恶：：Abc（std：：转发（Args…）{}
~Abc（）{}
void methodAdded（）{/*做一些魔术。*/}
};
#endif//ABC\u EXT\u水电站_
Abc.hppAbc bla=evil:：Abc（9）evil:AbcAbc编辑2:一旦涉及嵌套名称空间，您可能会遇到很多麻烦。当原始
Abc.hpp#includeevilevilc++obj-c//Abc.h
namespace LibraryA {
class Abc { //This class is from a 3rd party library....
// ...I don't want to edit its source file.
void methodOne();
void methodTwo();
}
}
//Abc+Ext.hpp
namespace MyProj {
class Abc : public LibraryA::Abc {
using Base = LibraryA::Abc; //desc: this is to easily access the original class...
// ...by using code: Abc::Base::someOrigMethod();
using Base::Base; //desc: inherit all constructors.
protected:
//---added members:
int memberAdded;
public:
//---added methods:
void methodAdded();
//---modified virtual member funcs from original class.
void origMethod_A() override;
}
}
//Abc+Ext.cpp
namespace MyProj {
void Abc::origMethod_A() {
//...some code here...
Base::origMethod_A(); //desc: you can still call the orignal method
//...some code here...
}
}
//SomeSourceFile_ThatUses_Abc.cpp
namespace MyProj { //IMPT NOTE: you really need to enclose your...
// ...project specific code to a namespace so you can...
// ...use the version of class Abc you extended.
void SomeClass::SampleFunc(){
Abc objX; //create MyProj::Abc object.
objX.methodAdded(); //calls MyProj::Abc::methodAdded();
objX.origMethod_A(); //calls MyProj::Abc::origMethod_A();
Abc::Base objY; //create Library::Abc object.
//objY.methodAdded(); //method not existing.
objY.origMethod_A(); //calls Library::Abc::origMethod_A();
//...some code here...
}
}
//SomeModule.cpp
namespace OtherNamespace {
void SomeOtherClass::SampleOtherFunc(){
Abc objZ; //create Library::Abc object.
//objZ.methodAdded(); //method not existing.
objZ.origMethod_A(); //calls LibraryA::Abc::origMethod_A();
}
}
类Abc//MyLib_ModuleA_Classes.hpp
namespace MyLib_ModuleA {
class Abc : public LibraryA::Abc {
//...add extensions here...
void addedMethod_X();
void origMethod_A() override; //own overriden behavior specific to this ModuleA only.
}
}
//MyLib_ModuleB_Classes.hpp
namespace MyLib_ModuleB {
class Abc : public LibraryA::Abc {
//...add extensions here...
void addedMethod_Y();
void origMethod_A() override; //own overriden behavior specific to this ModuleB only.
}
}
类AbcLibaryA:：Abc：：Abcc++14c++11c++17c++20当我使用的编译器已经完成了
c++20abcOne.add
//MyLib_ModuleA_Classes.hpp
namespace MyLib_ModuleA {
class Abc : public LibraryA::Abc {
//...add extensions here...
void addedMethod_X();
void origMethod_A() override; //own overriden behavior specific to this ModuleA only.
}
}
//MyLib_ModuleB_Classes.hpp
namespace MyLib_ModuleB {
class Abc : public LibraryA::Abc {
//...add extensions here...
void addedMethod_Y();
void origMethod_A() override; //own overriden behavior specific to this ModuleB only.
}
}