class test{
class test {
public:
	float *materialProperty1;
	float *materialProperty2;
	float *materialProperty3;
	
	void (*functionToCall)();
	
	void setFunction( void (*func)() )
	{
		functionToCall = func;
	}
};

#include <iostream>


// Optionally, FunctionA
// could have some internal data that
// helps compute the results of a function call.
// For example, a table lookup functor may store
// a table.
struct FunctionA {
    FunctionA() {}

    // this one will take an int
    void call( int n ) {
        // example
        std::cout << n * n << std::endl;
    }
};

struct FunctionB {
    FunctionB() {}
    
    // this one will take 2 floats
    void call( float a, float b ) {
        std::cout << a * b << std::endl;
    }
};

template <typename FunctionType>
class Test {
    private:
        // mutable because the function might want to
        // modify its internal state when called.
        mutable FunctionType fun_;
    public:
        void setFunction( const FunctionType &function ) {
            fun_ = function;
        }
        
        FunctionType &action() { return fun_; }
};

int main() {
    Test<FunctionA> testa;
    testa.setFunction( FunctionA() );
    testa.action().call( 3 );
    
    Test<FunctionB> testb;
    testb.setFunction( FunctionB() );
    testb.action().call( 4.2, 3.6 );
}

Test<FunctionB> tester( tester ); // Where tester is Test<FunctionA>