Shulou(Shulou.com)06/01 Report--

This article introduces the knowledge of "how C++ combines generics and object-oriented technology". Many people will encounter this dilemma in the operation of practical cases. next, let the editor lead you to learn how to deal with these situations! I hope you can read it carefully and be able to achieve something!

T.5: the combination of generics and object-oriented technologies should enhance their effectiveness rather than cost

Reason (reason)

Generic and OO techniques are complementary.

Generics and object-oriented technologies are complementary.

Example (sample)

Static helps dynamic: Use static polymorphism to implement dynamically polymorphic interfaces.

Static assist dynamic: use static polymorphic technology to realize dynamic polymorphic interface.

Class Command {

/ / pure virtual functions

}

/ / implementations

Template

Class ConcreteCommand: public Command {

/ / implement virtuals

}; Example (example)

Dynamic helps static: Offer a generic, comfortable, statically bound interface, but internally dispatch dynamically, so you offer a uniform object layout. Examples include type erasure as with std::shared_ptr's deleter (but don't overuse type erasure).

Dynamic help static: provides a universal, comfortable static boundary interface, but dynamically distributes internally so that a consistent object layout can be provided. The sample code introduces the same type elimination mechanism as std::shared_ptr 's deleter.

# include

Class Object {

Public:

Template

Object (tipped & obj)

: concept_ (std::make_shared (std::forward (obj) {}

Int get_id () const {return concept_- > get_id ();}

Private:

Struct Command {

Virtual ~ Command () {}

Virtual int get_id () const = 0

}

Template

Struct ConcreteCommand final: Command {

ConcreteCommand (tipped & obj) noexcept: object_ (std::forward (obj)) {}

Int get_id () const final {return object_.get_id ();}

Private:

T object_

}

Std::shared_ptr concept_

}

Class Bar {

Public:

Int get_id () const {return 1;}

}

Struct Foo {

Public:

Int get_id () const {return 2;}

}

Object o (Bar {})

Object O2 (Foo {}); Note (note)

In a class template, non-virtual functions are only instantiated if they're used-- but virtual functions are instantiated every time. This can bloat code size, and may overconstrain a generic type by instantiating functionality that is never needed. Avoid this, even though the standard-library facets made this mistake.

In class templates, non-virtual functions are instantiated only when they are used-but virtual functions are instantiated at any time. This inflates the code and overconstrains generic types by instantiating functionality that is not used at all. To avoid this problem, even standard libraries sometimes make such mistakes.

Enforcement (implementation recommendations)

See the reference to more specific rules.

See more specific rules.

This is the end of how C++ combines generics and object-oriented technology. Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.