#include <iostream>

void printArray(int data[])
{
    for(int i = 0, length = sizeof(data); i < length; ++i)
    {
        std::cout << data[i] << ' ';
    }
    std::cout << std::endl;
}

int main()
{
    int data[] = { 5, 7, 8, 9, 1, 2 };
    printArray(data);
	return 0;
}

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

// Method 1: works but very little security.  It is impossible to validate
// the inputs since the size of data still cannot be validated. If length is too large
// undefined behavior will occur.
void printArray(int data[], int length)
{
    for(int i(0); i < length; ++i)
    {
        std::cout << data[i] << ' ';
    }
    std::cout << std::endl;
}

// Method 2: Type safe and more generic.  Works with any container that supports forward iterators.
// Limitation - cannot validate iterators so caller could pass null or invalid pointers.  Typesafe - won't
// allow you to pass inconsistent iterator types.  Allows you to pass any valid range of a container.
template <class ForwardIteratorType> 
void printArray(ForwardIteratorType begin, ForwardIteratorType end)
{
    while(begin != end)
    {
        std::cout << *begin << ' ';
        ++begin;
    }
    std::cout << std::endl;
}

// Method 3 - This implementation is as typesafe and secure as you can get but
// does not allow a subrange since the entire container is expected.  It could
// be useful if you want that extra security and know that you want to operate
// on the entire container.
template <class ContainerType> 
void printArray(const ContainerType& container)
{
    ContainerType::const_iterator current(container.begin()), end(container.end());
    for( ; 
        current != end; 
        ++current)
    {
        std::cout << *current << ' ';
    }
    std::cout << std::endl;
}

int main()
{
    // Method 1.
    const int LENGTH(6);
    int data[LENGTH] = { 5, 7, 8, 9, 1, 2 };
    printArray(data, LENGTH);

    // Method 2.
    printArray(data, data + LENGTH);
    std::vector<int> vData(data, data + LENGTH);
    printArray(vData.begin(), vData.end());
    std::list<int> lData(data, data + LENGTH);
    printArray(lData.begin(), lData.end());
    std::deque<int> dData(data, data + LENGTH);
    printArray(dData.begin(), dData.end());
    // won't compile if caller accidentally mixes iterator types.
    //printArray(dData.begin(), vData.end());

    // method 3.
    printArray(vData);
    printArray(dData);
    printArray(lData);
	return 0;
}

#include <algorithm>
#include <iostream>

// Prints out array elements. Method 2 from PART I.
template <class ForwardIteratorType> 
void printArray(ForwardIteratorType begin, ForwardIteratorType end)
{
    while(begin != end)
    {
        std::cout << *begin << ' ';
        ++begin;
    }
    std::cout << std::endl;
}

// This function is a poor design which will lead to undefined behavior when the caller
// tries to use the pointer that is returned.  data is allocated on the stack and destroyed
// after the function returns.  The pointer to the memory is returned but it is a dangling
// pointer to memory that has already been released.
{
    int data[6] = { 13, 8, 9, 10, 11, 12 };
    int* pointer = data;
    printArray(pointer, pointer + 6);
    return pointer;
}

// The *& symbol means reference to a pointer so that modification of the array 
// results in modification of lotteryNumbers back in main.  In this case the pointer
// updated back in main is valid but the caller has to remember to release the memory
// at some point.  Therefore this approach is error prone.
void generateArray(int *&array, int length)
{
    int* pointer = new int[length];
    // std::generate requires the <algorithm> header
    std::generate(pointer, pointer + length, rand);
    printArray(pointer, pointer + length);
    array = pointer;
}

int main()
{
    int* lotteryNumbers = generateArray();
    printArray(lotteryNumbers, lotteryNumbers + 6);

    const int LENGTH(6);
    generateArray(lotteryNumbers, LENGTH);
    printArray(lotteryNumbers, lotteryNumbers + 6);
    delete lotteryNumbers;
    return 0;
}

#include <vector>
#include <iostream>
#include <limits>

// Prints out array elements. Method 2 from PART I.
template <class ForwardIteratorType> 
void printArray(ForwardIteratorType begin, ForwardIteratorType end)
{
    while(begin != end)
    {
        std::cout << *begin << ' ';
        ++begin;
    }
    std::cout << std::endl;
}

// The caller must decide whether to pass an empty container.  This function will 
// add to it.  
void readScores(std::vector<int>& container)
{
    std::cout << "Type the list of scores followed by a non-numeric character and press enter when finished. " 
              << "For instance (22 25 26 f <enter> " << std::endl;
    int temp(0);
    while(std::cin >> temp)
    {
        container.push_back(temp);
    }
    // clear and discard any leftover data from the input stream.
    std::cin.clear();
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
}

int main()
{
    std::vector<int> scores; // uninitialized.  Let readScores fill it.
    readScores(scores);
    printArray(scores.begin(), scores.end());
    return 0;
}

#include <iostream>
#include <algorithm>
using namespace std;

template<class T, int N>
class SmartArray
{
      private:
      T array[N]; 
      static T foo;
      
      public:
      SmartArray(){}
      ~SmartArray(){}
      
      inline int size() const {return N;}       
      inline T * get_ptr(){return array;}      

      T& operator[](int i) 
      {
            if (i>=0 && i<N) return array[i];
         
            cerr << "out of bounds!...\n";
            return foo;
      }           
      
      const T& operator[](int i) const 
      {
            if (i>=0 && i<N) return array[i]; 
            
            cerr << "out of bounds!...\n";
            return foo;
      }
      
};

template<class T, int N>
T SmartArray<T,N>::foo;

template<class T, int N>
void read_arr(SmartArray<T,N> * arr)
{
     int i;
     for (i=0; i<N; i++)
     {
         cout << "enter element " << i+1 << ": ";
         cin >> (*arr)[i];
     }
}

template<class T, int N>
void print_arr(SmartArray<T,N> * arr)
{
     int i;
     
     cout << "{ ";
     for (i=0; i<N; i++)
     {
         cout << (*arr)[i] << ' ';
     }
     cout << '}' << endl;
}

int main()
{ 
    SmartArray<int,10> arr;
    
    read_arr(&arr);
    
    cout << "your array is:" << endl;
    print_arr(&arr);
    
    sort(arr.get_ptr(),arr.get_ptr()+arr.size());
    cout << "your sorted array is:" << endl;
    print_arr(&arr);
    
    cout << "let's try something bad..." << endl;
    arr[1000]=5;
    
    system("pause");
    return 0;
}

#include <iostream>
#include <algorithm>
using namespace std;

template<class T>
class SmartArray
{
      private:
      T * array; 
      int sz;
      static T foo;
      
      public:
      SmartArray(int s){sz=s; array=new T[sz];}
      ~SmartArray(){delete[] array;}
      
      inline int size() const {return sz;}    
      inline T * get_ptr(){return array;}   
      
      T& operator[](int i) 
      {
            if (i>=0 && i<sz) return array[i];
         
            cerr << "out of bounds!...\n";
            return foo;
      }           
      
      const T& operator[](int i) const 
      {
            if (i>=0 && i<sz) return array[i]; 
            
            cerr << "out of bounds!...\n";
            return foo;
      }
      
};

template<class T>
T SmartArray<T>::foo;

template<class T>
void read_arr(SmartArray<T> * arr)
{
     int i;
     int size=arr->size();
     for (i=0; i<size; i++)
     {
         cout << "enter element " << i+1 << ": ";
         cin >> (*arr)[i];
     }
}

template<class T>
void print_arr(SmartArray<T> * arr)
{
     int i;
     int size=arr->size();
     
     cout << "{ ";
     for (i=0; i<size; i++)
     {
         cout << (*arr)[i] << ' ';
     }
     cout << '}' << endl;
}

int main()
{ 
    SmartArray<int> arr(10);
    
    read_arr(&arr);
    
    cout << "your array is:" << endl;
    print_arr(&arr);
    
    sort(arr.get_ptr(),arr.get_ptr()+arr.size());
    cout << "your sorted array is:" << endl;
    print_arr(&arr);
    
    cout << "let's try something bad..." << endl;
    arr[1000]=5;
    
    system("pause");
    return 0;
}

#include <vector>

// Imagine that this is a legay API function within an older library.
// It requires a C-Array as an input.
void printArray(int data[], int length)
{
    for(int i(0); i < length; ++i)
    {
        std::cout << data[i] << ' ';
    }
    std::cout << std::endl;
}


int main(int argc, char* argv[]) {
    const int SIZE(20);

    // Certainly you can use printArray for a C-Array.  
    int mainCArray[SIZE];
    std::generate(mainCArray, mainCArray + SIZE, rand);
    printArray(mainCArray, SIZE);

    // The C++ std guarantees that you can also call it even if you are
    // using a std::vector!  
    std::vector<int> mainData(mainCArray, mainCArray + SIZE);
    printArray(&mainData[0], SIZE);
}