Non-type template argument, from constant function argument?

Question

I'm experimenting with C++ templates, and a kind of heterogenous type-safe map. Keys go with specific types. An example use would be something like a CSS stylesheet. I've got it to where I can things write:

styles.set<StyleKey::fontFamily>("Helvetica");
styles.set<StyleKey::fontSize>(23.0);

That type checks as desired; it won't compile calls where the key does not match it's intended value type. But I'm wondering if there's also a way to write it like this:

styles.set(StyleKey::fontFamily, "Helvetica");
styles.set(StyleKey::fontSize, 23.0);

... and have it deduce the same thing, because the first argument is a constant.

Here's my flailing attempt, pasted below and on godbolt. The set2 template does not work.

#include <iostream>
#include <string>

using namespace std;

struct color {
  float r,g,b;
};
ostream &operator <<(ostream &out, const color &c) {
  return out << "[" << c.r << ',' << c.g << ',' << c.b << "]";
}

// Gives something that would have types: string, float, color, bool
enum class StyleKey {
  fontFamily = 1, fontSize, fontColor, visible
};

template <StyleKey key>
struct KeyValueType {

};

struct StyleMap;

template <>
struct KeyValueType<StyleKey::fontFamily> {
  typedef string value_type;
  static void set(StyleMap *sm, value_type value);
};
template <>
struct KeyValueType<StyleKey::fontSize> {
  typedef float value_type;
  static void set(StyleMap *sm, value_type value);  
};

struct StyleMap {
  string fontFamily = "";
  float fontSize = 14;
  color fontColor = color{0,0,0};
  bool visible = true;

  template <StyleKey key>
  void set(typename KeyValueType<key>::value_type value) {
    cout << "set " << (int)key << " value: " << value << endl;
    KeyValueType<key>::set(this, value);
  }

  template <StyleKey key>
  void set2(StyleKey key2, typename KeyValueType<key>::value_type value) {
    static_assert(key == key2);
    cout << "set " << (int)key << " value: " << value << endl;
  }
};

void KeyValueType<StyleKey::fontFamily>::set(StyleMap *sm, string str) {
  sm->fontFamily = str;
}
void KeyValueType<StyleKey::fontSize>::set(StyleMap *sm, float sz) {
  sm->fontSize = sz;
}

void print(const StyleMap &sm) {
  cout << "font family : " << sm.fontFamily  << endl;
  cout << "font size   : " << sm.fontSize    << endl;
  cout << "color       : " << sm.fontColor   << endl;
  cout << "visible     : " << sm.visible     << endl;  
}

int main() {

  // Goal:
  //
  // StyleMap styles;
  // styles[fontFamily] = "Helvetica";
  // styles[fontSize] = 15.0;
  // string fam = styles[fontFamily]
  // float sz   = styles[fontSize];
  
  StyleMap styles;

  // This works!
  styles.set<StyleKey::fontFamily>("Helvetica");
  styles.set<StyleKey::fontSize>(23.0);

  // This won't compile, as desired
  // styles.set<StyleKey::fontFamily>(20);

  // But can we write it like this?
  // styles.set2(StyleKey::fontFamily, "Helvetica");
  // styles.set2(StyleKey::fontSize, 23.0);  

  print(styles);
}

I can't think of anything better than a macro, like `#define set2(key, val) set(val)` I suspect this cure is worse than the disease. It's relatively easy to implement your desired syntax if it's OK to detect the type mismatch at runtime; but I don't see a way to have it fail at compile time. — Igor Tandetnik, Sep 19 '22 at 03:41

score 1 · Accepted Answer · answered Sep 19 '22 at 03:57

You can't do SFINAE or specialization on function parameters, only template parameters. That means this can't work using your current approach.

What you could do is change your StyleKeys from being enum values to being empty tag structs with different types. Then you could specialize KeyValueType on each of those types and pass an object of one of those types to StyleMap::set. It can then use the type of that object to deduce the correct KeyValueType specialization to dispatch to.

namespace StyleKey {
  static constexpr inline struct FontFamily {} fontFamily;
  static constexpr inline struct FontSize {} fontSize;
};

template <typename KeyType>
struct KeyValueType {};

struct StyleMap;

template <>
struct KeyValueType<StyleKey::FontFamily> {
  using value_type = std::string;
  static void set(StyleMap *sm, value_type value);
};
template <>
struct KeyValueType<StyleKey::FontSize> {
  using value_type = float;
  static void set(StyleMap *sm, value_type value);  
};

struct StyleMap {
  std::string fontFamily = "";
  float fontSize = 14;

  template <auto key>
  void set(typename KeyValueType<std::remove_const_t<decltype(key)>>::value_type value) {
    KeyValueType<std::remove_const_t<decltype(key)>>::set(this, value);
  }

  template <typename KeyType>
  void set2(KeyType key, typename KeyValueType<KeyType>::value_type value) {
    KeyValueType<KeyType>::set(this, value);
  }
};

void KeyValueType<StyleKey::FontFamily>::set(StyleMap *sm, std::string str) {
  sm->fontFamily = str;
}
void KeyValueType<StyleKey::FontSize>::set(StyleMap *sm, float sz) {
  sm->fontSize = sz;
}

Demo

Note: This approach will also work for the goal mentioned in the comment in your main function. Example.

Interesting, thanks. Any tips on how to get educated on this template programming topic? I see _C++ Templates: The Complete Guide_, by Vandevoorde, et al. It's 2017 so maybe not too obsolete yet. — Rob N, Sep 19 '22 at 19:54
@RobN Sadly I don't have any book recommendations I can make from personal experience. Anything on [The Definitive C++ Book Guide and List](https://stackoverflow.com/questions/388242/the-definitive-c-book-guide-and-list) should be pretty good, but I've not personally read any of them (I learned it all the hard way: by reading a lot of SO answers). — Miles Budnek, Sep 19 '22 at 20:07

Non-type template argument, from constant function argument?

1 Answers1