How to use Templated methods in C++?

Question

In my header file, I have two different kind of objects ImageFrame and `PointCloudFrame. These are then defined with a std::variant as such

struct ImageFrame{

};

struct PointCloudFrame{

};

using SensorFrame = std::variant<std::shared_ptr<ImageFrame>,
                                std::shared_ptr<PointCloudFrame>>;

I need to write a template method for both these objects so I did it like this in the headerfile:

template<class T>
std::string getFrameBin(const T& frame);

And in the cpp file

template <class ImageFrame>
std::string getFrameBin(const ImageFrame& image_frame)
{
  std::string x;
  return x;
}

template <class PointCloudFrame>
std::string getFrameBin(const PointCloudFrame& cloud_frame)
{
  std::string x;
  return x;
}

However, I get the error relating to: error: redefinition of 'template<class PointCloudFrame> std::string

What am I doing wrong? Is there a more elegant way to do this to make use of the SensorFrame object

Template code needs to be defined in the header file, not the `cpp` file. — jkb, Jun 14 '21 at 17:33
`std::variant` was added in C++17. The C++11 tag makes no sense. — Aykhan Hagverdili, Jun 14 '21 at 17:40

score 4 · Answer 1 · answered Jun 14 '21 at 17:36

This doesn't need to be a template. It's just overloading:

std::string getFrameBin(const ImageFrame&) {
    // do ImageFrame stuff
}

std::string getFrameBin(const PointCloudFrame&) {
    // do PointCloudFrame stuff
}

Declare the two functions in a header file and implement them in a .cpp file.

score 2 · Accepted Answer · answered Jun 14 '21 at 17:33

template <class ImageFrame>
std::string getFrameBin(const ImageFrame& image_frame)
{
  std::string x;
  return x;
}

Means the same thing as

template <class T>
std::string getFrameBin(const T& image_frame)
{
  std::string x;
  return x;
}

So you are defining your template twice. If you mean to make specializations for the templated function, the syntax would be:

template <>
std::string getFrameBin(const ImageFrame& image_frame)
{
  std::string x;
  return x;
}

template <>
std::string getFrameBin(const PointCloudFrame& cloud_frame)
{
  std::string x;
  return x;
}

I am going to accept it as the solution as its the closest to what i want — raaj, Jun 14 '21 at 18:15

score 1 · Answer 3 · answered Jun 14 '21 at 17:36

1

Here's how I would do it:

#include <cstdio>
#include <memory>
#include <variant>

struct ImageFrame {};

struct PointCloudFrame {};

using SensorFrame =
    std::variant<std::shared_ptr<ImageFrame>, std::shared_ptr<PointCloudFrame>>;

struct Visitor {
  void operator()(std::shared_ptr<ImageFrame> const&) const {
    // Use image frame
    std::puts("Visiting image");
  }
  void operator()(std::shared_ptr<PointCloudFrame> const&) const {
    // Use point cloud
    std::puts("Visiting point cloud");
  }
};

int main() {
  SensorFrame frame = std::make_shared<ImageFrame>();
  std::visit(Visitor{}, frame);
  frame = std::make_shared<PointCloudFrame>();
  std::visit(Visitor{}, frame);
}

answered Jun 14 '21 at 17:36

Aykhan Hagverdili

28,141
6
41
93

This is a really nice idea. – raaj Jun 14 '21 at 18:15
Can I know what the syntax in `Visitor{}` particularly the `{}` here means? – raaj Jun 14 '21 at 18:16
@raaj it creates a temporary object. You could also use `Visitor()`. – Aykhan Hagverdili Jun 14 '21 at 18:19
Is the only option to use that operator() flag? What about having other methods in there and making std::visit call those? – raaj Jun 14 '21 at 18:40
@raaj no, it has to be the `operator()`. That's the API – Aykhan Hagverdili Jun 14 '21 at 18:56

score 0 · Answer 4 · answered Jun 14 '21 at 17:35

You defined the same template twice. The parameter name is just a name. Compare your code to:

void foo(int x) {}

void foo(int y) {}

Similar to how you defined the same template twice, this is two definitions for the same function.

When the implementation is identical, it actually is a good case for templates, but define it only once:

template <class T>
std::string getFrameBin(const T& cloud_frame)
{
  std::string x;
  return x;
}

Then call it with either type as parameter and the template parameter will be deduced from the function parameter. When the implementation is not identical, you should rather provide two overloads. If you still want to stay with the template, you can specialize it as outlined in the other answer.

Also read this: Why can templates only be implemented in the header file?

How to use Templated methods in C++?

4 Answers4