Surprising Code

Using Algorithm Library and Functional

2012-12-05T13:06:00.000+01:00

Just an example to show the utility of the library algorithm.

#include <iostream>
#include <algorithm>
#include <vector>
#include <functional>

using namespace std;

int op_increase (int i) { return ++i; }
int op_sum (int i, int j) { return i+j; }

void inc(int& val){
    static int i = 0;
    val += i;
    i += 10;
}

ostream& operator<<(ostream& out, const vector<int>& a){
    for (int i = 0; i < a.size(); i++)
        out << a[i] << ", ";
    
    out << endl;
    return out;
}
int main () {
  vector<int> first(5);
  vector<int> second;
  vector<int> result;
  
  second.resize(first.size());    
  result.resize(first.size());

  // set some values:
  for_each(first.begin(), first.end(), inc); 
  for_each(second.begin(), second.end(), inc);
  
  cout << first << second << result;

  transform (first.begin(), first.end(), result.begin(), op_increase);
  cout << result;
  
  transform (first.begin(), first.end(), second.begin(), result.begin(), op_sum);
  cout << result;

  vector<int> lenghts;
  vector <string*> numbers;

  // populate vector of pointers:
  numbers.push_back ( new string ("one") );
  numbers.push_back ( new string ("two") );
  numbers.push_back ( new string ("three") );
  numbers.push_back ( new string ("four") );
  numbers.push_back ( new string ("five") );

  lenghts.resize(numbers.size() );

  transform (numbers.begin(), numbers.end(), lenghts.begin(), mem_fun(&string::length) );
  cout << lenghts;

  system("pause");
  return 0;
}

Also, it is possible to use mem_fun_ref instead of mem_fun without the need of use a vector of pointers to strings and just use strings instead of,

Thus, in conclusion, it's very interesting to know how to use this libraries because allow you to work more efficiently and do the same work in less time.

Pointers, References and Local Variables

2012-12-02T15:48:00.000+01:00

Well, I bring here an example when you should figure out how constructors, pointers and reference works.

Thus, here it goes:

Note: Take a fast look to A class and start reading in main function.

#include <iostream>
#include <algorithm>
#include <stdlib.h>

using namespace std;

class A{
private:
    int a;
public:
    A() : a(-1){
        cout << "Default constructor" << endl;
    }
    A(int val) : a(val){
        cout << "Calling contructor by int" << endl;
    }
    //************************************
    A(A* val){
        cout << "Calling contructor by A_pointer" << endl;
        a = val->get();
    }
    A(A& val){
        cout << "Calling contructor by A_reference" << endl;
        a = val.get();
    }

    // This can't be done because when the constructor is called
    // the parameter of the function calls itself, I mean, val is being
    // a local variable
    /*A(A val){
        a = val.get();
    }*/

    int get(){ return a; }
    int get() const { cout << "get 'a' by a const variable\n"; return a; }
    int& getRef(){ return a; }
    //int& getRef() const{ return a; } This can't be done
};


void byPointers(A *a, A *b){
    *a = b->get()*2; //(-1 * 2 = -2)
    // this can be done because a points to a instanced class A
    // in case that would point to null this would be a segmentacion fault
    // on runtime

    // Beside, this calls the constructor by value
}

void byReference(A& a, const A& b){
    a.getRef() = 1000; // we change a_int value, because a is a reference and a.getRef return the atribut inside the class by reference
                       // if the int atribut would've been public that would be equivalent to a.a = 1000;

    //so, because in this call, a and b are A_value, if we change a, also are changing b, let's look:
    cout << b.get() << endl;

    //However, we can't change the b value, because is constant although points to the same variable
}
void byReference2(A& a){
    a.getRef() = 1000000;
}

void byCopy(A a){
    cout << "a: " << a.get() << endl;

    a = A(25); 
    cout << "a: " << a.get() << endl; // now it's 25

    a.getRef() = 26;
    cout << "a: " << a.get() << endl; // now it's 26 but still being
    // a local variable
}

int main(){
    cout << "First example:" << endl;
    A A_value; // this calls default constructor
    
    cout << A_value.get() << endl;
    A* A_pointer; // this doesn't because is a pointer
    A_pointer = &A_value; // this doesn't call any A constructor
    *A_pointer = A_value; // this is equivialent to the previous line
    cout << A_pointer->get() << ", " << (*A_pointer).get() << endl << endl; // point to A_value (two ways to access it)
    //**************************************************************************************

    cout << "Second example:" << endl;
    byPointers(&A_value,&A_value); // this doesn't call any constructor
    // just points to the references of A_value, so inside the function 
    // if we change A *a, A *b pointers we'll change A_value
    cout << endl;

    // This is a bit obfuscated, so peruse
    byCopy(A_value); // byCopy expect to creat (A a) as a local variable
                     // so calls A_reference, or method to copy a class
                     // however, the construtor is by reference, a still be
                     // a local variable
    cout << A_value.get() << endl << endl;// Thus, we haven't changed any attribut of A_value
    //**************************************************************************************
    
    cout << "Third example:" << endl;
    byReference(A_value, A_value); // pass by reference doesn't call any constructor
                                   // because a and b are exactly A_value
    // So, after the call, A_value have changed:
    cout << A_value.get() << endl;

    // even, we can do the same with the pointer
    byReference2(*A_pointer);
    // and because A_pointer points to A_value, this will also change the value
    cout << A_value.get() << endl; 

    system("pause");
    return 0;
}

Example of two and three dimensional pointers

2012-11-30T14:32:00.000+01:00

Welcome everyone,
I did a little problem to practice with pointers to other pointers. In this case, I did a matrix and pass it by a function than expect the reference of it.

The example compute the multiplication of two matrices.

Note: This post was inspired answering that post: http://www.cplusplus.com/forum/general/86553/

Enjoy it:

#include <iostream>
#include <algorithm>
#include <stdlib.h>

using namespace std;

void fill(int& value){
    static int val = 0;
    val++;

    value = val;
}

void zero(int& value){
    value = 0;
}


void mult(int* **A,int* **B,int* **result, const int SIZE) {
    for (int i = 0; i < SIZE; i++)
        for (int j = 0; j < SIZE; j++)
            for (int k = 0; k < SIZE; k++)
                (*result)[i][j] += B[0][i][k] * (*A)[k][j];
}

int main(){
    int *vector;
    const int SIZE = 3;

    //reserve memory:
    vector = (int*) malloc(sizeof(int) * SIZE);
    for_each(vector,vector + SIZE,fill); //fill

    //print
    for(int i = 0 ; i < SIZE ; i++)
        cout << vector[i] << ", ";
    cout << endl << endl << endl;

    //reserve memory for a pair of matrices:
    int**matrix;
    matrix = (int**) malloc(sizeof(int*) * SIZE );
    for(int i = 0 ; i < SIZE ; i++ )
        matrix[i] = (int*) malloc(sizeof(int) * SIZE);

    int**result;
    result = (int**) malloc(sizeof(int*) * SIZE );
    for(int i = 0 ; i < SIZE ; i++ )
        result[i] = (int*) malloc(sizeof(int) * SIZE);
    //***************************

    //fill matrix:
    for_each(matrix[0],matrix[0] + SIZE,fill);  for_each(result[0],result[0] + SIZE,zero);  
    for_each(matrix[1],matrix[1] + SIZE,fill);  for_each(result[1],result[1] + SIZE,zero);
    for_each(matrix[2],matrix[2] + SIZE,fill);  for_each(result[2],result[2] + SIZE,zero);

    //print it
    for(int i = 0 ; i < SIZE ; i++){
        for(int j = 0 ; j < SIZE ; j++)
            cout << matrix[i][j] << ", ";
        cout << endl;
    }
    cout << endl << endl << endl;

    mult(&matrix, &matrix, &result, SIZE);
    //print it
    for(int i = 0 ; i < SIZE ; i++){
        for(int j = 0 ; j < SIZE ; j++)
            cout << result[i][j] << ", ";
        cout << endl;
    }
    cout << endl << endl << endl;

    system("pause");

    return 0;
}

Type Traits 2

2012-11-25T00:59:00.000+01:00

Have I ever spoken about decltpe?
Well, I just mentioned.

In a previous post, I spoke about Type Traits. Now, I'm going further and show you some details about decltype; a new feature of C++11.

This is useful because you will spend less time having to write out things the compiler already knows.
C++11 introduces several tools for type inference. Decltype, auto, new return feature, these are some examples.

In this chapter, I'll review references and introduce decltype.
Read carefully and note the types.

#include <iostream>

using namespace std;

int main(){
    int a = 2, *b;
    b = &a;

    int& c = a; //int referenced
    c = 20; //This modifies a


    auto d = c; // that's an int, isn't referenced
    d = -1;

    decltype(c) e = a; // that's a referenced int
    e = -20;

    cout << a << ", " << c << ", " << *b << ", " << d << endl; // all refers to the same number
    //*****************************************************

    int q1 = 0;
    decltype(q1) q2 = 1;
    decltype( (q1) ) q3 = q1;// int&
    q3 = 2;

    cout << q1 << ", " << q2 << ", " << q3 << endl;
    //*****************************************************
    struct MyClass { double x; };
    const MyClass* const f = new MyClass(); // constant pointer pointing to constant value

    decltype( f ) asd = new MyClass(); // const MyClass* const so have to be initialized
    decltype( f->x ) x; // double
    decltype( (f->x) ) y = x; // const double&

    return 0;
}

Notice that decltype( (variable) )  with double parenthesis is referenced.

Now, I want to introduce a new way to declare function. 

The idea:
template <typename Builder>
auto
makeAndProcessObject (const Builder& builder) -> decltype( builder.makeObject() )
{
    auto val = builder.makeObject();
    // do anything
    return val;
}




A short example:
#include <iostream>
#include <utility>

using namespace std;

class A{
public:
    typedef pair<int,int> T;

    static T build(){
        return T(1,2);
    };
    static ostream& printA(ostream& out,const T& val){
        out << "( " << val.first << ", " << val.second << " )" << endl;
        return out;
    };
    // we can override the operator <<
    // inside the class
    //
    // friend ostream& operator<<(ostream& out, const A& val)
    //
    // but we don't want to print an A class, we just are printing an
    // internal type
};

// NEW C++11
auto foo() -> decltype( A::build() ){
    auto a = A::build();
    
    // DO ANITHING

    return a;
}

ostream& operator<<(ostream& out,const A::T& val){
    return A::printA(out, val); // overloading << operator for cout << A::T
}

int main(){
    cout << foo() << endl;
    // If we change A::T class and build constructor, foo() will change automaticaly the return type

    return 0;
}

A-star Search

2012-08-30T19:40:00.001+02:00

Hello Folks,
Today I won't write code but instead of I'll speak about a famous algorithm to find optimal paths.

A* search

It evaluates nodes by combining g(n) and h(n), where g(n) is the cost to reach the current node and h(n) is the heuristic cost from the note to the goal.

So, by combining both we have f(n) that is the estimated cost of the cheapest solution.
This algorithm is both complete and optimal whether satisfies certain heuristic conditions.
In fact, the algorithm is identical to Uniform-Cost-Search, also known by the name Dijkstra, except that uses g(n) + h(n) instead of g(n).

Conditions for optimality

The main condition we require for optimality is that h(n) has to be an admissible heuristic. An admissible heuristic is one that never overestimates the cost to reach the goal.

In other words, g(n) is the minimal accumulated cost from the initial state to the current node and h(n) is heuristic cost from the current node to the goal. Thus, f(n) that is g(n) + h(n) is the cost from the initial state to the goal.
So, admissibility here means that h(n) has to be calculated heuristicly and this means that won't be the real cost.

So, if h(n) is bigger that h*(n), which is the real cost or the perfect heuristic, then f(n) = g(n) + h(n) would be bigger than the shortest path and due to wouldn't be optimal.

An example of an admissible heuristic is the straight-line distance h_SLD. Whether we want to calculate the shortest path between two cities h_SLD will be an excellent heuristic to be used because between two points always the shortest path is a straight-line and don't exist a better solution. Thus, this heuristic will be admissible because would never calculate a further path than the optimal solution.

A*: Additional Properties

A* store in memory all nodes visited so his complexity is exponential both time and space.
Thus, A* is not practical for many large-scale problems. There are, algorithms, that overcome the space problem without sacrificing optimality or completeness, at a small cost in execution time.
For instance, IDA*.

A* is optimal in another sense: no other algorithm expands less nodes than A* with same heuristic function but this doesn't mean that A* is always the fastest.
Another property is that better heuristic functions A* expands less nodes.

0 < h_1 < h_2 < h*

With h_2 will expand less nodes than with h_1.

Example of heuristics

I won't explain any of it but just with the name you will be able to google it.

Manhattan distance in N-puzzle
Euclidean Distance in Routing Finding
Spanning Tree in Travelling Salesman Problem
Shortest Path in Job Shop Scheduling

Algorithm

Illustration of A* search for finding path from a start node to a goal node.

Extracted from wikipedia.

Example:

In order to solve the shortest path in the graph using A* I will use two list, one for the current nodes ( search frontier ) and another for the visited nodes ( in order to check loops ).

Opened

1 2 3 and so on
f(a) = 1.5 + 4 = 5.5 f(b) = 3.5 + 2 = 5.5 f(c) = 6.5 + 2 = 8.5
f(d) = 2 + 4.5 = 6.5 f(d) = 2 + 4.5 = 6.5 f(d) = 2 + 4.5 = 6.5

Closed
1 2 3
f(a) f(a)
f(b)

Random vector

2012-05-19T04:32:00.000+02:00

Last post it was about lambdas but, indeed, I just focused with an utility; random vectors creation. Now, after still being researching I found more intuitive and elegant forms.

Let's see this amazing things:

#include <algorithm>
#include <iostream>
#include <vector>
#include <time.h>

//Start reading inside main!!!!
//first template is the rank of numbers we want
//second, where it starts
template<int N, int Start = 0>
class MyRand{
public:
     int operator()(void){
         return std::rand()%N + Start;
     }
};

int fRand(){
     return std::rand()%10 + 30;
}

int main()
{
      // Create a vector object that contains 10 elements.
      std::vector<int> a(10);

     // randomly initialize using lambda expressions
     srand((unsigned)time(0)); 

     //generating the vector by means of standard random function
     //This is nice but you don't have much control of which rank of numbers
     //will be returned. Indeed, you know, with the macro RAND_MAX
     //and this is a huge number.

     //And that perhaps isn't what we expected. So the solucion is to use
     //a custom function:
     std::generate(a.begin(), a.end(), std::rand );

     //Now, just changing fRand we can get our wished numbers, but
     //even that is not the best way because you can't use any function
     //that takes some parameter and then you'd need as many function
     //as you need; and that can be tedious. Instead of this, we can use templates
     //which we won't get that problem.
     std::generate(a.begin(), a.end(), fRand );

     //So, here we go:
     //With two templated parameters we can get any random rank of numberes we want.
     //for example, if we want numbers between 10 and 20 that's the example:
     std::generate(a.begin(), a.end(), MyRand<10,10>() );

     //O maybe we want numbers between 14 and 71
     //how many numbers there are between them? 71 - 14 = 57 and we start at 14
     //So:
     std::generate(a.begin(), a.end(), MyRand<57,14>() );


     //like last time, how to write this vector with just code a line
     std::for_each(a.begin(), a.end(), [](int a){ std::cout << a << std::endl; } );
     return 0;
}

Lambdas

2012-05-13T00:01:00.001+02:00

Yes, I'm still alive hehe
Today, I have been working with C++11 and I did some awesome things.

In this post, I won't explain much, just because I'm still inexperienced but I will.

How many times did you print a vector? And how many lines was needed? Yes, of course. You could make a function but so many times you are just debuging and you aren't really interested with it because you are solving anothers problems of mayor importance.

Here, there's an example with one line to do it. Moreover, I randomly initialized the vector with the same idea.

#include <algorithm>
#include <iostream>
#include <vector>
#include <time.h>

using namespace std;

int main()
{
    // Create a vector object that contains 10 elements.
    vector<int> a(10);

    // randomly initialize using lambda expressions
    srand((unsigned)time(0)); 
    for_each(a.begin(), a.end(), [](/*by reference*/ int& aux){

        aux = rand()%100; } );

    //now, print it
    for_each(a.begin(), a.end(), [](int aux){ cout << aux << endl; } );

    return 0;
}

If you are not used to use for_each, here is an example without use lambdas:

#include <algorithm>
#include <iostream>
#include <vector>

using namespace std;

void printThing(int i){
     cout << i << endl;
}

int main(){
    // Create a vector object that contains 10 elements.
    vector<int> a(10);

    // randomly initialize using lambda expressions
    srand((unsigned)time(0)); 
    for_each(a.begin(), a.end(), [](int& aux){aux = rand()%100; } );

    for_each(a.begin(), a.end(), printThing );
    return 0;
}

And another example using templates, just getting fun:

#include <algorithm>
#include <iostream>
#include <vector>

using namespace std;

template<class T>
void printThing(T i){ //void printThing(const T& i) would be better/faster
     cout << i << endl;
}

int main(){
    // Create a vector object that contains 10 elements.
    vector<int> a(10);

    // randomly initialize using lambda expressions
    srand((unsigned)time(0)); 
    for_each(a.begin(), a.end(), [](int& aux){aux = rand()%100; } );

    for_each(a.begin(), a.end(), printThing<char> );//yes is char,

    //just to show that we are casting
    return 0;
}

Playing with variadic

2012-03-29T13:24:00.004+02:00

Okey, here's an example with variadics. Of course, that's not ever the best way, in fact, it's absolutely bad practice but I was just playing with.

So, if you are interested in what this guy did? go ahead if not and you want to learn and even use
some of my ideas, don't try it.

Being weighed, this is not a good example, just take it for fun.

#include <iostream>

template<typename...Types>
class List{
public:
     int size;
     void** elements;//aray of things
     List(){
         size = sizeof...(Types);
     };
     List(Types... Args){
         size = sizeof...(Types);
         elements = new void*[size];
         if(size != sizeof...(Args) )
             std::cout << "diferent size" << std::endl;
         else{
             std::cout << "good" << std::endl;
             push(0,Args...);
         }
     };
    
private:
     template<class T>
     void push(int pos, T last){
         if(pos == size-1){
             std::cout << "at: " << pos << " added -> " << *last << std::endl;
             std::cout << "All correct" << std::endl;
             elements[pos] = static_cast<void*>(last);
         }
     }
     template<class First, class...Rest>
     void push(int pos, First first, Rest...rest){
         elements[pos] = static_cast<void*>(first);
         std::cout << "at: " << pos << " added -> " << *first << std::endl;
         pos++;
         push(pos,rest...);
     }
};

using namespace std;

struct A{
public:
      string info;
public:
      A(string in) : info(in){};
      friend ostream& operator<<(ostream& out, const A& a){
          out << a.info;
          return out;
      };
};
int main(void){
     List<int*,int*,double*,string*,A*> list(new int(1),new int (2),

                     new double (2.101), new string("aloha"),new A("NICE") );

     cout << "size: " << list.size << endl;
     cout << *static_cast<int*>(list.elements[0]) << ", ";
     cout << *static_cast<int*>(list.elements[1]) << ", ";
     cout << *static_cast<double*>(list.elements[2]) << ", ";
     cout << *static_cast<string*>(list.elements[3]) << ", ";
     cout << *static_cast<A*>(list.elements[4]) << ", ";
     
     return 0;
}

Output:

good
at: 0 added -> 1
at: 1 added -> 2
at: 2 added -> 2.101
at: 3 added -> aloha
at: 4 added -> NICE
All correct
size: 5
1, 2, 2.101, aloha, NICE,

Variadic templates

2012-03-28T23:51:00.000+02:00

Every time, every time, C++ surprise me. Today, with variadic templates that allow us to specifier an unknown number of arguments. And this becomes an completely useful tool.

At the moment, I won't explain it because still being a mystery for me. Just say that this allow recursion
like prolog. Moreover, we can make containers of different types and even very things that I don't know.

Here's my example:

#include <iostream>

using namespace std;

//base case:
template<class T>
void printArray(T last){
     cout << last << endl;
}

template<class First, class...Rest>
void printArray(First first, Rest... rest){
     cout << first << ", ";
     printArray(rest...);
}

struct A{
public:
     string info;
public:
     A(string in) : info(in){};
     friend ostream& operator<<(ostream& out, const A& a){
         out << a.info;
         return out;
     };
};

int main(void){
     printArray(1);
     printArray(1,2);
     printArray(1,2,3);
     printArray(1,2,3,4,5);
     
     printArray("I");
     printArray("I","can't");
     printArray("I","can't","that");
     printArray("I","can't","that","this");
     printArray("I","can't","that","this","works");
     
     //diferent types, even a custom class
     printArray(1,"aloha",2.123,'a', A("Com estas?") );
     
     return 0;
}

Output:

1, 2, 3
1, 2, 3, 4, 5
I
I, can't
I, can't, that
I, can't, that, this
I, can't, that, this, works
1, aloha, 2, que tal?
1, aloha, 2.123, a, Com estas?

String arguments in templates

2012-03-28T21:21:00.000+02:00

Well, well, well.
Up to this point, you should have a minimal idea of templates. Of course, there are some chapter
that you didn't understand yet or you didn't take the whole idea that I was trying to teach.

But don't worry, you just need reviews like this post to understand that some of the titles I made
are of huge interest and even, indeed, more complex.

Here there's an example that show that the chapter, argument deduction, is more complex as it
seems and we don't have to take it as if nothing because even with the string type we can get
much mistakes as you think.

#include <string>
// note: reference parameters
template <typename T>
inline const T& max (const T& a, const T& b){
     return a < b ? b : a;
}
int main(){
     std::string s;
     ::max("bye","cya"); // OK: same type
     ::max("hello","bye"); // ERROR: different types
     ::max("chau",s); // ERROR: different types
}

First look, you may think, what the hell is happening here, how it doesn't work?, but if you take long
time and read the compiler you'll that is an error about types.

First off, remember that string is a C++ type and when you declare some thing like "this (with commas)" you are not really creating an string if not that is an char*. Thus, max(), is not
calling the function max with string's type if not that are char's.

Beside, we have to notice, in order to see the error, that the problem becomes from pass arguments
as reference (&) because without this we didn't get error from first and second call.
That's it because without pass by reference the type pass it is const char*. On the other hand, calling
by reference, we are passing the following type. char const[3] where this number is the size of
the string.

This makes that two strings of different sizes makes an error like in the second call where
"hello" is 4 and "bye" is 3(insist, all this is by argument deduction).

There are many forms to solve this problem like be sure that strings are strings(for instance, string("bye") ) but I want to handle it with templates; it's not as elegant as I'd like but this is it.

template <typename T, int N, int M>
inline T const* max (const T (&a)[N], const T (&b)[M]){
     return a < b ? b : a;
}

Type Traits

2012-03-23T16:43:00.000+01:00

Hello everybody,
Lately I have been snowed under work, in fact, I still. But I'm posting anyway ^ ^

Well, here's an introduction to some features of templates type traits.

Notice that this post is just an introduction and if you don't see the utility now you will see in further posts. Just say that generic programming can sometimes be not generic enough.

Starting to take a look to the standard way to check types of variables.

The standard provide some ways to do it. Although has his limitations and even isn't much effective but
allows to compare or even read the type of variables.

Doing this task I'm using typeid that return a std::type_info where is implemented some
methods like name in order to return a human-readable.

I don't know why my compiles expres int as i, I think that is not much normal because I have seen
many examples where typeid().name return the word int, not i, but in fact don't care.

// type_info example
#include <iostream>
#include <typeinfo>
using namespace std;

struct Base {};
struct Derived : Base {};

//using virtual; being polymorphic
struct Poly_Base {virtual void Member(){}};
struct Poly_Derived: Poly_Base {};

int main() {
     int i;
     int *p_int = 0;
     double array_d[10];

     cout << "    int is: " << typeid(int).name() << endl;
     cout << "      i is: " << typeid(i).name() << endl;
     cout << "  int==i? : " << boolalpha <<

           (typeid(i) == typeid(int)) << endl;

            //with boolapha we'll print true/false inside of 1/0
     cout << "  p_int is: " << typeid(p_int).name() << endl;
     cout << " *p_int is: " << typeid(*p_int).name() << endl;
     cout << "array_d is: " << typeid(array_d).name() << endl << endl;
   
     // non-polymorphic types:
     Derived derived;
     Base* pbase = &derived;
     cout << "derived is: " << typeid(derived).name() << endl;
     cout << "  pBase is: " << typeid(pbase).name() << endl;
     cout << " *pbase is: " << typeid(*pbase).name() << endl;
     cout << " same type? "; 
     cout << boolalpha <<( typeid(derived)==typeid(*pbase) )

          << endl << endl;

     // polymorphic types:
     Poly_Derived polyderived;
     Poly_Base* ppolybase = &polyderived;
     cout << "polyderived is: " << typeid(polyderived).name() << endl;
     cout << "  ppolybase is: " << typeid(ppolybase).name() << endl;
     cout << " *ppolybase is: " << typeid(*ppolybase).name() << endl;
     cout << boolalpha << "same type? " <<

           ( typeid(polyderived)==typeid(*ppolybase) ) << endl << endl;
}

Output:

int==i? : true
p_int is : Pi
*p_int is : i
array_d is : A10_d

derived is : 7Derived
pBase is : P4Base
*pbase is : 4Base
same type? false

polyderived is : 12Poly_Derived
ppolybase is : P9Poly_Base
*ppolybase is : 12Poly_Derived
same type? true

Useful? Could be.
Although, as I said, it has some limitations, for example, what happens if I want to compare an
usigned int and an int, is it equal? The answer is no; false.

So, now, I want to show how we could do this task using temples. The behind idea is argument deduction and specialization.

#include <iostream>

template<class T>
struct is_int{
     static const bool value = false;
};
template<>
struct is_int<int>{
     static const bool value = true;
};
template<>
struct is_int<unsigned int>{
     static const bool value = true;
};
template<>
struct is_int<char>{
     static const bool value = true;
};

class A{};

using namespace std;

int main() {
     cout << "is int?: " << boolalpha << is_int<int>::value << endl;
     cout << "is unsigned int?: " << boolalpha

          << is_int<unsigned int>::value << endl;

     cout << "is string?: " << boolalpha << is_int<string>::value << endl;
     cout << "is A?: " << boolalpha << is_int<A>::value << endl;
}

Output:

is int?: true
is unsigned int?: true
is string?: false
is A?: false

Finally, just say that boost library provide many of this template functions.

#include <boost/type_traits>

And even functions like:

is_pointer<T>
is_arithmetic<T>
is_function<T>
is_class<T>
is_polymorphic<T>
has_trivial_constructor<T>

Awesome, I know.

Also, I wanted to mention to the new decltype that is introduced in the new version of C++,
this one will be a tricky form to declare variables that you don't know how, because his complexity
can be complex like templates. It's not exactly related with what I explained but I think that
may be interesting to someone.

Pointers and Constants using Int

2012-03-05T15:17:00.001+01:00

Hello everybody,

I did a short example to give an expression of pointers and constants. It's uniquely illustrative. With all this, I'm trying to lay the groundwork to const correctness's use because the good use of const is absolutely important in complex applications where the efficient matter.

Here we go:

int main(){
           int         intInt;
     const int         cint = 10;//we have to initialize here unless

                                 that is an atribut's class

                                 //and, in this case, have to be

                                 initialize inside the constructor

           int *       ptrInt;
     const int *       constValue;
           int * const constPtr = &intInt;//have to be initialize here
     const int * const constPtrValue = &intInt;//have to be initialize

                                               here

     
     //intInt
     intInt = 1;
     intInt = 2;
     //we can change the value as times as we like
     
     //cint
     //cint = 2; EROR: this variable is const so is the same

     to say read-only
     
     //ptrInt
     ptrInt = &intInt;
     //ptrInt = &cint; ERROR: the reference from cint is 'const int*'

     and was expected int*
     *ptrInt = cint; //we can put the value of cint inside our pointer
                     //but in this case we have copied by value and no

                     by reference so
                     //*ptrInt don't point to a const and then

                     we can increment his value:
     (*ptrInt)++;    //now is 11
     
     //constant pointer
     constValue = &cint; //we can point to any constant int
     int aux = 20;
     constValue = &aux; //even to a int but still being unaccesible

                        using constValue
     intInt = 30;
     int *auxPtr = &intInt;
     constVconstValue = auxPtr;//in this way the value of constValue is 30
                         //and still being unaccesible from constValue
     //*constValue = 12; ERROR: the value of constValue is const,

     so *constValue is read-only
     intInt = 100;       //but we can change the value from the variable
                         //so this is legal, and then
     std::cout << *constValue;//this print 100
     
     (*auxPtr)++;        //but we still having access also from our auxPtr
                         //so this is legal to
     std::cout << *constValue;//and now, this print 101
     
     //int * const constPtr
     //constPtr = auxPtr; EROR: our pointer is constant so we can't change

     the direction where point
     *constPtr = 2;//but the value isn't constant, so we can change it
     std::cout << *constPtr; // is 2
     std::cout << intInt;// and the value have been changed too, is 2
     
     //const int * const constPtrValue
     std::cout << *constPtrValue;// is 2 because we are pointing to intInt
     //constPtrValue = ptrInt; ERROR: assigment of read-only variable
     //*constPtrValue = 20; ERROR: read-only value
                 //so we only have access to the variable
                 //although we can change the value with other variables
     intInt = 666;
     std::cout << *constPtrValue; //this print 666
}

Pointers to Functions

2012-02-29T02:20:00.000+01:00

First FAQ post

Check it out!!
http://surprising-code.blogspot.com/p/pointers-to-member-functions.html

Nontype Template Parameters

2012-02-28T17:28:00.001+01:00

Konnichiwa!!

Lately I have been very excited programming and I really have to do an effort to continue chapter after chapter in order not to mess up the blog. However, if you are interested to get further feel free to check out the examples page.

So then, let's work!

First off, what's the meaning of nontype template parameters? Indeed, the idea is so simple, is just to use types like int inside templates. Till now, all template examples we have seen has been with the reserve word typename or class but the powerful of templates don't finish here.

For example, a Matrix:

template<int W, int H>
struct Matrix{
    double m[W][H];
};

Thus, now, we can simply constructor of a Matrix like this:

Matrix<4,4> A={0,0,0,0,

               0,1,0,0,

               0,0,1,0,

               0,0,0,1};

Matrix<4,1> B={1,2,3,4};

In the case using a class in lieu of a struct, we could not do it in this way unless we started using C++11.
Another example usefull with matrices could be the below:

template<int sizeAX,int sizeAY, int sizeBY>
void mult(const Matrix<sizeAX,sizeAY>& A,const Matrix<sizeAY,sizeBY>& B,

Matrix<sizeAX,sizeBY>& C);

Note: I'm using pass by reference, check out FAQ if dont get it at all why I used &'s or const.

This function multipy does A · B = C
But not always matrices can be multiplied. With the definition we did, we can do A · B but not B · A.
In this case we'll have a compile error:

(I change the variable names to make it more understandable)

void mult(const Matrix<4,1>& A,const Matrix<4,4>& B,

void mult(const Matrix<sizeAX,sizeAY>& A,const Matrix<sizeAY,sizeBY>& B,

sizeAX = 4; sizeAY = 4;
sizeAY = 1; sizeBY = 4;
SizeAY don't match so here is where the error occurs. But, in fact, is better to have this error in compile time than runtime.

Struct Matrix here!!

A similar example, here:

template<typename T, int ROWS, int COLS>
class Matrix;

template<int InCOLS>
Matrix<T, ROWS, InCOLS> operator*(const Matrix<T, COLS, InCOLS>& in) const;

If template COLS of our matrix match with the rows of the supose matrix to be multiply then we are able to do it. And the result of this multiply will be ROWS and InCOLS.

Slowly:

A(3,2)*B(2*10) = C(3,10)

If colsA(2) is equal to rowsB(2).

sizeC = (rowsA, colsB)

Summary

2012-02-27T21:49:00.000+01:00

A short summary.

So far, I have introduced templates programming step by step with some examples. I didn't explain many things by myself, I tried to show you how it works.

Bearing all of this in mind, it's time to go over the profits of templates and the reason of being so interesant.

Templates are type-safe: The compiler is able to do the type checking before a error occurs.

If you write general code for a common base class you lose this benefits. Moreover is expected you may derive this class, which makes it even more difficult to maintain.

Easiness writing them: With just one class we may have an infinity number of uses

Remember the example of max, with which one we saved many definitions.

Optimize the runtime by compiling time: This point, I'd like to flesh out through metaprogramming but stay with the idea.

Good possibility to reuse code.

Default Template Arguments

2012-02-26T18:39:00.000+01:00

Hello everybody, sorry for the delay. I have been so busy although I posted some examples.

Today, I'll show you an useful tool with templates. You will able to define default templates, this, it is so interested especially for containers.

Some chapters before we defined a Queue class. Now, we retake it.

How it looks a Default Template:

template<typename T, typename CONT = std::vector<T> >

T, like previous examples, is the type that contain our class. And CONT is the template parameter that the class will use as container.

For example:

Using the new class Queue ( at the end you the sheet or here ):

Queue<int> queueInt;
Queue<int, std::deque<int> > queueIntWithDeque;

So, we can indicate the container that our queue will use or not. Taking the dafault argument in this case.

Even, we can define a default type, for example:

template<typename T = double, typename CONT = std::vector<T> >

And now, we can use the default templates, for instance:

Queue<> defaultExample;

Another example which I will explain deeper in the next chapter are the nontype template parameters.
Basically, we are also able to define these as default.

A short example:

template<int H = 2, int W = 2 > (example of nontype template parameters here)

Okey, let's see the new class Queue:

#include <iostream>
#include <stdexcept>
#include <vector>
#include <deque>

template <typename T = double, typename CONT = std::vector<T> >
class Queue{
      private:
          CONT elements;
          
      public:
          Queue(){}//default constructor
          T back(){ // return last element
              return elements.back();
          }
          void push(const T& element){//add an element
               elements.push_back(element);
          }
          void pop(){//erase first element
              if (elements.empty()) {
                  throw std::out_of_range("Stack<>::pop(): empty stack");
              }
              elements.erase( elements.begin() );
          }
          bool empty(){return elements.empty();}
          int size(){return elements.size();
          }
          T front(){
              if (elements.empty()) {
                  throw std::out_of_range("Stack<>::pop(): empty stack");
              }
              return elements.front();}
};
          
template< typename T>
void iterate_Queue(Queue<T>& queue){
      while(not queue.empty()) {
          std::cout << "(" << queue.front()<< ", " << queue.back() << ")";
          std::cout << "with size:"<< queue.size() << std::endl;
          queue.pop();
      }
      std::cout << std::endl;
}

// overloading function
template< typename T, typename CONT>
void iterate_Queue(Queue<T,CONT>& queue){
      while(not queue.empty()) {
          std::cout << "(" << queue.front()<< ", " << queue.back() << ")";
          std::cout << "with size:"<< queue.size() << std::endl;
          queue.pop();
      }
      std::cout << std::endl;
}


typedef Queue<int> intQueue;// It's common to define typedef's in order to simply 

int main() {
      try{
          intQueue y;
          y.push(1);
          y.push(2);
          y.push(3);
          y.push(4);
          iterate_Queue(y);

          y.push(15);
          iterate_Queue(y);

          
          Queue<int, std::deque<int> > newExample;
          newExample.push(10);

          newExample.push(20);

          newExample.push(30);

          newExample.push(40);

          iterate_Queue(newExample);

          newExample.push(150);

          iterate_Queue(newExample);

          std::cout << "complet dafault example " << std::endl;
          Queue<> defaultExample;
          defaultExample.push(1.3);

          defaultExample.push(2.2);

          defaultExample.push(3.1);

          defaultExample.push(4.4);

          iterate_Queue(defaultExample);

          defaultExample.push(150);

          iterate_Queue(defaultExample);

          
      } catch (const std::exception& ex) {
          std::cerr << "Exception: " << ex.what() << std::endl;
      } 
      
      return 0;
}

output:

(1, 4)with size:4
(2, 4)with size:3
(3, 4)with size:2
(4, 4)with size:1

(15, 15)with size:1

(10, 40)with size:4
(20, 40)with size:3
(30, 40)with size:2
(40, 40)with size:1

(150, 150)with size:1

complet dafault example
(1.3, 4.4)with size:4
(2.2, 4.4)with size:3
(3.1, 4.4)with size:2
(4.4, 4.4)with size:1

(150, 150)with size:1

RUN SUCCESSFUL (total time: 615ms)

However, default templates have their own shortcomings, for example, in this case, we did the Queue methods using functions like: back(), front(), ...

All this methods has to be implemented in the container we are going to use. In the case we didn't, we'll get some errors in time compiling (fortunately).

Templates are so useful for this, you can check errors in compiling time. If you saw the example of a Matrix class that I did, you can see this feature. We can multiply matrixes, and at compiling time, we can be sure all the products are possible.

Enjoy it!

Specializations

2012-02-21T11:38:00.002+01:00

Morning!

Today, I want to show the specialize of classes. Thereby, you can give a diferent implementation.

Templates are so useful but sometimes could be necessary to make exceptions. C++ provide this tool that is similar to override functions.

Testing specialitzations:

#include <iostream>

//base case or primary template
template <typename T1, typename T2>
class Example{
     private:
         T1 _element1;
         T2 _element2;
     public:
         Example(){ 
             std::cout << "Example" << std::endl;
         }
};

//Specializations or also called partial or full specialization
//depending on each case

template <typename T>
class Example<T, T>{
     private:
         int _element1;
         int _element2;
     public:
         Example(){ 
             std::cout << "Example same class" << std::endl;
         }
};


template <typename T>
class Example<T, int>{
     private:
         int _element1;
         int _element2;
     public:
         Example(){ 
             std::cout << "Example template and int" << std::endl;
         }
};

template <typename T1,typename T2>
class Example<T1*,T2*>{
     private:
         int _element1;
         int _element2;
     public:
         Example(){ 
             std::cout << "Example template* and template* " << std::endl;
         }
};

int main(){
     Example<int,float> ex1;
     Example<float,float> ex2;
     Example<float,int> ex3;
     Example<int*,float*> ex4;
     //Example ex5; // error:
     /*
      * main.cpp:57:22: error: ambiguous class template instantiation for ‘class Example<int, int>’
      * main.cpp:19:20: error: candidates are: class Example<T, T>
      * main.cpp:31:22: error:                 class Example<T, int>
      * 
      * To fix it we might specify:
      * 
      * template <>
      * class Example<int,int>
      */
     
     //Example ex6; // error:
     /*
      * main.cpp:64:24: error: ambiguous class template instantiation for ‘class Example<int*, int*>’
      * main.cpp:19:20: error: candidates are: class Example<T, T>
      * main.cpp:42:23: error:                 class Example<T1*, T2*>
      * 
      * To solve this issue we could implement a specialitzacion for pointers
      * of the same type:
      * 
      * template<typename T>
      * Example<T*, T*>
      * 
      */
}

First template class, queue

2012-02-19T23:38:00.000+01:00

Hello again!

I hope you have started to see the useful of templates, till now, I only showed templates with functions but, of course, that was just the start.

Now, I'll begin showing template classes. One of the most famous examples to show this are container classes, specially Stack. To change, I have done a Queue.

By the way, I have programmed using the exception library, if you don't get it, just ignored and think you could implement with other ways.
This way programming is so common in Java and if you come from it should be so easy to you.

First of all, what is the behave of a queue? just think with the queue of a cinema. First in, first out.
Example of the behave having this queue: [ a, b, c, d ]

With the back function we get d.
With a push(e) we'll have [ a, b, c, d, e ]
With pop(): [ b, c, d, e ]
empty(): false
size(): 4
front(): b

Well, here you have the code Note that I used a STL container internally.

#include <iostream>
#include <stdexcept>
#include <vector>

template <typename T>
class Queue{
     private:
         std::vector<T> _elements;
         
     public:
         Queue(){}//default constructor
         T back(){ // return last element

         if (_elements.empty()) {
                 throw std::out_of_range("Queue<>::back(): empty stack");
             }
return _elements.back();
         }
         void push(const T& element){//add an element
              _elements.push_back(element);
         }
         void pop(){//erase first element
             if (_elements.empty()) {
                 throw std::out_of_range("Queue<>::pop(): empty stack");
             }
             _elements.erase( _elements.begin() );
         }
         bool empty(){return _elements.empty();}
         int size(){return _elements.size();}
         T front(){
             if (_elements.empty()) {
                 throw std::out_of_range("Queue<>::front(): empty stack");
             }
             return _elements.front();}
};
         
template< class T >
//Note that we are passing by reference, so original queue will be erased
void iterate_Queue(Queue<T>& queue){
     while(not queue.empty()) {

         std::cout << "(" << queue.front()<< ", " << queue.back() << ")";
         std::cout << "with size:"<< queue.size() << std::endl;
         queue.pop();
     }
     std::cout << std::endl;
}
typedef Queue<int> intQueue;// It's common to define typedef's in order to simply 
//definicions
//typedef Queue< intQueue > intQueueQueue;

typedef Queue< Queue<int> > intQueueQueue;

                       // ^-- This space isn't opcional, copiler'd think that is a << operador
int main() {
     try{
         intQueue y;
         y.push(1);
         y.push(2);
         y.push(3);
         y.push(4);
         iterate_Queue(y);

         y.push(15);
         iterate_Queue(y);

         y.front();//exception, queue is empty
     } catch (const std::exception& ex) {
         std::cerr << "Exception: " << ex.what() << std::endl;
     } 
     
     return 0;
}

output:

(1, 4)with size:4
(2, 4)with size:3
(3, 4)with size:2
(4, 4)with size:1

(15, 15)with size:1

Exception: Queue<>::front(): empty stack

RUN SUCCESSFUL (total time: 244ms)

Ok, I hope you understood the most code, let's take a look of hard parts.

First, I did a template function to empty and show the values of a Queue, printing the first and the last element.

Beside, we have some exceptions (throws) in our class, pop, back and front. Theses exceptions void the problem to access an empty vector, in that case, we make a throw:

throw std::out_of_range("Queue<>::pop(): empty stack");

Then, in the main, we bracketed our code with a try and catch. This means that C++ is going ahead taking care whether an error happends and if so then execute the catch. In fact, that error is called by the throw we made.

In the catch, ex.what() get the string we threw.

Another example of throw:

throw std::overflow_error("overflow");
even:

throw 20;//in that case you have to catch an int

On the other hand, I introduced typedef operator in which you can define any type as you like:

//typedef Queue< intQueue > intQueueQueue;

typedef Queue< Queue<int> > intQueueQueue;

typedef Queue< std::vector<int> > intVectorQueue;


I hope you enjoyed. For any doubt or comment, feel free to leave your message.


For an example without use of std::vector :
http://surprising-code.blogspot.com/p/example8.html

Overloading: calls by reference and by value

2012-02-18T00:25:00.001+01:00

In this chapter you would understand the significance defining functions types.

By the way, it's a good idea to pass all arguments by references whenever you don't have to modify any parameter. In fact, pass by references is much efficient.

Example:

#include <iostream>
#include <cstring>
// maximum of two values of any type (call-by-reference)
template <typename T>
inline T const& max(T const& a, T const& b) {
     std::cout << "call-by-reference, 2 arguments" << std::endl;
     return a < b ? b : a;
}
// maximum of two C-strings (call-by-value)
inline char const* max(char const* a, char const* b) {
     std::cout << "call-by-value" << std::endl;
     return (std::strcmp(a, b) < 0) ? b : a;
}
// maximum of three values of any type (call-by-reference)
template <typename T>
inline T const& max(T const& a, T const& b, T const& c) {
     std::cout << "call-by-reference, 3 arguments" << std::endl;
     return max(max(a, b), c); // error, if max(a,b) uses call-by-value
}

int main() {
     ::max(1, 2, 3);// OK
     std::cout << std::endl;
     
     const char* s1 = "surpring";
     const char* s2 = "-";
     const char* s3 = "code";
     ::max(s1, s2, s3);// ERROR, warning: returning reference to temporary
     std::cout << std::endl; 
     
     ::max(*s1, *s2, *s3);//works good! (by reference)
     std::cout << std::endl; 
}

::max(s1, s2, s3);// ERROR, warning: returning reference to temporary

This line is given an error/warning because call to the non-template function andhis parameters expected a value not a reference.

We may fix up it changing the definition to const char* const&. (There are others)

If we switch the order the compiler might take another function, for example, if the order is the bellow:

template <typename T>
inline T const& max(T const& a, T const& b) {

template <typename T>
inline T const& max(T const& a, T const& b, T const& c) {

inline char const* max(char const* a, char const* b) {

Now, with this call ::max(s1, s2, s3); we won't have the warning but, look out, because at this form we aren't using return (std::strcmp(a, b) < 0) ? b : a; .

For the moment, as a rule of thumb you always have all

overloaded versions of a function declared before the function is called.

Pointers and Constants

2012-02-17T00:19:00.000+01:00

Hello everybody,
This is a fast example to give expression to pointer and constants.

I had some questions about char const* const, so now, I try to explain what exactly means.

If you continue having questions don't doubt to ask me.

#include <iostream>

int main(){    

     char const* s1 = "Testing";//pointer to const variable
     char* const s2 = "constant";//const pointer
     char const* const s3 = "aloha";//const pointer and variable

     s1 = "testing 2";//works perfectly, reassigning the pointer to another const variable
     //*(s1+1) = 'A'; error, tring to change Testing to TAsting
     //*s1 is const, so can't be modify
     
      //s2 = "new string"; error, read-only, you can't change the pointer because is constant
     *s2 = 'A';//you can modify the value

     //s3 = "fuuuu"; error, constant pointer
     //*s3 = 'B'; error, constant value
     

     return 0;

}

Thanks you all!

Overloading Function Templates

2012-02-16T01:35:00.001+01:00

Hello everybody

So far, we should have a bit idea of templates programming. In this post I'll speak about overloading functions center of attention to templates.

For a change, I follow using max function.

#include <iostream>
namespace mySpace{
    inline const int& max (const int& a, const int& b){
        std::cout << "int"<< std::endl;
        return a>b?a:b;
    }
template < class T >
   inline T max (const T& a, const T& b){
    std::cout << "template"<< std::endl;
        return a>b?a:b;
    }
template < class T >
   inline T max (const T& a, const T& b, const T& c){
           std::cout << "template, 3: "<< std::endl;
        return max(max(a,b),c);
    }
}
int main(){
    // calls the template with three arguments
    //and this one will call the non-template int function (by argument deduction)
    //because the better choise that compiler can make
    mySpace::max(2, 1, 9);
 
    //both types match perfectly, so calls non-template int (by argument deduction)
    mySpace::max(3, 5); 
 
    // if the template can generate a better match, will be selected
    // there is neither a function with char arguments nor template, so
    // the call will be max<char> (by argument deduction)
    mySpace::max('a', 'b'); 
 
    // calls max<double> (by argument deduction)
    mySpace::max(3.2, 5.4); 
 
    // forcing the call template with no deduction
    // calls max<double> (no argument deduction)
    mySpace::max<double>(7, 42); 

    // calls the nontemplate for two ints
    mySpace::max('a', 42.7); 

    // calls max<int> (by argument deduction)
    // with <>, we are calling the template function
    // rather that a non-template exists
    mySpace::max<>(7, 42); 
 
        return 0;

}

Up to now it seems easy, what happends wheter we start using pointers and char types.
I like to be practical, so let's see another one:

#include <iostream>
#include <cstring>
#include <string>
namespace mySpace{ 
    template < class T > 
    inline const T& max (const T& a, const T& b){ 
        std::cout << "template"<< std::endl;
        return a>b?a:b; 
    }
    template < class T > 
    //I have changed the argument types to constants because I want to pass it by reference, (&)
    //note that const T& is equivalent to T const&
    inline T* const&  max (T* const& a, T* const&  b){ 
        std::cout << "template pointer: "<< std::endl;
        return a>b?a:b; 
    }
    
    //a fuction for C-string, char*
    /*
     * Note: Go back and remember the first template max; I didn't 
     * show any call like max("abc","acd"), this one is deduced as 
     * a char*, so, with the implementations we did (return a>b?a:b;),
     * this operacion is comparing the pointers and no his values
     * so this was a bug
     * 
     * In order to resolve it, we may call max<std::string>("abc","acd")
     * or calling constructor like std::string: max(std::string("abc"),std::st     * ring("acd") )
     * 
     * Or with the following function
     */
    //
    inline char const* const&  max (char const* const& a, char const* const&  b){ 
        std::cout << "c-string: "<< std::endl;
        return (std::strcmp(a,b) < 0) ? b : a;
    }
}
int main(){
    int a = 5, b = 10;
    int* p_a = &a;
    int* p_b = &b; //pointers_to
    
    mySpace::max(a,b); //template
    mySpace::max(p_a,p_b); //template pointer
    mySpace::max(*p_a,*p_b); //template

    char const* s2 = "I'm so cool";
    char const* s1 = "David";
    mySpace::max(s1,s2); //c-string
    mySpace::max<>(s1,s2); //template, the output is David, WRONG!
    mySpace::max("asd","asdasd");//c-string
    
    std::string s3 = "David";
    std::string s4 = "I'm so cool";
    mySpace::max(s3,s4);//c-string
    
    //This is more typical in C
    char* s5 = "David";//warning: deprecated conversion from string constant to ‘char*’
    char* s6 = "I'm so cool";//warning: deprecated conversion from string constant to ‘char*’
    
    //warning: deprecated conversion from string constant to ‘char*’
    //our function works with char const*, so call templates,
    //and how templates are constants this make a warning
    //but note that call can be wrong
    mySpace::max(s5,s6);//template

    return 0;
}

Note that I declared all templates as const and by reference, is a good practice to do unless you need to modify.
That's all today, next I will do a bit example with char const* using 3 parameters, like first exercice.

Argument Deduction

2012-02-13T16:26:00.000+01:00

Hello everybody

Till now, we have been seeing the powerful of templates but, like I showed,
sometimes we can get some unexpected results so I like to check out this topic, argument deduction

There are so many times that C++ compiler must conclude that T must
be int or any type, what becomes this?

An example we unexpected:

#include <iostream>
#include <complex>
namespace mySpace{ // getting sure that this is the class we call becouse std::max is implemented
    template < class T > // for any class/typename T
    inline const T& max (const T& a, const T& b){ //
        return a>b?a:b; // where the operator '>' is implemented
    }
}
int main(){
    std::cout << mySpace::max(10,20) << std::endl;// works perfectly as we saw
    //std::cout << mySpace::max(15,21.1) << std::endl;// error: no matching function for call to ‘max(int, double)’
    //std::cout << mySpace::max('a',21) << std::endl;// error: no matching function for call to ‘max(char, int)’
    
    //some ways to fix it:
    
    // static_cast is a powerful tool, and I'm going to explain it while course
    std::cout << mySpace::max(static_cast<double>(15),21.1) << std::endl;
    
    // double(x) call the costructor of double, so 15 is an double
    std::cout << mySpace::max(double(15),21.1) << std::endl;
    
    // this is a bad practice, this cast is highlighting to the compiler that is a double
    //in this case works, but take care it
    std::cout << mySpace::max((double)15,21.1) << std::endl;
    
    //and the first solucion where we really use templates
    //we are forcing that max's call have to be doouble
    std::cout << mySpace::max<double>(15,21.1) << std::endl;
    
    //this examples also works but returning types is unexpected
    //we unlike 97's answer, we wanted a, as char
    //but our template function is unable to do it
    std::cout << mySpace::max<int> ('a',21) << std::endl;
    
    //This works too but don't make much sense
    std::cout << mySpace::max(int('a'),21) << std::endl;
    return 0;
}

This may appear to be a good method to enable passing two call parameters. Thus, we'll have two templates types as arguments.

Example:

#include <iostream>
#include <complex>
namespace mySpace{ // getting sure that this is the class we call becouse std::max is implemented
    template < class T1 , class T2 > // for any class/typename T
    inline const T1& max (const T1& a, const T2& b){ //
        return a>b?a:b; // where the operator '>' is implemented
    }
}
int main(){
    std::cout << mySpace::max(10,20) << std::endl;//no problems
    
    //Now, the errors we had, have been fixed but isn't enough
    std::cout << mySpace::max(15,21.1) << std::endl;
    std::cout << mySpace::max('a',21) << std::endl;
    //both of us calls makes this warning
    //main.cpp:14:37:   instantiated from here
    //main.cpp:6:22: warning: returning reference to temporary
    
    return 0;
}

This template method have some issues, for example, we're defining the return type with the first argument, then:

std::cout << mySpace::max(15,21.1) << std::endl;

This call returns 21 (with warning), the comparison works perfectly but at the moment to return value, it's needed an int, so have to truncate the double. In fact, it's not as simple as truncate and the code instance a local variable (temporaly), making that our return definacion as constant is not exaclty correct, so makes a warning.

Therefore, it may sense to define a returning type, a new template, example:

#include <iostream>
#include <complex>
namespace mySpace{ // getting sure that this is the class we call becouse std::max is implemented
    template < class T1, class T2, class RT > // for any class/typename T
    inline RT max (const T1& a, const T2& b){ //Note that return type isn't constant
        return a>b?a:b; // where the operator '>' is implemented
    }
}
int main(){
    //correct but tedious
    std::cout << mySpace::max<int,double,double>(15,21.1) << std::endl; 
    std::cout << mySpace::max<char,int,char>('a',100) << std::endl;
    
    return 0;
}

In this way, we can control types and how RT can't be deduced we have to list explitly each template type..
Another approach is to specify only the return type, in general we must specify all the argument types up to the last argument that cannot be determined by deduction progress.

Thus, if we change the order of the templates we could only specify RT, let's see:

#include <iostream>
#include <complex>
namespace mySpace{ // getting sure that this is the class we call becouse std::max is implemented
    template < class RT, class T1, class T2 > // for any class/typename T
    inline RT max (const T1& a, const T2& b){ //Note that return type isn't constant
        return a>b?a:b; // where the operator '>' is implemented
    }
}
int main(){
    std::cout << mySpace::max<double>(15,21.1) << std::endl; 
    std::cout << mySpace::max<char>('a',100) << std::endl;
    std::cout << mySpace::max<char,char,int>('a',100) << std::endl;
    return 0;
}

Instantiation

2012-02-13T01:17:00.000+01:00

Unfortunately, the tems instance and instantiate are used in a different context in object-oriented programming.
In general, when I speak about instantisate I will be refering at template context.

When we define a template, compiler review if the systax is correct but this isn't enough, for example, the example of max. We instantiated some calls to max with int, string, float. All examples worked well because each type had the operator > implemented, the review of this is what I call instantisate.

So, the instantiation is when compiler checks whether some calls like max(a,b) can make it. In the example you'll see below you can see when compiler make an error for instantisation because our template method is assuming we can use the operator > and isn't implemented.

Below an example where instantisate makes an error:

#include <iostream>
#include <complex>
namespace mySpace{ // getting sure that this is the class we call becouse std::max is implemented
    template < class T > // for any class/typename T
    inline const T& max (const T& a, const T& b){ //
        return a>b?a:b; // where the operator '>' is implemented
    }
}
int main(){
    std::complex<float> a(10,10.1);
    std::complex<float> b(10.1,10);
    
    std::cout << mySpace::max(a,b) << std::endl;
    
    return 0;
}

main.cpp: In function ‘const T& mySpace::max(const T&, const T&) [with T = std::complex]’:
main.cpp:13:34:   instantiated from here
main.cpp:6:22: error: no match for ‘operator>’ in ‘a > b’

Fixing this error:

#include <iostream>
#include <complex>
namespace mySpace{ // getting sure that this is the class we call becouse std::max is implemented
    template < class T > // for any class/typename T
    inline const T& max (const T& a, const T& b){ //
        return a>b?a:b; // where the operator '>' is implemented
    }
    template<class T> 
    inline bool operator>(const std::complex<T>& a, const std::complex<T>& b)    {
        if(a.imag() > b.imag())
            return true;
        return false;
    }
}
int main(){
    std::complex<float> a(10,10.1);
    std::complex<float> b(10.1,10);
    
    std::cout << mySpace::max(a,b) << std::endl;
    
    return 0;
}

This solucions is prioritizing 'i' (complex number), but we could do anything.

Next topic, Argument Deduction.

Thanks you all.

Why templates?

2012-02-12T20:34:00.001+01:00

What is a template?

Template programming is a programming method where we don't indicate what type we are using so this allow to make generals methods or whatever.

For instance, a typical scenario where we can use templates are data structures, such a list or a binary list. We just have indicate what class we are using.

Undestanding its usefulness:

For example:

#include <vector>
class MyClass{};//empty
    
int main(){
    std::vector<MyClass> myVector;
        myVector.push_back(MyClass());
    return 0;
}

In this example we are adding an empty class to a vector (it's a bit stupid, I know), note that this class don't have constructor, C++ makes default.

We can see that vector class is implemented with templates so just putting our class we can use it. Think about it.

Other examples are override methods. C++ allow override methods, for example:

#include <vector>
#include <iostream>
int max (int a, int b){
    std::cout << "max_int" << std::endl;
    return a>b?a:b; 
}
float max (float a, float b){
    std::cout << "max_float" << std::endl;
    return a>b?a:b; 
}
int main(){
    int a = 10, b = 20;
    float c = 10.1, d = 10.2;
    
    std::cout << max(a,b) << std::endl;
    std::cout << max(c,d) << std::endl;
    return 0;
}

Running this returns:

max_int
20
max_float
10.2

So we can see which function have been called.

The next code show a bit how C++ works and some mistakes we can make if we don't know it:

#include <iostream>
bool isMaxA (int a, int b){// if a is maxim return true(1) else return false(0)
    std::cout << "max_int" << std::endl;
    return a>b; 
}

int main(){
    float c = 10.2, d = 10.1;
    
    std::cout << isMaxA(c,d) << std::endl;
    return 0;
}
/*
This program print this:
max_int
0

*/

This isn't the answer we expected. And why is this happening?
C++ try to find a function to call isMaxA where it takes float arguments but cannot so call isMaxA with int arguments. Transforming float to int ( by trucation ) so out function compares 10>10 and, indeed, the answer is no instead of 10.2>10.1

So with this fool example we can see weaknesses and, in fact, it's a bit stupid to declare two methods that are exacly the same.

Solucion (templates):

#include <iostream>
#include <cstring>
namespace mySpace{ // getting sure that this is the class we call becouse std::max is implemented
    template < class T > // for any class/typename T
    inline const T& max (const T& a, const T& b){ //
        return a>b?a:b; // where the operator '>' is implemented
    }
}
int main(){
    int a = 10, b=20;
    float c = 10.2, d = 10.1;
    std::string e = "a";
    std::string f = "aa";
    
    std::cout << mySpace::max(a,b) << std::endl;
    std::cout << mySpace::max(c,d) << std::endl;
    std::cout << mySpace::max(e,f) << std::endl;
    std::max(a,b);
    return 0;
}

That's all today, I'll explain slowly soon why I have used words like inline, namespace, class, etc
Just get the idea
See you soon

Introduction of myself and the goal of this blog

2012-02-12T18:09:00.000+01:00

Welcome everybody!

Why are you here and why you won't leave?

If you are a programmer who'd like to improve his skills programming, making better practices or you
just are interested in new ways to programming or even more powerful tools, you are at right site.

By now, this course/blog is oriented to the use of C++ templates but likely I will do something more like some articles of interest. I'm assuming that if you are here is because you know programming so I won't explain anything of compiles, IDE's or whatever.

Beside, I'll try to teach and explain all I do but if you have any doubt you can ask me. My form
to teach maybe is a bit particular because I think that read posts isn't enough whenever you have
to program, how a writer learn to write? reading? no, writing. Of course that read would be good
but again, not enough.

Something I like to teach (this is not an index, it's a brainstorm ideas):

Why templates?
Function Templates
Argument Deduction
Instantiation
Polymorphic Power of Templetes
Namespaces
and more!

About myself

I'm a studient of computer engineering at Universitat Pompeu Fabra ( Barcelona ) and I did this blog with the goal of improve my english and show the power of templates in C++.

Thus, if there is any part that is hard to understand feel free to advise me.

If you would like to deepen in any subject or talk about any specific just say it!