Declaring array of int in C++ under Xcode - c++

Question

What is the difference between these two declarations?
int myints[5];
array<int,5> myints;
If I use the first declarations and the function size(), there will be a error "Member reference base type 'int [5]' is not a structure or union".
But if I use the second declarations and the function size(), the program works.
Why would the first declarations does not work?
#include <iostream>
#include <iomanip>
#include <array>
using namespace std;
int main()
{
//int myints[5]; //illegal
array<int,5> myints; //legal
cout << "size of myints: " << myints.size() << endl; //Error if I use the first declarations
cout << "sizeof(myints): " << sizeof(myints) << endl;
}

Answer 1

As others have pointed out, std::array is an extension added
to C++11 (so you may not have it), which wraps a C style array,
in order to give it some (but not all) of an STL-like interface.
The goal was that it could be used everywhere a C style array
could; in particular, it accepts the same initialization syntax
as C style arrays, and if the initialization type allows static
initialization, its initialization can be static as well. (On
the other hand, the compiler cannot deduce its size from the
length of the initializer list, which it can for the older
C style arrays.)
With regards to size, any experienced programmer will have
a size function in their toolkit, along the same lines as
std::begin and std::end (which are C++11 extensions, and
which everyone had in their toolkit before C++11 standardized
them). Something like:
template <typename T>
size_t
size( T const& c )
{
return c.size();
}
template <typename T, size_t n>
size_t
size( T (&a)[n] )
{
return n;
}
(In modern C++, the second could even be constexpr.)
Given this, you write size( myInts ), regardless of whether it
is an std::array or a C style array.

Answer 2

array<int,5> myints uses an std::array, a template that overlays enhanced functionality on-top of a "basic" C/C++ array (which is what int myints[5] is). With a basic array, you are just reserving a chunk of storage space, and are responsible for keeping track of its size yourself (although you can use sizeof() to help with this).
With the std::array you get helper functions that can make the array safer and easier to use.

Answer 3

std::array is new in C++11. As you have found, it has a size function. This tells you how many items are in the array.
sizeof on the other hand tells you how much memory a variable is taking up i.e. its size in bytes.

Answer 4

array is a template class that has size() as it's member function while int[] is simple C array

Answer 5

By using int myints[5]; , you are declaring an array of 5 ints on the stack, which is the basic C array.
Instead, by using array<int,5> myints; you are declaring an object of type array, which is a container class defined by the STL (http://en.cppreference.com/w/cpp/container/array), which in turns implements the size()function to retrieve the container's size.
The STL containers are built on top of the "basic" C types to provide extra functionality and to make it easier to manage them.

Answer 6

int myints[5]; has no function size() but you can do
int size = sizeof(myints)/ sizeof(int);
to get the size of the array.
so basically you can do:
#include <iostream>
#include <iomanip>
#include <array>
using namespace std;
int main()
{
int myintsArr[5]; //legal
array<int,5> myints; //legal
cout << "size of myints: " << myints.size() << endl; //Error if I use the first declarations
cout << "sizeof(myintsArr): " << sizeof(myintsArr)/ sizeof(int) << endl;
}
and get the same result from both the arrays