如何定义可使用this指针的成员Lambda以访问结构体对象成员？

原代码问题分析 #

你最初的写法有两个核心问题：

1. 无捕获的Lambda才能隐式转换为普通函数指针，而要访问Person对象成员的Lambda必须捕获外部变量（比如对象本身），这类Lambda无法转成std::string(*)()类型的函数指针。
2. Lambda定义时p1尚未完成初始化，即便语法允许，this也不可能指向p1。

你的临时方案通过让函数指针接收Person*参数实现了需求，但调用时需要手动传入对象指针，不够简洁。下面是几个更优的实现方式：

方案1：用std::function存储带捕获的Lambda #

std::function可以存储任意可调用对象（包括带捕获的Lambda），完美适配「每个对象自定义行为」的需求，且调用时无需额外传参：

#include <iostream>
#include <string>
#include <functional>

struct Person{
    std::string sName;
    std::function<std::string()> introduce;
};

int main(){
    Person p1{
        "John",
        // 捕获p1的引用，直接访问成员
        [&p1]() -> std::string {
            return "my name is " + p1.sName;
        }
    };
    std::cout << p1.introduce() << std::endl; // 输出：my name is John

    // 可以给不同对象定义完全不同的introduce逻辑
    Person p2{
        "Alice",
        [&p2]() -> std::string {
            return "Hi! I'm " + p2.sName + ", nice to meet you~";
        }
    };
    std::cout << p2.introduce() << std::endl; // 输出：Hi! I'm Alice, nice to meet you~
}

注意：这里捕获的是对象的引用，如果后续p1被移动、销毁或者拷贝，引用会失效。如果需要支持对象拷贝，可以改为捕获值（[p1]），但会复制对象；或者用智能指针管理对象生命周期。

方案2：构造函数中绑定this，兼顾默认行为与自定义 #

如果希望给Person一个默认的introduce逻辑，同时允许部分对象自定义，可以在构造函数中绑定this到Lambda：

#include <iostream>
#include <string>
#include <functional>

struct Person{
    std::string sName;
    std::function<std::string()> introduce;

    // 默认构造：使用默认的自我介绍逻辑
    explicit Person(std::string name) : sName(std::move(name)) {
        introduce = [this]() {
            return "my name is " + sName;
        };
    }

    // 自定义构造：接受外部传入的自定义逻辑
    Person(std::string name, std::function<std::string(Person*)> custom_func) 
        : sName(std::move(name)) {
        // 绑定当前对象的this到自定义逻辑中
        introduce = [this, custom_func]() {
            return custom_func(this);
        };
    }
};

int main(){
    // 使用默认逻辑的对象
    Person p1("John");
    std::cout << p1.introduce() << std::endl; // 输出：my name is John

    // 使用自定义逻辑的对象
    Person p2("Bob", [](Person* p) {
        return "I'm " + p->sName + ", and I love C++!";
    });
    std::cout << p2.introduce() << std::endl; // 输出：I'm Bob, and I love C++!
}

这个方案既保留了默认行为的简洁性，又能灵活支持自定义，同时调用时无需手动传参，体验更接近普通成员函数。

方案3：模板类存储Lambda（极致性能场景） #

如果追求极致性能，不想引入std::function的开销，可以用模板类存储Lambda类型，每个不同的Lambda会生成对应的模板实例：

#include <iostream>
#include <string>
#include <type_traits>

template<typename Func>
struct Person{
    std::string sName;
    Func introduce;

    Person(std::string name, Func func) 
        : sName(std::move(name)), introduce(std::move(func)) {}
};

// 辅助函数自动推导模板参数
template<typename Func>
Person<std::decay_t<Func>> make_person(std::string name, Func func) {
    return Person<std::decay_t<Func>>(std::move(name), std::move(func));
}

int main(){
    auto p1 = make_person("John", [](auto* p) {
        return "my name is " + p->sName;
    });
    std::cout << p1.introduce(&p1) << std::endl; // 输出：my name is John

    auto p2 = make_person("Alice", [](auto* p) {
        return "Greetings! I'm " + p->sName;
    });
    std::cout << p2.introduce(&p2) << std::endl; // 输出：Greetings! I'm Alice
}

注意：该方案中每个Person对象的类型不同（因为模板参数是Lambda类型），无法将不同自定义逻辑的对象放入同一个容器（比如std::vector<Person>），仅适合不需要多态的场景。

内容的提问来源于stack exchange，提问作者starriet 차주녕