C++ class template with conditional data members

Conditionally existing fields can be implemented via inheritance, and compile-time handling of variable-length argument lists can be achieved using pack expansions:

#include <set>
#include <string>
#include <cstdint>
#include <iostream>

enum class Field : uint8_t {
    kX,
    kY
};

namespace {
    std::string ToString(const Field field) {
        switch (field) {
            case Field::kX: return "x";
            case Field::kY: return "y";
            default:        return "?";
        }
    }
}  // namespace

template<Field FieldName>
struct FieldStorage;

template<>
struct FieldStorage<Field::kX> {
    int x{0};
};
template<>
struct FieldStorage<Field::kY> {
    int y{0};
};

template<Field... FieldsList>
struct S : FieldStorage<FieldsList>... {
    static const std::set<std::string>& Fields() {
        static const std::set<std::string> kFields{ToString(FieldsList)...};
        return kFields;
    }
};

int main() {
    S<Field::kX> SWithXOnly;
    SWithXOnly.x = 1;
    // SWithXOnly.y = 2; // Will produce compilation error.

    S<Field::kY> SWithYOnly;
    SWithYOnly.y = 1;
    // SWithYOnly.x = 2; // Will produce compilation error.

    S<Field::kX, Field::kY> SWithBoth;
    SWithBoth.x = 1;
    SWithBoth.y = 2;

    for (const std::string& field : decltype(SWithBoth)::Fields()) { 
        std::cout << field << "\n";
    }
}

This solution scales linearly with the number of fields, improving upon the exponential approach. Further improvements to scalability or reduction of boilerplate code would likely require heavy use of macros.

I think the main question would be how would you like to get your name of fields TheAliceBaskerville provided a great way to calculate fields. I'll suggest just separate out the implementation of data formatting and struct S unless S is used for formatting and get the field names.

Following prints X: x, Y: y, XY:x,y

Live Demo

#include <iostream>
#include <vector>
#include <string>
#include <fmt/format.h>
#include <fmt/ranges.h>
#include <algorithm>
#include <iostream>
#include <set>
#include <string>
#include <string_view>
#include <array>

// C++23 has std::to_underlying
template <typename E>
constexpr auto
to_underlying(E e) noexcept
{
    return static_cast<std::underlying_type_t<E>>(e);
}

enum class Field: unsigned { kX, kY, LAST };
 // additional one to set terminate mark
using FieldArray = std::array<Field, to_underlying(Field::LAST) + 1>;

std::string ToString(const Field f) {
  static constexpr std::array<std::string_view,to_underlying(Field::LAST)> STR_MAP{
    "x",
    "y"
  };
  if(f >= Field::LAST){
    return "?";
  }
  return std::string(STR_MAP[to_underlying(f)]);
}

template<typename T>
consteval FieldArray computeFields(){
    std::vector<Field> fields;
    constexpr bool has_x = requires(const T& t) {
        t.x;
    };
    constexpr bool has_y = requires(const T& t) {
        t.y;
    };
    size_t index = 0;
    if(has_x){
        fields.push_back(Field::kX);
    }
    if(has_y){
        fields.push_back(Field::kY);
    }
    FieldArray arr;
    std::copy_n(fields.begin(), fields.size(), arr.begin());
    arr[fields.size()] = Field::LAST;
    
    return arr;
}

template<typename T>
std::set<std::string> FieldStrings() {
  std::set<std::string> field_strings;
  constexpr auto fields = computeFields<T>();
  for(auto field: fields){
    if(field == Field::LAST) break; // End of fields
    field_strings.insert(ToString(field));
  }
  return field_strings;
}

struct DataX{
    int x;

};

struct DataY{
    int y;

};
struct DataXY{
    int x;
    int y;

};

template <typename T> struct S {
  T data{};

  // Should return `ToString` called on all of the `Field`s in `Args`.
  static const std::set<std::string> Fields() {
    static const std::set<std::string> kFields = FieldStrings<T>();
    return kFields;
  }
};

int main(){ 
    fmt::print("X: {}, Y: {}, XY:{}", 
        fmt::join(S<DataX>::Fields(), ","),
        fmt::join(S<DataY>::Fields(), ","),
        fmt::join(S<DataXY>::Fields(), ",") );
    return 0;
}