Changes between Version 2 and Version 3 of code/doc/Functor

Timestamp:

Sep 30, 2008, 12:56:51 AM (16 years ago)

Author:

landauf

Comment:

—

code/doc/Functor

@@ -142 +142 @@
 Note: If you add a constant object, you can only call the Functor if the assigned function-pointer leads to a constant function too.
 
-== Template and ambiguity ==
-
-== Examples ==
+== Template ==
+Sometimes you might have to create know the template arguments of a Functor. This may be the case if the name of a function is ambiguous and createFunctor can't decide which function to use.
+
+This is how the template arguments are arranged:
+{{{
+template <classname, returntype, paramtype1, ..., paramtype5>
+}}}
+
+If a function has no returnvalue, the returntype argument is discarded:
+{{{
+template <classname, paramtype1, ..., paramtype5>
+}}}
+
+If a function is static, the classname argument is discarded:
+{{{
+template <returntype, paramtype1, ..., paramtype5>
+}}}
+
+If a function has less than 5 parameters, the surplus parameters are discarded:
+{{{
+example: 3 parameters:
+template <paramtype1, paramtype2, paramtype3>
+}}}
+
+Examples:
+{{{
+int function(float p1, float p2, float p3);
+=> <int, float, float, float>
+
+void function(const std::string& p);
+=> <const std::string&>
+
+void Class::function(int p);
+=> <Class, int>
+
+bool Class::function(int p);
+=> <Class, bool, int>
+}}}
+
+== Ambiguity ==
+Sometimes two functions have the same name but different parameters. This is called overloading. Usually the compiler knows what you want because your arguments define the function. But if you just pass the function-pointer to createFunctor, the compiler has no idea which function to chose.
+
+Example:
+{{{
+class SomeClass
+{
+    void someFunction(const Vector3& position);
+    void someFunction(float x, float y, float z);
+};
+
+Functor* functor = createFunctor(&SomeClass::someFunction); // error!
+}}}
+
+This problem can be solved by specifying the template arguments by yourself. Read the chapter above to learn about how to arrange the template arguments.
+
+This is how it works:
+{{{
+class SomeClass
+{
+    void someFunction(const Vector3& position);
+    void someFunction(float x, float y, float z);
+};
+
+Functor* functor1 = createFunctor<SomeClass, const Vector3&>(&SomeClass::someFunction);
+Functor* functor2 = createFunctor<SomeClass, float, float, float>(&SomeClass::someFunction);
+}}}