Question

假设我有两个类，一个是Foo类，它与用户接口，另一个是Bar类，它实际上可以处理收到的任何输入。 Foo中有一个Bar类型的对象，因此当Foo从用户接收输入时，它可以调用Bar类的方法，将它接收的任何数据传递给“bar :: onEvent（）”函数进行处理。

从那里，Bar方法onEvent（）根据传递的数据调用一堆其他方法。在某些情况下，这些方法可能需要从Foo类调用接口方法，如输出或退出类型函数。

基本上，Foo获取用户输入，将数据传递给Bar，Bar处理该输入，Bar将数据发送回（如果适用）输出。 Foo处理从/向用户接收和发送数据，而Bar处理数据的实际处理。

所以Foo一直在检查输入，当它被接收时，它从Foo传递到Bar进行处理。在某些情况下，Bar可能需要将新数据发送回Foo以进行输出。

这是我需要做的一个愚蠢的版本。

class Foo
{
public:
    Bar bar;
    void genericFunctionSimulatingInput(char* data)
    {
        //when input is received, call bar class to handle the logic
        while(data == someKindOfInput)
        {
            bar::onEvent(data);
        }
    }
    void spitOut(char* data);
};

class Bar
{
    void onEvent(char* data)
    {
        //do something with data
        //here the modified data needs to be sent back to the user(could be a mathematical operation  
        //or something.  But what I really need to call is "bu::spitOut(data);", not 
        Foo::spitOut(data);
    }
};

int main()
{
    //create the Foo object that I'll be using throughout
    Foo bu;
    //call the main loop function that will act as the heart of the code
    bu.genericFunctionSimulatingInput("fdklafjdasl");
    return 0;
}

我需要Bar从我在main函数中创建的现有Foo对象调用函数，我称之为bu，但我不知道如何将bu对象放入bar对象范围。

我只需要bu对象中的bar对象就能知道它所在的bu对象。

我该怎么做呢？我是否必须以某种方式将bu的引用传入bar.onEvent（）;方法？然后是这个初始方法调用的所有后续方法？如果是这样，我该如何做呢？

如果我在main函数中创建它们，我理解该怎么做。只是通过＆amp; bu，但是从内部开始？我不清楚我是怎么做的。

我知道这是一个非常抽象的例子，但我希望我已经足够解释了你的想象力可以做到的其余部分。如果不是，我会尝试更好地解释它。

我只需要Bu's Bar类就可以访问bu的功能。

Answer 1

也许是这样的：

class Foo;

class Bar
{
public:
    Bar(Foo &foo)
        : m_foo(foo)
        { }

    void onEvent();

private:
    Foo &m_foo;
};

class Foo
{
public:
    Foo()
        : m_bar(*this)
        { }


    void onEvent()
        {
            m_bar.onEvent();
        }

    void onEventDone()
        {
        }

private:
    Bar m_bar;
};

Bar中的Foo调用函数中的函数必须在Foo被正确定义后定义。所以它们不能在Bar中内联。

void Bar::onEvent();
{
    // Do stuff
    m_foo.onEventDone();
}

如果你希望Bar of Foo中的方法是私有的，那么让它们成为彼此的朋友：

class Bar
{
    friend class Foo;
    // ...

和

class Foo
{
    friend class Bar;
    // ...

Answer 2

而不是

class Bar
{
public:
    void onEvent(char* data)
    {
        //do something with data
        //here the modified data needs to be sent back to the user(could be a mathematical operation  
        //or something.  But what I really need to call is "bu::spitOut(data);", not 
        Foo::spitOut(data);
    }
};

写

class Bar
{
 public:
    void onEvent(Foo& foo, char* data)
    {
        //do something with data
        //here the modified data needs to be sent back to the user(could be a mathematical operation  
        //or something.  But what I really need to call is "bu::spitOut(data);", not 
        foo.spitOut(data);
    }
};

而不是

 bar::onEvent(data);

写

  bar.onEvent( *this, data );

总是尝试尽可能地分离类。

从另一个类调用类函数？

2 个答案: