How is the function being called? What does "does not work" mean? Do you have a compilation error? If so, what is it? Does the program crash? Hang? Does the program give the wrong results? If so, what is the data, what results are you expecting, and what results do you get?

t is initialized to 0, t == 5 will always be evaluated to be false, so your for loop will never run.

update

for (t = 0; t == 5; t++) {

to

for (t = 0; t < 5; t++) {

for Statement

Executes a statement repeatedly until the condition becomes false.

for ( init-expression ; cond-expression ; loop-expression )

      statement;

basically the for loop consist of 3 parts separted by ';'(semi-colon)
1)first part, this part is about initialization of variables, again you can leave it if you want
2)second part, it defines the condition on basis of which for loop will keep running, again you can leave it if you want
3) third part, this is the part where you want to do some operations, conventially iteration value is increment, but again you can leave it if you want

so if you go with this model, I think you can easily break down what is happening in the for loop that you mentioned.

You are using an array. It is a primitive type. So there are not member functions on it like objects. You have to use a vector instead. You also have to initialize the vector (or array) with chars not strings.

int main()
{
    std::vector<char> a = {'H', 'e', 'l', 'l', 'o'};
    for (int i = 0; i < a.size (); i++)
    {
        std::cout << a[i];
    }
}

If you really want to use an array you have to define the size function as follow:

template<class T, size_t N>
constexpr size_t size (T (&)[N]) { return N; }

int main()
{
    char a[] = {'H', 'e', 'l', 'l', 'o'};
    for (int i = 0; i < size (a); i++)
    {
        std::cout << a[i];
        //I also tried printf with stdlib.h
    }
}

Here's a way to do it that does not need too much boilerplate, inspired from http://stackoverflow.com/a/26902803/1495627 :

template<std::size_t N>
struct num { static const constexpr auto value = N; };

template <class F, std::size_t... Is>
void for_(F func, std::index_sequence<Is...>)
{
  using expander = int[];
  (void)expander{0, ((void)func(num<Is>{}), 0)...};
}

template <std::size_t N, typename F>
void for_(F func)
{
  for_(func, std::make_index_sequence<N>());
}

Then you can do :

for_<N>([&] (auto i) {      
  std::get<i.value>(t); // do stuff
});

If you have a C++17 compiler accessible, it can be simplified to

template <class F, std::size_t... Is>
void for_(F func, std::index_sequence<Is...>)
{
  (func(num<Is>{}), ...);
}