C++ pass function with arguments as template

Question

i got a Problem with a template I created a generic class whcih stores global available Information. This class holds a private mutex to manage the access to the global info.

template<typename Mutex_Type_T, typename Struct_Type_T>
class CGlobal_Struct
{
public:
/**
         * Exports data from this class to target
         * @param target the actual target
         * @param mutex_timeout Mutex wait time
         * @return true in case of success
         */
        bool Export(Struct_Type_T& target, const uint32_t mutex_timeout = 100);
        /**
         * Imports data to this class
         * @param source The data to store in this class
         * @param mutex_timeout Wait Time for Mutex
         * @return true in case of success
         */
        bool Import(const Struct_Type_T& source, const uint32_t mutex_timeout = 100);
             /**
     * 1) Loads Data to Buffer
             * 2) performs user defined Operation by calling func_T(data, args)
             * 3) stores back the data
     * @param User defined function
     * @param values class data to modify
             *  @param mutex_timeout Mutex wait time
     * @return true in case of success
     */
            template<typename func_T, typename func_arg_t>
        bool Replace(func_T(Struct_Type_T& values, const func_arg_t args), const func_arg_t func_args,const uint32_t mutex_timeout = 100);

private:
mutex _mutex;
}

This implementation Looks like this

template<typename Mutex_Type_T, typename Struct_Type_T>
template<typename func_T, typename func_arg_t>
bool CGlobal_Struct<Mutex_Type_T, Struct_Type_T>::Replace(func_T(Struct_Type_T& values, const func_arg_t args),const func_arg_t func_args, const uint32_t mutex_timeout)
    {
        CLock_Guard lock(mutex);

        //Lock access
        if(false == lock.Lock(mutex_timeout))
        {
                //Locking failed
            return false;
        }
        //Replace Data
        func_T(data, func_args);

        //Mutex is released automatically when we leave this function
        return true;
    }

Now first Question: is this template implementation correct?

Second: How would i call this replacement function from outside this class? Could you give me some help please?

Answer 1

Now first Question: is this template implementation correct?

Does it compile when you try calling it?

Second: How would i call this replacement function from outside this class?

The template arguments are deduced from a function pointer. Where func_T is the return type. I would advice against it and recommend a simpler template parameter:

template<typename Struct_Type_T>
struct CGlobal_Struct
{
    template<typename func_T, typename func_arg_t>
    bool Replace(func_T function, const func_arg_t func_args,const uint32_t mutex_timeout = 100) {
        // function(struct_type_value, func_args);
    }
};

Both version are valid and are called like this:

struct A {};

void func(A&, int) {}

int main() {
    CGlobal_Struct<A> glob;
    glob.Replace(func, 1);
}

The version I recommend can also support lambdas:

glob.Replace([](A&, int){ /* code */ }, 1);

---

Reading your implementation, it won't work with your current version:

//Replace Data
func_T(data, func_args);

The problem it that func_T is the type of the return type of the function sent as parameter. It is the same as this:

void(data, func_args);

Or more evil:

struct evil { evil(A&, int){} };

// ...

evil(data, func_args);

This will call the constructor of evil and never call a function.

It you look closely, your parameter has no name:

 bool Replace(
     func_T(Struct_Type_T&, const func_arg_t), 
 /* other params */ );

To give it a name, the sytax would be:

 bool Replace(
     func_T(*function)(Struct_Type_T&, const func_arg_t), 
 /* other params */ );

Then call function(...)