The Big Programming Thread - Page 480

template<class T>
T avg(vector<T> const& v){ 
	static_assert(std::is_default_constructible<T>::value,"default constructibleness lacking");
	auto size=v.size();
	assert(size>0);
	return std::accumulate(std::begin(v),std::end(v),T())/size; 
}

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

template<class T>
class Stack
{
     public:
          T GetSum();
          T GetMean();
          T GetMedian();
          void AddElement(T const&);
          void Display();

     private:
          std::vector<T> elements;
};

template<class T>
void Stack<T>::AddElement(T const& element)
{
     elements.push_back(element);
}

template<class T>
void Stack<T>::Display()
{
     std::copy(elements.begin(), elements.end(), std::ostream_iterator<T>(std::cout));
     std::cout << std::endl;
}

template<class T>
T Stack<T>::GetSum()
{
    return std::accumulate(std::begin(elements), std::end(elements), T());
}

template<class T>
T Stack<T>::GetMean()
{
    T size = elements.size();
    T sum = GetSum();

    return sum / size;
}

template<class T>
T Stack<T>::GetMedian()
{
    T size = elements.size();
    T num = size / 2;

    std::nth_element(elements.begin(), elements.begin() + num, elements.end());
    
    return elements[num];
}

int main()
{
    // create stacks
    Stack<double> doubleStack;
    Stack<float>  floatStack;
    Stack<int>    intStack;

    // populate stacks
    doubleStack.AddElement(7.1);
    doubleStack.AddElement(1.3);
    doubleStack.AddElement(3.8);
    doubleStack.AddElement(8.7);

    floatStack.AddElement(7.138);
    floatStack.AddElement(1.387);
    floatStack.AddElement(3.871);
    floatStack.AddElement(8.713);

    intStack.AddElement(7);
    intStack.AddElement(1);
    intStack.AddElement(3);
    intStack.AddElement(8);

    // display data
    std::cout << "Stack of doubles: " << std::endl;
    std::cout << doubleStack.Display();
    std::cout << "Doubles mean: " << doubleStack.GetMean() << std::endl;
    std::cout << "Doubles median: " << doubleStack.GetMedian() << std::endl;

    std::cout << "Stack of floats: " << std::endl;
    std::cout << floatStack.Display();
    std::cout << "Floats mean: " << floatStack.GetMean() << std::endl;
    std::cout << "Floats median: " << floatStack.GetMedian() << std::endl;

    std::cout << "Stack of ints: " << std::endl;
    std::cout << intStack.Display();
    std::cout << "Ints mean: " << intStack.GetMean() << std::endl;
    std::cout << "Ints median: " << intStack.GetMedian() << std::endl;

    return 0;
}

intStack.Display();

std::cout<<intStack.Display();

public DownloadInfo getDownloadInfo(String title)
	{
		for(DownloadInfo info : downloadList)
		{
			if (info.getTitle().equals(title))
			{
				return info;
			}
		}
		return null;
	}

DownloadInfo temp = music.getDownloadInfo("Pompeii");
		if((temp.getTitle()) == null) //returns false, moves on to else as it should(Pompeii is in the musicList)
			System.out.println(temp.getTitle() + " was never downloaded");
		else
			System.out.println(temp.getTitle() + " was downloaded " + temp.getTimesDownloaded() + " times");
		
		DownloadInfo temp2 = music.getDownloadInfo("Jingle Bells");
		if((temp2.getTitle()) == null) //returns a Null Pointer Exception due to not being in the list.
			System.out.println(temp2.getTitle() + " was never downloaded");
		else
			System.out.println(temp2.getTitle() + " was downloaded " + temp2.getTimesDownloaded() + " times");

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

template<class T>
class Stack
{
     public:
          T GetSum();
          T GetMean();
          T GetMedian();
          void AddElement(T const&);
          void Display();

     private:
          std::vector<T> elements;
};

.... code removed....

#include <algorithm>
#include <iterator>
#include <array>


template<typename T, std::size_t size>
class math_array
{
public:
	typedef T* iterator;
	typedef const T* const_iterator;
	
	typedef std::reverse_iterator<T*> reverse_iterator;
	typedef std::reverse_iterator<const T*> const_reverse_iterator;

	iterator begin()	{	return &data[0];	 }
	iterator end() 	{	return &data[size]; }
	
	const_iterator begin() const	{	return &data[0];	 }
	const_iterator end() const 	{	return &data[size]; }

	reverse_iterator rbegin()	{	return reverse_iterator(end());	 }
	reverse_iterator rend() 	{	return reverse_iterator(begin()); }

	const_reverse_iterator rbegin() const	{	return reverse_iterator(end());	 }
	const_reverse_iterator rend() const 	{	return reverse_iterator(begin()); }

	T& operator[] (std::size_t index)
	{
		return data[index];
	}
	T const& operator[] (std::size_t index) const
	{
		return data[index];
	}

	template<class FuncT>
	void for_each(FuncT func)
	{
		std::for_each(begin(),end(), func);
	}

	T average(T const& i = 0)
	{ 
		auto size=v.size();
		assert(size>0);
		return std::accumulate(std::begin(v),std::end(v),i)/size; 
	}
	/// rest of your math functions already provided...

	T data[size];
};

	math_array<int,10> f = {3,4,5,56,234,23,4234,234,23423,4234};

	f.for_each([](int n)
	{
		std::cout << n << std::endl;
	});

T average(T const& i = 0) {...}

System.out.Println(songTitle + " was not downloaded!")

String songTitle = "Pompeii";
...
songTitle = "Jingle Bells";
...