C++ template, stack, vector

template <class T>
bool Postfixe<T>::valider_expression(vector<T> & tableau)
{

  return true;
} 

template <typename T>
bool Postfixe<T>::valider_expression(const vector<T> & tableau) const
{
  std::cout << "mon vecteur est de taille " << tableau.size() << std::endl;
  return true;
} 

template <typename T>
bool Postfixe<T>::valider_expression(const vector<T> & tableau) const
{
  std::cout << "mon vecteur est de taille " << tableau.size() << std::endl;
  // Le type en italique dépend d'au moins un paramètre template (ici T) 
  // donc doit être précédé d'un typename si on veut accéder
  // à un de ses champs (ici le type "const_iterator").
  typename std::vector<T>::const_iterator
    vit (tableau.begin()),
    vend(tableau.end());
  for(;vit!=vend;++vit) std::cout << *vit << ' ';
  std::cout << std::endl;
  return true;
}

typedef typename std::vector<T>::const_iterator my_const_iterator;
my_const_iterator vit(v.begin()),vend(v.end());

#include <iostream>

void incrementer(int x){
  ++x;
  std::cout << "incrementer : " << x << std::endl;
}

void incrementer1(int & x){
  ++x;
  std::cout << "incrementer1 : " << x << std::endl;
}

void incrementer2(int *x){
  ++(*x);
  std::cout << "incrementer2 : " << x << std::endl;
}

int main(){
  int x = 0;
  incrementer(x);
  std::cout << "main : " << x << std::endl;
  incrementer1(x);
  std::cout << "main : " << x << std::endl;
  incrementer2(&x);
  std::cout << "main : " << x << std::endl;
  return 0;
}

incrementer : 1
main : 0
incrementer1 : 1
main : 1
incrementer2 : 2
main : 2

#include <iostream>

// Début de postfixe.hpp
#include <vector>
#include <stack>

template <typename T>
class postfixe
{
    public:
        typedef std::stack<T> pile_t;
        typedef std::vector<T> tableau_t;
    protected:
        pile_t pile;
        tableau_t tableau;
    public:
        postfixe(const tableau_t & tableau0):
            tableau(tableau0) // recopie tableau0 dans l'attribut tableau
        {}

        bool valider_expression() const { // const car a priori on ne modifie ni pile, ni tableau
            std::cerr << "valider_expression: not yet implemented" << std::endl;
            return false;
        }

        void transformer_en_nombres() { // pas const car on modifie pile ou tableau
            std::cerr << "transformer_en_nombres: not yet implemented" << std::endl;
        }

        void transformer_en_postfixe() { // pas const car on modifie pile ou tableau
            std::cerr << "transformer_en_postfixe: not yet implemented" << std::endl;
        }

        int evaluer_expression() const { // const car a priori on ne modifie ni pile, ni tableau
            std::cerr << "evaluer_expression: not yet implemented" << std::endl;
            return 0;
        }
};
// Fin de postfixe.hpp

int main(){
    postfixe<int>::tableau_t tableau0;
    postfixe<int> p(tableau0);
    p.valider_expression();
    p.transformer_en_nombres();
    p.transformer_en_postfixe();
    p.evaluer_expression();
    return 0;
}

#include <iostream>
#include <string>
#include <vector>

int main(){
    std::string operation;
    std::cout << "opération ? ";
    std::cin >> operation;
    std::size_t len = operation.size();
    std::vector<char> tableau0;
    tableau0.reserve(len);
    for(std::size_t i=0;i<len;++i) tableau0.push_back(operation[i]);
    //...
    return 0;
}

std::vector<int> v(50,0);

#include <vector>
#include <iostream>
#include <algorithm> // std::fill

template <typename T>
void write_vector(
    const std::vector<T> & v,
    std::ostream & out = std::cout
){
    const std::size_t n = v.size();
    out << '[';
    for(std::size_t i=0;i<n;++i){
        out << ' ' << v[i];
    }
    out << " ]" << std::endl;
}

int main(){
    std::vector<int> v0(10); // les 10 entiers sont initialisés avec l'entier par défaut (0)
    write_vector(v0);
    std::vector<int> v(10,1); // les 10 entiers sont initialisés à 1
    write_vector(v);
    std::fill(v.begin(),v.end(),2);
    write_vector(v);
    return 0;
}

[ 0 0 0 0 0 0 0 0 0 0 ]
[ 1 1 1 1 1 1 1 1 1 1 ]
[ 2 2 2 2 2 2 2 2 2 2 ]

#include <iostream>

void swap(float *p1,float *p2){
/*
  // je ne sais pas ce que tu as voulu faire ici mais ça n'a pas de sens
  // la variable p2 est passée en paramètre et est masquée par une variable locale p2
  // la boucle while peut tourner à l'infini (du moins jusqu'à faire une seg fault
  while(*p1<*p2) p1++;
  float *p2=p1;
*/
}

int main( ){
  float a,b,c;
  std::cout<<"xxxxxxxxxxx";
  std::cin >> a >> b >> c;
  swap(&a,&b);
  swap(&a,&c);
  swap(&b,&c);
  std::cout << "xxxxxxxxxxxxxxx";
  std::cout << a << ' ' << b << ' ' << c << std::endl;
  return 0; // code d'exécution du programme
}