Thread: constructors

In the source file that defines main(), you need to ensure the compiler has visibility of the definition of class Team. For example, if the class is defined in team.h, there needs to be #include <team.h> before the definition of main().

You also need to ensure the three pointer arguments of Team's constructor are declared const. const arrays (which cannot be changed) cannot be passed as a non-const reference/pointer/array argument (which would permit changing them).

Also, in C++, main() returns int, not void.

Your constructor expects an array of characters while but you provide it with an array of strings instead

Code:

char * foo ;//array of characters 
char foo[];//array of characters
char * foo[] ;//array of strings

actually it uses C-strings. And since this is C++ the std::string would be better IMHO

Code:

#include <vector>
#include <string>
#include <iostream>
class Test
{
    std::vector<std::string> _vs;
public: 
    Test(const std::vector<std::string> &vs):_vs(vs)
    {
    }
    void print()
    {
        for(size_t i=0;i<_vs.size();i++)
        {
            std::cout << _vs[i] << std::endl;
        }
    }
};
int main(void)
{
    std::string init[] = {"test1","test2","test3"};
    size_t count = sizeof(init)/sizeof(init[0]);
    std::vector<std::string> v(init, init+count);
    Test t =Test(v);
    t.print();
	return 0;
}

Yes, it will. Though you should remember that if you a container (eg std::array, std::vector), it has a .size() function that returns the size.

Originally Posted by Aslaville

Am I guaranteed this will give me the number of strings in the array ?

Code:

size_t count = sizeof(init)/sizeof(init[0])

Actually, no. Success of this construct depends on context.

If init is a pointer (which includes arrays that are arguments of functions) then the above is not guaranteed to work as you expect.

If init is actually an array, then that construct gives the number of elements in that array.

For example;

Code:

#include <iostream>

void f(char *p)
{
     std::cout << "In f() " << sizeof(p)/sizeof(p[0]) << '\n';
}

int main()
{
     char p[5];
     std::cout << "In main() " << sizeof(p)/sizeof(p[0]) << '\n';
     f(p);
     return 0;
}

You will find that this code will print different values in main() and in f().

There is actually a trick, if you are willing to endure some template magic:

Code:

template<size_t N, typename T>
size_t ArraySize(const T(&)[N])
{
	return N;
}

void foo(int arr[])
{
	std::cout << ArraySize(arr) << "\n"; // Fails to compile
}

int main()
{
	int arr[10];
	std::cout << ArraySize(arr) << "\n"; // Compiles happily: returns 10
}

This protects you from passing a pointer, if you need it.

I don't think you will this in a book.
const T(&Name)[N] is type for passing an array by const reference where Name is the name of the argument.
T is the type and N is the size. I substituted those for template parameters so they could be anything.
An array of any type and an array of any size.
Then I just return the size.