调用模板成员 function 和 object 和私有成员

Question

I have this templated function which argument is the member function of any object:

// Function that captures the data
template <class T>
bool captureData(T& f_captureObject, bool (T::* f_captureFunction)())
{
    // Lock data access
    std::unique_lock<std::mutex> lock(m_mutex);

    // Capture data and check if it is ready
    if ((f_captureObject.*f_captureFunction)() == true)
    {
        // If data is ready ...

        // Set data flag to ready
        m_isReady = true;

        // Notify if processing thread is waiting
        m_conditionVariable.notify_one();
    }
    else
    {
        // If data is not ready ...

        // Set data flag to not ready
        m_isReady = false;
    }

    // Return grab state
    return !m_isReady;
};

The way I call it is:

m_monitorLidar.captureData<Lux>(m_lidar, &Lux::captureScanOffline);

Where m_lidar is a Lux object whose.hpp is:

#pragma once

// Includes
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

// Standard
#include <iostream>
#include <fstream>
#include <thread>

// User
#include "PlatformTypes.hpp"
#include "VariableTypes2.hpp"
#include "Timer.hpp"

// Namespaces
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
using namespace std;
using namespace chrono;

// Class
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
class Lux
{

// Variables
// ------------------------------------------------------------------------------------------------

private:

    // Scan number
    uint32 m_scanNumber;

    // Scan captured
    Scan m_scanCaptured;

    // Scan saved
    Scan m_scanSaved;

    // Flag indicating if scan is captured
    bool m_isCaptured;

    // Flag indicating if scan is saved
    bool m_isSaved;

    // Scans file
    string m_fileScans;

    // Lidar points file stream
    ifstream m_lidarPointsFileStream;

    // Number of scans of a file
    uint32 m_numScansFile;

    // Timer for the simulation
    Timer m_timer;

    // Scan rate for the simulation
    uint64 m_scanRate;

// Functions
// ------------------------------------------------------------------------------------------------

public:
    
    // Constructor
    Lux();

    // Destructor
    ~Lux();

    // Initilization function
    void init();

    // Initilization function in offline mode
    bool initOffline(string f_fileScans);

    // Initilization function in online mode
    bool initOnline();

    // Initilization function in simulation mode
    bool initSimulation(string f_fileScans, uint64 f_scanRate);

    // Capture scan offline
    bool captureScanOffline();

    // Capture scan online
    bool captureScanOnline();

    // Capture scan simulation
    bool captureScanSimulation();

    // Save the captured scan
    void saveScan();

    // Get scan points from sensor/file
    bool getScanPoints();

    // Getters
    uint32 getScanNumber();
    const Scan& getScanCaptured();
    const Scan& getScanSaved();
    bool getIsCaptured();
    bool getIsSaved();

private:

     //Open lidar file
    bool openFile();

    // Close lidar file
    void closeFile();
};

And its.cpp file is:

#include "Lux.hpp"

Lux::Lux()
{
    init();
}

Lux::~Lux()
{
    // Close lidar file
    closeFile();
}

void Lux::init()
{
    // Error flag
    bool error = false;

    // Scan number
    m_scanNumber = 0U;

    // Init stereo images
    m_scanCaptured.init();

    // Init flag indicating if scan is captured
    m_isCaptured = false;

    // Set flag indicating scan is not saved
    m_isSaved = false;
}

bool Lux::initOffline(string f_fileScans)
{
    // Function error
    bool error = false;

    // Set file path
    m_fileScans = f_fileScans;

    // Open file
    error = openFile();

    // Return error status
    return error;
}

bool Lux::initOnline()
{
    // Function error
    bool error = false;

    // Return error status
    return error;
}

bool Lux::initSimulation(string f_fileScans, uint64 f_scanRate)
{
    // Function error
    bool error = false;

    // Init in offline mode
    error = initOffline(f_fileScans);

    // Set scan rate
    m_scanRate = f_scanRate;

    // Return error status
    return error;
}

bool Lux::captureScanOffline()
{
    // Check if there are scans
    if (m_scanNumber < m_numScansFile)
    {
        // If there are scans ...

        // Read number of echoes
        m_lidarPointsFileStream.read((char*)(m_scanCaptured.ne), p_maxNumberOfPointsPerEcho * sizeof(uint32));

        // Read radial distance
        m_lidarPointsFileStream.read((char*)(m_scanCaptured.sc.rd), p_maxNumberOfPointsPerScan * sizeof(float32));

        // Read x-coordinate
        m_lidarPointsFileStream.read((char*)(m_scanCaptured.cc.x), p_maxNumberOfPointsPerScan * sizeof(float32));

        // Read y-coordinate
        m_lidarPointsFileStream.read((char*)(m_scanCaptured.cc.y), p_maxNumberOfPointsPerScan * sizeof(float32));

        // Read z-coordinate
        m_lidarPointsFileStream.read((char*)(m_scanCaptured.cc.z), p_maxNumberOfPointsPerScan * sizeof(float32));

        // Set is captured flag to true
        m_isCaptured = true;
    }
    else
    {
        // If there are no scans ...

        // Print message
        cout << "No more scans" << endl;

        // Set is captured flag to false
        m_isCaptured = true;
    }

    // Return if there was an error
    return !m_isCaptured;

    return false;
}

bool Lux::captureScanOnline()
{
    return false;
}

bool Lux::captureScanSimulation()
{
    // Function error
    bool error = false;
    // Waiting time to achive the scan rate
    int64 waitTime = 0LL;

    // Start timer
    m_timer.start();

    // Capture scan offline
    error = captureScanOffline();

    // Stop timer
    m_timer.stop();

    // Measure the waiting time
    waitTime = m_scanRate - m_timer.elapsed();

    // If capture was to fast
    if (waitTime > 0LL)
    {
        // Wait a time to achive the scan rate
        this_thread::sleep_for(milliseconds(waitTime));
    }

    // Return error status
    return error;
}

void Lux::saveScan()
{
    // Copy the stereo images
    m_scanSaved = m_scanCaptured;

    // Set flag indicating stereo is saved
    m_isSaved = true;
}

uint32 Lux::getScanNumber()
{
    return m_scanNumber;
}

const Scan& Lux::getScanCaptured()
{
    return m_scanCaptured;
}

const Scan& Lux::getScanSaved()
{
    return m_scanSaved;
}

bool Lux::getIsCaptured()
{
    return m_isCaptured;
}

bool Lux::getIsSaved()
{
    return m_isSaved;
}

// Private functions definition
// --------------------------------------------------------------------------------------------------------------------

bool Lux::openFile()
{
    // Open file
    m_lidarPointsFileStream.open(m_fileScans, ifstream::binary);
    if (!m_lidarPointsFileStream.is_open())
    {
        cout << "Lidar points file could not be opened." << endl;
        return true;
    }

    // Read the number of scans
    m_lidarPointsFileStream.read((char*)(&m_numScansFile), sizeof(uint32));

    return false;
}

void Lux::closeFile()
{
    // Close lidar file
    m_lidarPointsFileStream.close();
}

bool Lux::getScanPoints()
{

}

The question is, what the Lux object has to get this error. With other objects I haven't this error.

C++ function "Lux::Lux(const Lux &)" (declared implicitly) cannot be referenced -- it is a deleted function

Thanks in advance.

Answer 1

I found the solution using std::ref() when passing the object:

m_monitorLidar.captureData<Lux>(std::ref(m_lidar), &Lux::captureScanOffline);