Creating Function Templates

Hi...I've posted here before and received some help on a program, and now I'm here to get some help on another problem: I'm having trouble understanding the mechanics of function templates and function overloading. I've tried several different ways to write this out. This time I have added my code files to make commenting easier. The point to this program is that it is my first experience with using a randomizer, and it's supposed to create certain 'wanderers' who randomly take a step on a square of a certain size. When a wanderer falls off, he is destructed. I am to overload a function to accept and display two parameters, the first one a string and the second several different data types. I think that once I have the template concept down, I can figure out the overloading from there. Anyway, without further preamble, here are my files, and thank you in advance.

Basics for overloaded:

Code:

---

void foo(int, int);
void foo(string, int);

---

The two functions have the same name, but take different arguments. The compiler will call the right function depending on the arguments you pass.

Basics for templates:

Code:

---

template<typename T>
class myclass
{
// Implenetation
T MyData;
};

template<typename T>
void myfunc(T foo);

---

T is the data type which is determined when you create the class (or call the function):

Code:

---

int main()
{
myclass<int> myint;
myclass<string> mystring;
myfunc(5);
myfunc("test");
}

---

Be sure to read the tutorials on the site.

Thank you for the quick reply. I am off to class now, but I will come back to you in about 3 hours to be sure I understand. Thanks also for the reminder to check the tutorials.

Working on the overloading, the identifiers I am using are not found. My function prototype is declared within the class, with empty parameters:

Code:

---

void showStuff();

---

then my definitions indicate parameters to be expected, with no class affiliation:

Code:

---

void CWanderer::showStuff(string s, int x)
{       
        cout << s << x << endl;
}

void CWanderer::showStuff(string t, bool y)
{
        cout << t << y << endl;
}

---

when calling this, I wrote:

Code:

---

        joe.showStuff("Text ", wandererCount());
        joe.showStuff("More text ", onSquare());

---

So, basically, keeping everything within the class gives me the error messages that the overloaded function is not found in CWanderer and that wandererCount() and onSquare are undeclared identifiers. Making this a non-member function returns the error that wandererCount() and onSquare are undeclared identifiers. Is the problem in the way I am defining/calling the function or in the way that I am declaring the variables?

Declarations should look exactly like your definitions, even if they're overloaded. Declarations are used to tell the compiler that the functions exists! No shortcuts here! Especially with classes, they're part of the blueprint from which the compiler creates an object.
Redeclare your declarations to match your definitions.

Code:

---

        joe.showStuff("Text ", joe.wandererCount());
        joe.showStuff("More text ", joe.onSquare());

---

Quote:

---

My function prototype is declared within the class, with empty parameters:

---

The problem is here. You have a member function named showStuff that takes no arguments. Where in the world do these two other member functions named showStuff come from? Declare them in the class as well.

Incidentally, it is probably a bad idea to make two function differ only in that one takes an int where the other takes a bool. Certain type conversions could make things ambiguous, if I remember correctly.

Quote:

---

Originally Posted by laserlight

Incidentally, it is probably a bad idea to make two function differ only in that one takes an int where the other takes a bool. Certain type conversions could make things ambiguous, if I remember correctly.

---

I have a feeling it will do so too. Bool and ints are interchangable, so passing an integer can easily be turned into a bool (!= 0 == true, 0 == false AFAIK).

I think I understand. I was thinking that a convenient aspect of overloaded functions means that it is declared ONCE, with an empty parameter list

Code:

---

void showStuff()

---

and that the definition file will tell the compiler what all goes in there.
Replacing that with

Code:

---

void showStuff(string, int);
void showStuff(string, bool);

---

gave me correct output.
Thank you. Now I will work on templates.

I agree with laserlight on the convenience and practicality, but the purpose of this particular program is to turn in something indicating that I understand how overloaded functions work. Any data type, as long as I'm returning more than one, would be acceptable.

I also disagree with your declarations. Some compilers' (like VC) IntelliSense parses the information from your declarations into showing you what the function you try to call looks like. Besides that, it also makes your declarations easier to read than just some function name. By naming the variables, the one who reads your code can deduce what to pass to the function.
So name your declarations with names on your variables, and not just type. Make them look exactly like your definitions.
Btw,
to make the functions more distinguishable, you could make functions such as:

Code:

---

void showStuff(string s, int i);
void showStuff(string s, double d);

---

The compiler determines which function to call depending on the parameters you pass to the function, so a bool and int may not be the best, since a bool IS basically an int.

I agree with that.
My declaration now looks like this:

Code:

---

void showStuff(string s, int i);
void showStuff(string t, double d);

---

and my definition:

Code:

---

void CWanderer::showStuff(string s, int i)
{       

        cout << s << i << endl;
}

void CWanderer::showStuff(string t, double d)
{
        cout << t << d << endl;
}

---

finally, I call it the same as before, only passing a literal double value directly into the second parameter.

I think I almost learn more directly from these forums than I do in class.

To avoid unnecessary copying, the std::string objects should be passed by (const) reference. Also, since those member functions do not modify the observable state of the CWanderer object, they should be declared as const:

Code:

---

void showStuff(const std::string& s, int i) const;
void showStuff(const std::string& t, double d) const;

---

Code:

---

void CWanderer::showStuff(const string& s, int i) const
{
        cout << s << i << endl;
}

void CWanderer::showStuff(const string& t, double d) const
{
        cout << t << d << endl;
}

---

Of course, since they do not actually involve CWanderer (they operately entirely based on the arguments passed), they should be non-member functions, by right.

Another thing: using declarations and directives should almost never be in header files. As such, remove the "using namespace std;" directive from CWanderer.h and then fully qualify names from the std namespace, like how I have edited my example in this post.

This may not be required in this little example, but in general, do consider naming your variables appropriately. It makes it easier to read and you don't go "huh???" later if you've forgotten what the variables are for.
You might also place a comment to what they're for.

What is a directive?

NVM - brain fart.

Quote:

---

What is a directive?

---

A using directive is basically a statement of the form:
using namespace namespace_name;

It makes all names in namespace_name (e.g., std) accessible.

I am working on a template to accomplish the same thing as the overloaded function - namely accept and display two parameters. This time I will write this as a non-member function.

I have this in my header file (I haven't removed the directive yet, until I know how to fully qualify the template)

Code:

---

template<class DTYPE1 text, class DTYPE2 someVal>

---

for definition

Code:

---

DTYPE1, DTYPE2 showStuff(DTYPE1 text, DTYPE2 someVal)
{
    cout << text << " " << someVal << endl;
}

---

to call:

Code:

---

showStuff(string "Text ", int 7);
showStuff(string "More text ", double 36.65);

---

The C++ book I am working from has next to nothing to say about more than one data type. I am sure that there needs to be a template argument list but how?

That is incorrect.
A function can only return one type.
A template functions look like this:

Code:

---

template<typename NameOfTypeHere1, typename NameOfTypeHere2> ReturnTypeHere foo(NameOfTypeHere1 myfirstarg, NameOfTypeHere2 myarg2);

---

Ha, so there are STILL no shortcuts in the header file? A template only shortens the definitions?

Huh? What's that supposed to mean?
A template is used to allow the compiler to substitute the type and generate code instead of you making lots of overloaded functions.

What I was thinking there for a minute was that my header file would contain the template prefix, followed by, well basically by more declarations that look like overloaded functions, then the definition would only contain a template definition. I'll try to work this out again and come back to you.

Every function, declaration or definition must have the exact same structure, and thus the "template" part must also appear before every declaration as well as definition.
Here's a sample:

Code:

---

// Declaration:
template<typename T> class CMemoryManagerBase abstract
{
        // ...
        void SetNewPointer(T* pNew) throw(...);
        // ...
}

// Definition:
#define MMB(return_type) template<typename T> return_type CMemoryManagerBase<T>
MMB(void)::SetNewPointer(T* pNew) throw(...)
{
        // ...
}

---

This is a sample from my own code - a template class. Adding the template to the class basically adds the "template" part before all the functions.
See the definition. I also put the template part before there and the function looks exactly like the declaration (although I use a MACRO to shorten the name).
That's how you use templates.
You can have more than one template, as I showed. The principle is the same.

Thank you for your patience with me...

so far I have this much done:

Code:

---

template<class T1, class T2>
void showStuff(T1 text, T2 someVal)

---

in my header file, and

Code:

---

template<class T1, class T2>
void showStuff(T1 text, T2 someVal
{
  cout << text << " " << someVal << endl;
}

---

Then call these like so:

Code:

---

        showStuff("Text here ", 36.52);
        showStuff("More text ", 7);

---

and receive an external error message.

Don't forget ; on your declarations.
Templates should also reside in headers. There is an excellent tutorial on why, but unfortunately, I don't have a link to it.

Okay, I'm heading out to class again...but I will come back to you in about 2 hours. I placed the ';' after the 'void showStuff(T1 text, T2 someVal);' but still get an external error. Do you mean that my header file should contain something like

Code:

---

template<class T1, class T2>
void showAbs(T1 text, T2 someVal)
{
        cout << text << " " << someVal << endl;
}

---

I will look for a tutorial this afternoon.

Place both declaration and definition in the header, or just skip the declaration and only do your definition (works fine for templates).

I understand now! Thank you so much for all your time and patience.