将类变量传递给API函数

我想跟踪传递到API函数中的全局变量。我发现可以使用一个类来完成：

template <class T>
class MonitoredVariable
{
public:
    MonitoredVariable() {}
    MonitoredVariable(const T& value) : m_value(value) {}

    //T operator T() const { return m_value; }

    const MonitoredVariable& operator = (const T& value)
    {
        PlugIn::gResultOut << "value changed " << std::endl;
        m_value = value;
        return *this;
    }


private:
    T m_value;
};

下面是一个错误：

ImagePtr Im;
bool is_done;
MonitoredVariable<double*> fraction_done;
bool frameready = Im->APIFunction(2.1, is_done, fraction_done);

ERROR:
    error C2664: cannot convert argument 3 from 'MonitoredVariable<double *>' to 'double *'

imageptrim；
一切都结束了；
监测可调分数；
bool frameready=Im->APIFunction（2.1，完成，分数完成）；
错误：
错误C2664:无法将参数3从“MonitoredVariable”转换为“double*”

我在这里要换什么？

---

谢谢

我不确定这是否是您想要的：

#include <iostream>

using namespace std;

template <class T>
class MonitoredVariable
{
public:
    MonitoredVariable() {}
    MonitoredVariable(const T& value) : m_value(value) {}

    //T operator T() const { return m_value; }

    const MonitoredVariable& operator = (const T& value)
    {
        //PlugIn::gResultOut << "value changed " << std::endl;
        m_value = value.m_value;
        return *this;
    }

    void printValue() {
        std::cout << m_value;
    }

    T& getValue() {
        return m_value;
    }

private:
    T m_value;
};

bool func(double firstDouble, bool *is_done, double* fraction_done) {
    // do stuff

    *fraction_done = firstDouble + (40.23 * 5);
    *is_done = true;
    return true;
}

int main()
{
    bool is_done = true;
    MonitoredVariable<double> fraction_done;

    func(2.10, &is_done, &fraction_done.getValue());

    fraction_done.printValue();

    return 0;
}

#包括
使用名称空间std；
模板
类监视变量
{
公众：
MonitoredVariable（）{}
监控变量（常量T和值）：m_值（值）{}
//T运算符T（）常量{返回m_值；}
常量监视变量和运算符=（常量T和值）
{
//PlugIn:：gResultOut在下面的例子中，我想实现的可能更有意义。我想将一个类变量输入API函数并实时监控该变量。该值每3毫秒左右从零变为1。但我试图避免使用while循环，并在类内使用重载=运算符跟踪它

#include "stdafx.h"
#include <iostream>
#include <thread>
#include <future>

using namespace std;

template <class T>
class MonitoredVariable
{
public:
    MonitoredVariable() {}
    MonitoredVariable(const T& value) : m_value(value) {}


    void printValue() {
        std::cout << m_value;
    }

    const MonitoredVariable& operator = (const T& value)
    {
        m_value = value.m_value;
        if(m_value> 0.8) std::cout << m_value;  // *THIS NEVER GETS PRINTED!!!*

        return *this;
    }


    T& getValue() {

        return m_value;
    }

private:
    T m_value;
};

bool func(bool *is_done, double* fraction_done) {

    unsigned long c = 1;

    while (*is_done)
    {
        *fraction_done =  (double) 0.01*c;
        this_thread::sleep_for(chrono::milliseconds(10));
        c++;
        if (*fraction_done >= 1) *is_done = false;
    }

    return true;
}

int main()
{

    bool is_done = true; 
    MonitoredVariable<double> *MonitoredVariablePtr = new MonitoredVariable<double>();

    std::future<bool> fu = std::async(std::launch::async,func, &is_done, &MonitoredVariablePtr->getValue()); 


    // IF I UNCOMMENT THIS, IT PRINTS...
     /*
    while(is_done)
    {
    if(MonitoredVariablePtr->getValue() > 0.8)  MonitoredVariablePtr->printValue();
    }
    */

return 0;
}

#包括“stdafx.h”
#包括
#包括
#包括
使用名称空间std；
模板
类监视变量
{
公众：
MonitoredVariable（）{}
监控变量（常量T和值）：m_值（值）{}
void printValue（）{
std:：cout 0.8）std:：cout=1）*是否完成=错误；
}
返回true；
}
int main（）
{
bool is_done=真；
MonitoredVariable*MonitoredVariablePtr=新的MonitoredVariable（）；
std:：future fu=std:：async（std:：launch:：async，func，&is_done，&MonitoredVariablePtr->getValue（））；
//如果我取消对此的注释，它将打印。。。
/*
（完成了吗）
{
如果（MonitoredVariablePtr->getValue（）>0.8）MonitoredVariablePtr->printValue（）；
}
*/
返回0；
}

为什么函数中的（if（m_value>0.8）std：：cout Is use of
*Is_done
不调用拼写错误？如果不是，你应该从a学习语言的基础知识。是的，这是一个拼写错误。分数完成是这里的问题……请在你的帖子中修复它，这样其他人就不会被它分散注意力/混淆了。
#include "stdafx.h"
#include <iostream>
#include <thread>
#include <future>

using namespace std;

template <class T>
class MonitoredVariable
{
public:
    MonitoredVariable() {}
    MonitoredVariable(const T& value) : m_value(value) {}


    void printValue() {
        std::cout << m_value;
    }

    const MonitoredVariable& operator = (const T& value)
    {
        m_value = value.m_value;
        if(m_value> 0.8) std::cout << m_value;  // *THIS NEVER GETS PRINTED!!!*

        return *this;
    }


    T& getValue() {

        return m_value;
    }

private:
    T m_value;
};

bool func(bool *is_done, double* fraction_done) {

    unsigned long c = 1;

    while (*is_done)
    {
        *fraction_done =  (double) 0.01*c;
        this_thread::sleep_for(chrono::milliseconds(10));
        c++;
        if (*fraction_done >= 1) *is_done = false;
    }

    return true;
}

int main()
{

    bool is_done = true; 
    MonitoredVariable<double> *MonitoredVariablePtr = new MonitoredVariable<double>();

    std::future<bool> fu = std::async(std::launch::async,func, &is_done, &MonitoredVariablePtr->getValue()); 


    // IF I UNCOMMENT THIS, IT PRINTS...
     /*
    while(is_done)
    {
    if(MonitoredVariablePtr->getValue() > 0.8)  MonitoredVariablePtr->printValue();
    }
    */

return 0;
}