C++ 两个类通过智能指针进行访问操作代码

// 定义函数指针类型
typedef void (*CallbackFunction)(int);
class Nav {
public:
    // 将函数指针作为参数传递给Follow类的函数
    void setCallback(CallbackFunction callback) {
        m_callback = callback;
    }
    // 调用回调函数
    void executeCallback() {
        if (m_callback) {
            m_callback(42);
        }
    }
private:
    CallbackFunction m_callback;
};
class Follow {
public:
    // 接收函数，用于调用传递的函数
    void execute(int value) {
        // 在这里可以访问Nav的成员变量
        // ...
        std::cout << "Received value: " << value << std::endl;
    }
};
int main() {
    Nav nav;
    Follow follow;
    // 将Follow类的execute函数作为回调函数传递给Nav类
    nav.setCallback(&Follow::execute);
    // 在Nav类中调用回调函数
    nav.executeCallback();
    return 0;
}

class Nav {
public:
    void execute(int value) {
        // 在这里可以访问Nav的成员变量
        // ...
        std::cout << "Received value: " << value << std::endl;
    }
};
class Follow {
public:
    Follow(Nav* nav) : m_nav(nav) {}
    // 使用存储的Nav指针来调用Nav类的函数
    void executeCallback() {
        if (m_nav) {
            m_nav->execute(42);
        }
    }
private:
    Nav* m_nav;
};
int main() {
    Nav nav;
    Follow follow(&nav);
    // 在Follow类中调用Nav类的函数
    follow.executeCallback();
    return 0;
}

class path_follow {
public:
    void waypointCallback(const bool arrived_flag);
};

void path_follow::waypointCallback(const bool arrived_flag) {
    // 在这里实现waypointCallback的逻辑
    if (arrived_flag) {
        // 如果到达了路径点，执行某些操作
        // ...
    } else {
        // 如果未到达路径点，执行其他操作
        // ...
    }
}

// 定义回调函数类型
typedef void (path_follow::*CallbackFunction)(const bool);
class Nav {
public:
    // 将回调函数作为参数传递给path_follow类的函数
    void setCallback(CallbackFunction callback) {
        m_callback = callback;
    }
    // 调用回调函数
    void executeCallback(const bool flag) {
        if (m_callback) {
            (this->*m_callback)(flag);
        }
    }
private:
    CallbackFunction m_callback;
};
int main() {
    Nav nav;
    path_follow pathFollow;
    // 将waypointCallback函数作为回调函数传递给Nav类
    nav.setCallback(&path_follow::waypointCallback);
    // 在Nav类中调用回调函数
    nav.executeCallback(true);
    return 0;
}

class Nav {
public:
    void waypointCallback(const bool arrived_flag) {
        if (arrived_flag) {
            // 如果到达了路径点，执行某些操作
            // ...
        } else {
            // 如果未到达路径点，执行其他操作
            // ...
        }
    }
    void executeCallback() {
        // 在这里调用回调函数
        bool flag = true; // 假设传递给回调函数的参数
        waypointCallback(flag);
    }
};
class path_follow {
public:
    path_follow(Nav* nav) : m_nav(nav) {}
    void executeNavCallback() {
        // 在这里调用Nav类的回调函数
        bool flag = false; // 假设传递给回调函数的参数
        m_nav->waypointCallback(flag);
    }
private:
    Nav* m_nav;
};
int main() {
    Nav nav;
    path_follow pathFollow(&nav);
    // 在path_follow类中调用Nav类的回调函数
    pathFollow.executeNavCallback();
    return 0;
}

#include <iostream>
class Nav {
public:
    void waypointCallback(const bool arrived_flag) {
        if (arrived_flag) {
            std::cout << "Waypoint reached!" << std::endl;
        } else {
            std::cout << "Waypoint not reached!" << std::endl;
        }
    }
};
class path_follow {
public:
    // 定义函数指针类型
    typedef void (Nav::*CallbackFunction)(const bool);
    path_follow(Nav* nav, CallbackFunction callback) : m_nav(nav), m_callback(callback) {}
    void executeNavCallback() {
        // 在这里调用Nav类的回调函数
        bool flag = true; // 假设传递给回调函数的参数
        (m_nav->*m_callback)(flag);
    }
private:
    Nav* m_nav;
    CallbackFunction m_callback;
};
int main() {
    Nav nav;
    // 定义函数指针
    path_follow::CallbackFunction callback = &Nav::waypointCallback;
    path_follow pathFollow(&nav, callback);
    // 在path_follow类中调用Nav类的回调函数
    pathFollow.executeNavCallback();
    return 0;
}

#include <memory>
class PathFollow : public std::enable_shared_from_this<PathFollow> {
public:
    void someMethod() {
        // 将 this 转换为 std::shared_ptr<PathFollow>
        std::shared_ptr<PathFollow> sharedThis = shared_from_this();
        // 使用 sharedThis 进行操作
        // ...
    }
};
int main() {
    std::shared_ptr<PathFollow> pathFollow = std::make_shared<PathFollow>();
    pathFollow->someMethod();
    return 0;
}