虚方法的C++部分模板专门化

Question

#include <iostream>
#include <array>
#include <cmath>

template<typename T, std::size_t DIM>
class Shape {
public:
    Shape(std::array<T,DIM> base_point) : base_point_(base_point) {}
    virtual T volume() const = 0;
protected:
    std::array<T,DIM> base_point_;
};

template<typename T, std::size_t DIM>
class Ball : public Shape<T,DIM> {
public:
    Ball(std::array<T,DIM> base_point, T radius) : Shape<T,DIM>(base_point), radius_(radius) {}
    virtual T volume() const;
private:
    T radius_;
};

// Cannot use the generic code below because of Template may not be 'virtual' ?
// template<typename T>
// T Ball<T,2>::volume() const { return M_PI * radius_ * radius_; }

template<>
float Ball<float,2>::volume() const { return M_PI * radius_ * radius_; }

// template<typename T>
// T Ball<T,3>::volume() const { return 4/3 * M_PI * radius_ * radius_ * radius_; }

template<>
float Ball<float,3>::volume() const { return 4/3 * M_PI * radius_ * radius_ * radius_; }

int main() {
    Ball<float,2> circle{{0.2f,0.3f}, 4.0f};
    std::cout << circle.volume() << std::endl;
}

shape_generic_naive.cpp:24:25: error: invalid use of incomplete type ‘class Sphere<T, 2ul>’
 T Sphere<T,2>::volume() const {return M_PI * radius_ * radius_; }
                         ^
shape_generic_naive.cpp:15:7: error: declaration of ‘class Sphere<T, 2ul>’
 class Sphere : public Shape<T,DIM> {

Answer 1

几乎总是，如果您需要函数模板的部分专门化，您可以使用“委托到类”技巧：

template <class T, std::size_t DIM>
struct BallVolume;

template <class T>
struct BallVolume<T, 2>
{
  static T compute(T radius) { return M_PI * radius * radius; }
};

template <class T>
struct BallVolume<T, 3>
{
  static T compute(T radius) { return 4.0/3.0 * M_PI * radius * radius * radius; }
};


template<typename T, std::size_t DIM>
class Ball : public Shape<T,DIM> {
public:
    Ball(std::array<T,DIM> base_point, T radius) : Shape<T,DIM>(base_point), radius_(radius) {}
    virtual T volume() const { return BallVolume<T, DIM>::compute(radius_); }
private:
    T radius_;
};

请注意，3D卷的公式不正确:4/3是1，因为它是整数除法。

此外，为了使它真正与类型无关，您应该将常数强制转换为t:

return static_cast<T>(M_PI) * radius * radius;
return 4 / static_cast<T>(3.0) * static_cast<T>(M_PI) * radius * radius * radius;