Could anyone tell me why i get a compiling error in the "setFlyBehaviour" and "setQuackBehaviour" of the Duck class? (error : "term does not evaluate to a function taking 1 arguments")

this is an example of a strategy pattern from Head First Design Patterns (which is in Java that i translated here in C++). I introduced a Wrapper pattern in order to manage memory. (the wrapper class i'm using is from Mark Joshi, Option Pricing and Design Patterns)

Thanks!!!!!

```
#include <iostream> 
#include <algorithm>    
#include <math.h>   
#include <string>   
#include <map>  
#include <exception>    
#include <vector>

using namespace std;

template< class T>
class Wrapper
{
//Taken From Mark Joshi, Designs patterns and derivatives pricing 
public:

    Wrapper()
    { DataPtr =0;}

    Wrapper(const T& inner)
    {
        DataPtr = inner.clone();
    }
    Wrapper(const Wrapper<T>& original)
    {
        if (original.DataPtr !=0)
            DataPtr = original.DataPtr->clone();
        else
            DataPtr=0;
    }
    ~Wrapper()
    {
        if (DataPtr !=0)
            delete DataPtr;
    }

    Wrapper& operator=(const Wrapper<T>& original)
    {
        if (this != &original)
        {
            if (DataPtr!=0)
                delete DataPtr;

            DataPtr = (original.DataPtr !=0) ? original.DataPtr->clone() : 0;
        }

        return *this;
    }

    T& operator*()
    {
        return *DataPtr; 
    }

    const T& operator*() const
    {
        return *DataPtr; 
    }

    const T* const operator->() const
    {
        return DataPtr;
    }

    T* operator->()
    {
        return DataPtr;
    }
private:
    T* DataPtr;
};

/*****************************************************/
/*****************      Interfaces    ****************/
/*****************************************************/
class FlyBehaviour
{
    private:
    public:
        virtual void fly() const = 0;
        virtual FlyBehaviour* clone() const = 0;
};

class QuackBehaviour
{
    private:
    public:
        virtual void quack() const = 0;
        virtual QuackBehaviour* clone() const = 0;
};

/*****************************************************/
/*****************      Implementations    ***********/
/*****************************************************/

// -- FlyBehaviour

class FlyWithWings : public FlyBehaviour
{
    public:
        virtual void fly() const{
            cout << "flying with wings" << endl;
        }
        virtual FlyBehaviour* clone() const {
            return new FlyWithWings;
        }
};

class FlyNoWay : public FlyBehaviour
{
    public:
        virtual void fly() const{
            cout << "flying no way" << endl;
        }
        virtual FlyBehaviour* clone() const {
            return new FlyNoWay;
        }
};

// -- QuackBehaviour

class Quack : public QuackBehaviour
{
    public:
        virtual void quack() const{
            cout << "Quacking here!" << endl;
        }
        virtual QuackBehaviour* clone() const{
            return new Quack;
        }
};

class Squeak : public QuackBehaviour
{
    public:
        virtual void quack() const{
            cout << "Squeaking here!" << endl;
        }
        virtual QuackBehaviour* clone() const{
            return new Squeak;
        }
};

class Duck
{
    private:
        Wrapper<FlyBehaviour>   flyBehaviour;
        Wrapper<QuackBehaviour> quackBehaviour;

    public:
        void performQuack() const{
            quackBehaviour->quack();
        }
        void performFly() const{
            flyBehaviour->fly();
        }

        void setFlyBehaviour(const FlyBehaviour& mfly){
            flyBehaviour(mfly);
        }
        void setQuackBehaviour(const FlyBehaviour& mquack){
            quackBehaviour(mquack);
        }

        virtual void display() const{
        }
};

class MallardDuck : public Duck
{
    public:
        virtual void display() const{
            cout << "It looks like a Mallar" << endl;
        }
};

class RedheadDuck : public Duck
{
    public:
        virtual void display() const{
            cout << "It looks like a Redhead" << endl;
        }
};

int main()
{

}

```