[C++]

#include <vector>
#include <iostream>

int main(){
    std::vector<int> v;
    v.push_back(1);
    v.push_back(6);
    v.push_back(4);
    v.push_back(5);
    v.push_back(1);
    std::vector<int>::const_iterator vit(v.begin()),vend(v.end());
    for(;vit!=vend;++vit) std::cout << *vit << ' ';
    std::cout << std::endl;
    return 0;
}

(mando@aldur) (~) $ g++ -W -Wall plop.cpp
(mando@aldur) (~) $ ./a.out
1 6 4 5 1

typedef class objet objet;

template <typename T>
class my_vector{
  protected:
  T * datas;
  public:
  typedef const T * const_iterator;
  typedef const T * iterator;

  my_vector(){}
  //...
};

template <typename T>
void write(std::vector<T> & v){
  typename std::vector<T>::const_iterator
    vit(v.begin()),vend(v.end());
  for(;vit!=vend;++vit) std::cout << *vit << ' ';
  std::cout << std::endl;
}

template <typename Tstream,typename T>
Tstream & operator<<(Tstream & out,const std::vector<T> & v){
  typename std::vector<T>::const_iterator
    vit(v.begin()),vend(v.end());
  for(;vit!=vend;++vit) out << *vit << ' ';
  out << std::endl;
  return out;
}

#include <iostream>
#include <vector>


struct plop_t{
    char x;
    float y;
    plop_t(){}
    plop_t(char x0,float y0):x(x0),y(y0){}

};

std::ostream & operator<<(std::ostream & out,const plop_t & p) {
    out << '[' << p.x << ',' << p.y << ']';
    return out;
}

class plops_t{
    protected:
        std::vector<plop_t> datas;
    public:
        plops_t(){}

        inline void add(const plop_t & p){
            datas.push_back(p);
        }

        inline void write() const{
            std::vector<plop_t>::const_iterator
                vit (datas.begin()),
                vend(datas.end());
            for(;vit!=vend;++vit) std::cout << *vit << ' ';
            std::cout << std::endl;
        }
};

int main(){
    plop_t plop1('x',69);
    plop_t plop2('y',70);
    plops_t plops;
    plops.add(plop1);
    plops.add(plop2);
    plops.write();
    return 0;
}

(mando@aldur) (~) $ g++ -W -Wall plop.cpp
(mando@aldur) (~) $ ./a.out
[x,69] [y,70]

#include <iostream>

//-----

template <typename T>
class my_pair{
    public:
        T first;
        T second;
        my_pair(){}

        inline my_pair<T> & operator=(const my_pair<T> & src){
            this->first = src.first;
            this->second = src.second;
            return *this;
        }

};

template <typename T>
my_pair<T> my_make_pair(const T & x0,const T & y0){
    my_pair<T> p;
    p.first = x0;
    p.second = y0;
    return p;
}

// Les operateurs peuvent êtres écrits dans ou hors de la classe

template <typename Tstream,typename T>
Tstream & operator << (Tstream & out,const my_pair<T> & p){
    out << '(' << p.first << ',' << p.second << ')';
    return out;
}

//-----

struct plop_t{
    char x;
    float y;
    plop_t(){}
    plop_t(char x0,float y0):x(x0),y(y0){}

    inline plop_t & operator=(plop_t src){
        x = src.x; // on peut sous entendre le this->
        y = src.y;
    }
};

inline std::ostream & operator<<(std::ostream & out,const plop_t & p) {
    out << '[' << p.x << ',' << p.y << ']';
    return out;
}

//-----

int main(){
    plop_t p1('x',69);
    plop_t p2('y',60);
    my_pair<plop_t> p_plop = my_make_pair(p1,p2);
    p_plop.first = plop_t('z',63);
    std::cout << p_plop << std::endl;
    return 0;
}

(mando@aldur) (~) $ g++ -W -Wall plop.cpp
(mando@aldur) (~) $ ./a.out
([z,63],[y,60])

#ifndef H_VECTEUR
#define H_VECTEUR

#include <cmath>

class Vecteur
{
	private:
		double x, y;
		
	public:
		//constructeur
		Vecteur();
		//constructeur par recopie
		Vecteur(const Vecteur &);
		//destructeur
		~Vecteur();

		void set(double, double);
		void setX(double x);
		void setY(double y);
		void normalise();

		void setNormalise(double, double);

		double getX();
		double getY();
};
#endif

#include "vecteur.h"

Vecteur::Vecteur()
{
	x = 0;
	y = 0;
}

Vecteur::Vecteur(const Vecteur &v)
{ 
x=v.x;
y=v.y;
}

Vecteur::~Vecteur()
{
}

void Vecteur::set(double x1, double y1)
{
	x = x1;
	y = y1;
}

void Vecteur::setX(double x1)
{
	x = x1;
}

void Vecteur::setY(double y1)
{
	y = y1;
}

double Vecteur::getX()
{
	return x;
}

double Vecteur::getY()
{
	return y;
}

void Vecteur::normalise()
{
	double n = x*x + y*y;
	n = sqrt(n);
	x /= n;
	y /= n;
}

void Vecteur::setNormalise(double x1, double x2)
{
	x = x1;
	x = x2;
	normalise();
}

#include "define.h"
#include "objet.h"

Objet::Objet()
{
	pos.set(0,0);
	vitdir.set(0,0);
	taille.set(0,0);
}

Objet::Objet(const Objet &o)
{
	pos=o.pos;
	vitdir=o.vitdir;
	taille=o.taille;
}

Objet::~Objet()
{
}

void Objet::SetPos(double x, double y)
{

	pos.setX(x);
	pos.setY(y);

}

void Objet::SetDir(double x,double y)
{

	vitdir.setX(x);
	vitdir.setY(y);
	
}

void Objet::SetTaille(double x, double y)
{

	taille.setX(x);
	taille.setY(y);

}

void Objet::SetVit(double x,double y)
{

}

double Objet::GetX()
{
	return pos.getX();
}

double Objet::GetY()
{
	return pos.getY();
}

double Objet::GetVX()
{
	return vitdir.getX();
}

double Objet::GetVY()
{
	return vitdir.getY();
}

double Objet::GetW()
{
	return taille.getX();
}

double Objet::GetH()
{
	return taille.getY();
}

void Objet::UpdatePosObjet()
{
	  //Test collision
	  if((GetX()<=0)||(GetX()+GetW()>=LARGEUR))
		{
		SetDir(-GetVX(),GetVY());
		}
	 if((GetY()<=0)||(GetY()+GetH()>=HAUTEUR))
		{
		SetDir(GetVX(),-GetVY());
		}
	pos.setX(pos.getX()+vitdir.getX());
	pos.setY(pos.getY()+vitdir.getY());
}

void Objet::Affiche()
{
	glClear(GL_COLOR_BUFFER_BIT);

    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity( );
	
    //dessin carré
	glBegin(GL_QUADS);
            glColor3ub(255,0,0);    glVertex2d(GetX(),GetY());
            glColor3ub(255,0,0);    glVertex2d(GetX()+GetW(),GetY());
            glColor3ub(0,0,255);    glVertex2d(GetX()+GetW(),GetY()+GetH());
			glColor3ub(0,0,255);    glVertex2d(GetX(),GetY()+GetH());
    glEnd();
	
	glFlush();
    SDL_GL_SwapBuffers();
}

#ifndef H_OBJET
#define H_OBJET
#include "vecteur.h"
#include <windows.h>
#include <SDL/SDL.h>
#include <GL/gl.h>
#include <GL/glu.h>
class Objet
{
private:
	Vecteur pos, vitdir,taille;
	
public:
	//constructeur
	Objet();
	//constructeur par recopie
	Objet(const Objet & o); 
	//destructeur
	~Objet();
	//Prendre position objet
	void SetPos(double,double);
	//Prendre direction objet
	void SetDir(double,double);
	//Prendre taille
	void SetTaille(double,double);
	//Prendre vitesse
	void SetVit(double,double);
	//donner position
	double GetX();
	double GetY();
	//donner direction
	double GetVX();
	double GetVY();
	//donner taille
	double GetW();//W pour largeur
	double GetH();//H pour hauteur

	//mise à jour position objet
	void UpdatePosObjet();
	//Affichage objet
	void Affiche();

};


#endif

Objet::Objet(const Objet &o)
{
	pos=o.pos;
	vitdir=o.vitdir;
	taille=o.taille;
}

#include <iostream>

class my_vector{
    public:
        typedef char x_t;
        typedef int y_t;
    protected:
        x_t x;
        y_t y;
    public:
        my_vector(char x0,int y0):x(x0),y(y0){}

        inline const x_t & get_x() const{return x;}
        inline const y_t & get_y() const{return y;}

        inline my_vector & operator=(const my_vector & src){
            x = src.get_x();
            y = src.get_y();
            return *this;
        }
};

inline std::ostream & operator<<(std::ostream & out,const my_vector & v){
    out << "[x=" << v.get_x() << ",y=" << v.get_y() << ']';
    return out;
}

int main(){
    my_vector v1('a',37),v2('b',55);
    std::cout << "v1 = " << v1 << "\tv2 = " << v2 << std::endl;
    v2 = v1;
    std::cout << "v1 = " << v1 << "\tv2 = " << v2 << std::endl;
    return 0;
}

(mando@aldur) (~) $ g++ -W -Wall plop.cpp
(mando@aldur) (~) $ ./a.out
v1 = [x=a,y=37] v2 = [x=b,y=55]
v1 = [x=a,y=37] v2 = [x=a,y=37]

jeu.obj : error LNK2019: symbole externe non résolu __imp___CrtDbgReportW référencé dans la fonction "public: __thiscall std::_Vector_const_iterator<class Objet,class std::allocator<class Objet> >::_Vector_const_iterator<class Objet,class std::allocator<class Objet> >(class Objet *,class std::_Container_base const *)" (??0?$_Vector_const_iterator@VObjet@@V?$allocator@VObjet@@@std@@@std@@QAE@PAVObjet@@PBV_Container_base@1@@Z)
D:\Programmation\Prog SDL\Testopengl\Debug\Testopengl.exe : fatal error LNK1120: 1 externes non résolus

objets.clear();

std::vector<Objet > objets;

#include <vector>

class plop_t{
    protected:
        int x;
        char a;
    public:
        plop_t(){}
        ~plop_t(){}
        plop_t(int x0,char a0):x(x0),a(a0){}
};

int main(){
    std::vector<plop_t> x;
    x.push_back(plop_t(1,'a'));
    x.push_back(plop_t(2,'b'));
    x.push_back(plop_t(4,'f'));
    x.push_back(plop_t(3,'d'));
    x.clear();
    return 0;
}

class plop_t{
    protected:
        int x;
        char a;
    public:
        plop_t(){}
        ~plop_t(){}
        plop_t(int x0,char a0):x(x0),a(a0){}
        inline int get_x() const{return x;}
        inline char get_a() const{return a;}
};