calling same funtion with different types of argument

Question

I want to call a function which can accept a vector but i want to pass different type of vector to that function.

I have come across a function call like

print<int>(int_vector);
print<string>(string_vector);

here <int> and <string> are mention as what.

One more doubt is if i pass different type of vector also how can i take it in the function call. should i use void * ? then type cast it

Answer 1

Sample of func template

#include <iostream>
#include <vector>

using namespace std;

template<typename T>
void foo(std::vector<T> vec)
{
   // do stuff with vector
}

int main() {
    std::vector<int> iv = {42};
    foo(iv);
    std::vector<string> sv = {"hello"};
    foo(sv);
    return 0;
}

There is an alternative if you know the exact types:

void foo(std::vector<int> v)
{}

void foo(std::vector<string> v)
{}

This is plain function overloading.

Answer 2

The code is using template programming to make a generic function:

template <typename T>
void foo(T item){
    // do something to item of type T
}
void foo(int str); // Declare a certain type of template

Later you can use the function:

int x = 1;
foo<int>(x);

But in this case, because e.g. printf uses different formatting for different types, it might be wise to instead overload the functions. Overloading is the practise of naming functions similarly, but giving different arguments:

void foo(std::vector<int> v);
void foo(std::vector<string> v);

Answer 3

What you want to use here is a templated function. Simples example relevant to your question would be:

// This line says that the function accepts one generic type
// which you will refer to as T
template <typename T>
// vector<T> means that the referenced type T will be of the type the vector, 
// you call this function with, is templated with
void print(const std::vector<T>& data) {
    // Here calling the operator[] will return the generic type T
    const T& element = data[0];
    for (unsigned i = 0; i < data.size(); ++i)
        std::cout << data[i] << std::endl;
}

This function would be used like this:

std::vector<int> vec = { 1, 2, 3 };
print(vec); 
// Note that you don't need to write the template type here
// because it is deduced from the type of vector

And the output will be:

1
2
3

Answer 4

This concept is known as generic programming. In C++, you use templates to achieve this, and specifically a function template. If you want different types of lists with different types to be auto-deduced, or have a specific need for advanced templates, you can also use a template-template.

An example:

#include <iostream>
#include <vector>
#include <list>

template < template < class, class > class V, class T, class A >
void erase_value(V<T, A>& v, const T& t)
{
    typename V<T,A>::iterator s = v.begin();
    while (s != v.end()) {
        if ((*s) == t) { v.erase(s); break; }
        ++s;
    }
}

template < typename T >
void print_all(T begin, T end)
{
    for (; begin != end; ++begin) {
        std::cout << *begin << " ";
    }
    std::cout << std::endl;
}

template < typename T >
void print_all(const T& array)
{
    for (auto i : array) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
}

int main(int argc, char** argv)
{

    std::vector<std::string> strings {"123","321","ABC"};
    std::list<int> ints {123,321,5332};
    print_all(strings);
    print_all(ints);
    erase_value(strings, std::string("123"));
    erase_value(ints, 123);
    print_all(strings.begin(), strings.end());
    print_all(ints.begin(), ints.end());
    return 0;
}

Hope that can help.

Answer 5

I believe you're looking for ostream_iterator:

template <typename T>
void print(vector<T> arg){
    copy(cbegin(arg), cend(arg), ostream_iterator<T>(cout, " "));
}