如何在C++中不使用变量名访问变量？模板类场景优化需求

这种重复实现同逻辑函数的烦恼我太懂了！因为结构体成员名不一样就得写两遍几乎一样的代码，完全是冗余工作。这里有几个实用的C++解决方法，帮你摆脱这种困境：

核心思路是把「如何访问目标成员」这个变化点单独抽离，让Controller的核心比较逻辑不用跟着成员名改。

方法1：使用成员指针作为模板参数（C++11+，直接高效） #

这是最适配你场景的方案，给Controller增加一个模板参数，指定要访问的成员指针，就能在函数里统一调用，不用硬编码成员名：

#include <iostream>

// 示例结构体：成员名不同但类型一致
struct Movie {
    int ReleaseYear;
};

struct Book {
    int PublicationYear;
};

// 新增成员指针模板参数，指定要访问的年份成员
template<class T, int T::*YearMember>
class Controller {
private:
    T Object;
public:
    Controller(T obj) : Object(std::move(obj)) {}

    bool YearCompare(int targetYear) {
        // 通过成员指针访问，逻辑完全复用
        return Object.*YearMember == targetYear;
    }
};

// 使用示例
int main() {
    Controller<Movie, &Movie::ReleaseYear> movieCtrl(Movie{2020});
    std::cout << std::boolalpha << movieCtrl.YearCompare(2020) << "\n"; // 输出true

    Controller<Book, &Book::PublicationYear> bookCtrl(Book{1984});
    std::cout << bookCtrl.YearCompare(1984) << "\n"; // 输出true
    return 0;
}

方法2：使用访问器函数/lambda（C++11+，灵活扩展） #

如果之后遇到更复杂的场景（比如年份不是直接成员，而是通过计算得到的），用访问器封装逻辑会更灵活，甚至可以把访问器作为构造参数传递：

template<class T, class YearGetter>
class Controller {
private:
    T Object;
    YearGetter getYear;
public:
    Controller(T obj, YearGetter getter) : Object(std::move(obj)), getYear(std::move(getter)) {}

    bool YearCompare(int targetYear) {
        return getYear(Object) == targetYear;
    }
};

// 使用示例
int main() {
    Movie movie{2020};
    // 用lambda指定成员访问逻辑
    auto movieCtrl = Controller(movie, [](const Movie& m){ return m.ReleaseYear; });

    Book book{1984};
    auto bookCtrl = Controller(book, [](const Book& b){ return b.PublicationYear; });

    std::cout << std::boolalpha << movieCtrl.YearCompare(2020) << "\n";
    std::cout << bookCtrl.YearCompare(1984) << "\n";
    return 0;
}

方法3：C++20 概念 + 统一接口（优雅规范） #

如果你的项目已经升级到C++20，用概念来约束类型的行为是最优雅的方式，通过统一的接口函数适配不同结构体：

#include <concepts>
#include <iostream>

struct Movie { int ReleaseYear; };
struct Book { int PublicationYear; };

// 定义概念：要求类型能通过get_year获取int类型的年份
template<typename T>
concept HasYear = requires(const T& obj) {
    { get_year(obj) } -> std::same_as<int>;
};

// 为每个结构体实现统一的get_year接口
int get_year(const Movie& m) { return m.ReleaseYear; }
int get_year(const Book& b) { return b.PublicationYear; }

// Controller只需要约束类型满足HasYear概念
template<HasYear T>
class Controller {
private:
    T Object;
public:
    Controller(T obj) : Object(std::move(obj)) {}

    bool YearCompare(int targetYear) {
        return get_year(Object) == targetYear;
    }
};

// 使用示例：代码更简洁，不用额外指定模板参数
int main() {
    Controller movieCtrl(Movie{2020});
    Controller bookCtrl(Book{1984});

    std::cout << std::boolalpha << movieCtrl.YearCompare(2020) << "\n";
    std::cout << bookCtrl.YearCompare(1984) << "\n";
    return 0;
}

内容的提问来源于stack exchange，提问作者Synthetic Ascension