#include <vector>
#include <iostream>
#include <stdexcept>
using namespace std;

class Remplisseur
{
public:
    Remplisseur(vector<int>& vec,unsigned int pos)
            : m_ref(vec)  //On initalise la reference
    {
        m_position = pos;    //Et on enregistre la position
    }

    Remplisseur operator,(int x)     //On prend l'entier après la virgule
    {
        m_ref.at(m_position)=x;                 //On le met à la position qu'il faut dans le Tableau
        return Remplisseur(m_ref,m_position+1); //Et on cree un nouveau Remplisseur qui s'occupera de la case suivante
    }

    ~Remplisseur()
    {
        if (m_position==1)
        {
            m_ref.assign(m_ref.size(),m_ref.at(0));
            m_position=0;
        }
        else if(m_position!=m_ref.size())
        {            
            m_position=0;
            throw std::out_of_range("Tableau:: Too much or not enough arguments after comma");
        }
    }

private:
    vector<int>& m_ref;
    static size_t m_position;
};

size_t Remplisseur::m_position=0;

class Tableau: public vector<int>
{
public:
    Tableau(unsigned int i=0)    //Construit un tableau de longueur i
            :vector<int>(i,0)
    {}

    Remplisseur operator=(int x)  //On prend le premier entier après la virgule
    {
        at(0) = x;                //On le met dans la premiere case
        return Remplisseur(*this,1);  //Et on initialise un remplisseur a partir de la deuxieme case
    }

};

ostream& operator<<(ostream& flux,const Tableau& tab)  //Affiche le contenu du tableau
{
    if (!tab.empty())
    {
        for (unsigned int i(0);i<tab.size()-1;++i)
            flux << tab[i] << ",";          //On separe les elements par des virgules
        flux << tab[tab.size()-1];
    }
    return flux;
}

int main()
{
    Tableau tab(10);

    tab=0,1,2,3,4,5,6,7,8,9;

    cout << tab << endl;

    return 0;
}

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

template<typename T>
class Remplisseur
{
public:
    Remplisseur(vector<T>& vec,unsigned int pos)  //Initialise juste les attributs
            : ref(vec)
    {
        m_pos = pos;
    }

    Remplisseur operator,(const T& x)     //On prend l'entier après la virgule
    {
        ref.at(m_pos)=x;               //On le met à la position qu'il faut dans le Tableau
        return Remplisseur(ref,m_pos+1); //Et on cree un nouveau Remplisseur qui s'occupera de la case suivante
    }

    ~Remplisseur()
    {
        if (m_pos==1)
        {
            ref.assign(ref.size(),ref.at(0));
            m_pos=0;
        }
        else if(m_position!=m_ref.size())
        {
            m_position=0;
            throw std::out_of_range("Tableau:: Too much or not enough arguments after comma");
        }

    }

private:
    vector<T>& ref;
    static size_t m_pos;
};

template<typename T>
size_t Remplisseur<T>::m_pos=0;

template<typename T>
class Tableau: public vector<T>
{
public:
    Tableau(unsigned int i=0)    //Construit un tableau de longueur i
            :vector<T>(i)
    {}

    Remplisseur<T> operator=(int x)  //On prend le premier entier après la virgule
    {
        vector<T>::at(0) = x;            //On le met dans la premiere case
        return Remplisseur<T>(*this,1);  //Et on initialise un remplisseur a partir de la deuxieme case
    }

};

template<typename T>
ostream& operator<<(ostream& flux,const Tableau<T>& tab)  //Affiche le contenu du tableau
{
    if (!tab.empty())  //Si il est non-vide
    {
        for (unsigned int i(0);i<tab.size()-1;++i)
            flux << tab[i] << ",";          //On separe les elements par des virgules
        flux << tab[tab.size()-1];
    }
    return flux;
}


int main()
{
    Tableau<int> tab(10);

    tab=2;

    cout << tab << endl;

    return 0;
}

#include <vector>
template <typename Container>
struct ComaInserter
{
    typedef typename Container::value_type value_type;

    ComaInserter(Container & container) : m_container(container) {}

    ComaInserter const& operator,(value_type const& v) const {
	m_container . push_back(v);
	return *this;
    }
private:
    Container & m_container;
};

template <typename Container>
ComaInserter<Container> operator+=(Container & container, typename Container::value_type const& v)
{
    return ComaInserter<Container>(container), v;
}

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

int main (int argc, char **argv)
{
    std::vector <int> v;
    v += 1, 2, 45;

    std::copy(v.begin(),v.end(), std::ostream_iterator<int>(std::cout, ", "));
}