1

I have multiple format types which each have a name and a value assigned to them. I want to be able to pass in the format type as a parameter into a method. The declaration will look like CreateFile(4,3,2,UGS12_FMT), where UGS12_FMT is a c++ type.

Notice that I am not passing in an instance as a parameter. Any suggestions on how to accomplish this?

Walter
  • 44,150
  • 20
  • 113
  • 196
James
  • 2,951
  • 8
  • 41
  • 55

3 Answers3

1

You cannot pass in a typename as a normal function argument, i.e. your snippet

using UGS12_FMT = some_type;
auto file = CreateFile(4,3,2,UGS12_FMT);  // error

will never work (except when you make CreateFile a macro, which is strongly discouraged).

Instead, you can essentially use one of three alternative techniques.

  1. Overload the function to take different arguments of empty type (so-called tag-dispatching):

    // declarations of tag types
struct format1 {} fmt1; 
struct format2 {} fmt2; // etc
// overloaded file creation functions
file_type CreateFile(args, format1);
file_type CreateFile(args, format2);
// usage:
auto file = CreateFile(4,3,2,fmt1);  // use format1

  2. Use a template (and specialise it for different format types)

    template<typename Format>
file_type CreateFile(args);   // generic template, not implemented
template<> file_type CreateFile<Format1>(args); // one speciliasation
template<> file_type CreateFile<Format2>(args); // another speciliasation

auto file = CreateFile<Format1>(4,3,2);   // usage

  3. Pass the information using an enum type.

    enum struct format {
  f1,                // indicates Format1
  f2 };              // indicates Format2
file_type CreateFile(args,format);

auto file = CreateFile(4,3,2,format::f1);

Finally, you can combine these various approaches using traits classes as similar techniques.

Community
  • 1
  • 1
Walter
  • 44,150
  • 20
  • 113
  • 196
0

There could be many methods to do this. The first method, which is the most recommended, is to inherit each of the class from a common parent class, since they share "name" and "value", as described previously.

If you really need to know what class it is in function "CreateFile", you'd better change the implement of the function, using multiple functions, like

CreateFile(ClassA a)
CreateFile(ClassB a)

instead of 

CreateFile(Class x)
    if x is an instance of ClassA
        doSomething ...
    else if x is an instance of ClassB
        doSomething ...
Davidsun
  • 721
  • 6
  • 13
0

You want to look at what is RTTI. Support varies depending on compiler, but basic functionality is there. A good place to start here.

Note that for instance for GCC you'll need helper functions to unmangle the names given by type_info objects.

EDIT: of course, make sure templates can't offer what you want first, it would be the preferred way.

J.N.
  • 8,203
  • 3
  • 29
  • 39
  • 2
    I can't see how RTTI fits here. – jweyrich Feb 20 '12 at 03:18
  • *If* you can't use templates and you need to do something that ultimately depends on a type, you can use RTTI info (usually in a map of type_info to function) to perform actions conditionally. That avoid the need for writing a possibly long and not so maintenable enum. – J.N. Feb 20 '12 at 05:44
  • We don't know how many file types OP is considering, but if he's going to write code to handle each one of these, maintaining an `enum` along with a `struct` is the easiest task. Besides that, `std::type_info::name()` is not consistent across compilers, thus, if portability is considered, I see that as the primary con. – jweyrich Feb 20 '12 at 06:01
  • Hum, I spoke too fast sorry. I am going to check my facts a bit. At least, for a small number of types, I agree. I think there's a way without using `std::type_info::name()` though. – J.N. Feb 20 '12 at 06:30