하나의 루트 객체를 가지면 많은 보상없이 수행 할 수있는 작업과 컴파일러가 수행 할 수있는 작업이 제한됩니다.
공통 루트 클래스를 사용하면 모든 컨테이너를 작성하고로 포함 된 것을 추출 할 수 dynamic_cast있지만 컨테이너가 필요한 경우 공통 루트 클래스 없이도 비슷한 것을 boost::any수행 할 수 있습니다 . 그리고 또한 프리미티브를 지원합니다 - 심지어 작은 버퍼 최적화를 지원하고 자바 용어로 거의 "박스 없음"을 남길 수 있습니다.boost::any
C ++는 가치 유형을 지원하고 번성합니다. 리터럴과 프로그래머가 작성한 값 유형. C ++ 컨테이너는 값 유형을 효율적으로 저장, 정렬, 해시, 소비 및 생성합니다.
상속, 특히 모 놀리 식 상속 Java 스타일 기본 클래스는 프리 스토어 기반의 "포인터"또는 "참조"유형을 필요로합니다. 핸들 / 포인터 / 데이터 참조는 클래스의 인터페이스에 대한 포인터를 보유하며 다형성으로 다른 것을 나타낼 수 있습니다.
일부 상황에서는 유용하지만 "공통 기본 클래스"를 사용하여 패턴과 결혼 한 후에는 유용하지 않은 경우에도 전체 패턴베이스를이 패턴의 비용과 수하물에 고정했습니다.
호출 사이트 나 코드를 사용하는 코드에서 "객체"라는 것보다 유형에 대해 더 많이 알고있을 것입니다.
함수가 단순하면 함수를 템플리트로 작성하면 호출 사이트의 정보가 버려지지 않는 오리 유형 컴파일 시간 기반 다형성이 제공됩니다. 기능이 더 복잡한 경우 수행하려는 유형 (예 : 직렬화 및 역 직렬화)에 대한 균일 한 작업을 빌드하고 저장 (컴파일 시간에)하여 런타임에 소비 할 수 있도록 유형 삭제를 수행 할 수 있습니다. 다른 번역 단위의 코드.
모든 것을 직렬화 할 수있는 라이브러리가 있다고 가정하십시오. 한 가지 방법은 기본 클래스를 사용하는 것입니다.
struct serialization_friendly {
virtual void write_to( my_buffer* ) const = 0;
virtual void read_from( my_buffer const* ) = 0;
virtual ~serialization_friendly() {}
};
이제 여러분이 작성하는 모든 코드가 가능합니다 serialization_friendly.
void serialize( my_buffer* b, serialization_friendly const* x ) {
if (x) x->write_to(b);
}
를 제외한 std::vector모든 컨테이너를 작성해야합니다. 그리고 그 큰 숫자 라이브러리에서 얻은 정수는 아닙니다. 그리고 그런 유형은 직렬화가 필요하지 않다고 썼습니다. 그리고이 아니 tuple거나 int또는 double, 나 std::ptrdiff_t.
우리는 다른 접근 방식을 취합니다.
void write_to( my_buffer* b, int x ) {
b->write_integer(x);
}
template<class T,
class=std::enable_if_t< void_t<
std::declval<T const*>()->write_to( std::declval<my_buffer*>()
> >
>
void write_to( my_buffer* b, T const* x ) {
if (x) x->write_to(b);
}
template<class T>
void serialize( my_buffer* b, T const& t ) {
write_to( b, t );
}
겉보기에는 아무것도하지 않는 것으로 구성되어 있습니다. 이제는 유형의 네임 스페이스 또는 유형의 메서드에서 자유 함수로 write_to재정 의하여 확장 할 수 있습니다 write_to.
우리는 약간의 삭제 코드를 작성할 수도 있습니다.
namespace details {
struct can_serialize_pimpl {
virtual void write_to( my_buffer* ) const = 0;
virtual void read_from( my_buffer const* ) = 0;
virtual ~can_serialize_pimpl() {}
};
}
struct can_serialize {
void write_to( my_buffer* b ) const { pImpl->write_to(b); }
void read_from( my_buffer const* b ) { pImpl->read_from(b); }
std::unique_ptr<details::can_serialize_pimpl> pImpl;
template<class T> can_serialize(T&&);
};
namespace details {
template<class T>
struct can_serialize : can_serialize_pimpl {
std::decay_t<T>* t;
void write_to( my_buffer*b ) const final override {
serialize( b, std::forward<T>(*t) );
}
void read_from( my_buffer const* ) final override {
deserialize( b, std::forward<T>(*t) );
}
can_serialize(T&& in):t(&in) {}
};
}
template<class T> can_serialize::can_serialize<T>(T&&t):pImpl(
std::make_unique<details::can_serialize<T>>( std::forward<T>(t) );
) {}
이제 임의의 유형을 가져 와서 가상 인터페이스를 통해 나중에 can_serialize호출 할 수 있는 인터페이스에 자동 상자를 넣을 수 있습니다 serialize.
그래서:
void writer_thingy( can_serialize s );
대신 직렬화 할 수있는 모든 것을 취하는 함수입니다.
void writer_thingy( serialization_friendly const* s );
그리고 첫 번째, 두 번째는 달리, 그것은 처리 할 수있는 int, std::vector<std::vector<Bob>>자동으로.
작성하는 데 많은 시간이 걸리지 않았으며, 특히 이런 종류의 일은 당신이 거의 원하지 않는 일이기 때문에 기본 유형을 요구하지 않고 직렬화 가능한 것으로 취급 할 수있는 능력을 얻었습니다.
무엇을 더, 지금 우리가 할 수 std::vector<T>단순히 대체하여 일류 시민으로 직렬화 write_to( my_buffer*, std::vector<T> const& )- 그 과부하, 그것은에 전달 될 수 can_serialize와의 serializabilty는 std::vector의 vtable에 저장하고 액세스됩니다 .write_to.
간단히 말해 C ++은 필요할 때 강제 상속 계층 구조의 가격을 지불하지 않고도 필요할 때 즉시 단일 기본 클래스의 이점을 구현할 수있을 정도로 강력합니다. 그리고 단일 염기 (가짜 또는 불필요)가 필요한 시간은 합리적입니다.
유형이 실제로 자신의 정체성이고 그 유형을 알면 최적화 기회가 많이 있습니다. 데이터는 로컬에 연속적으로 저장되어 있으며 (현대 프로세서의 캐시 친화성에 매우 중요), 컴파일러는 불투명 한 가상 메소드 포인터를 사용하지 않고 지정된 작업이 수행하는 작업을 쉽게 이해할 수 있습니다. 다른 쪽)을 사용하면 명령을 최적으로 재정렬하고 둥근 구멍에 적은 수의 둥근 못을 박을 수 있습니다.