En fait il y a deux points sur lesquels tu dois réfléchir
- comment générer une valeur aléatoire
- comment stocker ton tableau
Il y a plusieurs façons de faire, tout dépend si tu stockes l'information
- dans un tableau 2d (vecteur de vecteur (classe std::vector), dont les cases vides seront initialisées avec une valeur par défaut) . Pour cette solution chaque case est identifiée par une paire d'entiers positifs (std::size_t)
- ou matrice creuse (map de map (classe std::map), seule les cases remplies sont stockées en mémoire). Pour accéder à une case tu peux utiliser une paire générique de clé (par exemple un entier relatif et un char).
Dans notre cas on va par exemple utiliser des vecteurs de vecteurs de char.
Ci dessous une façon de faire :
#include <vector>
#include <iostream>
#include <cstdlib>
template <typename T>
class tableau2d{
protected:
std::size_t size1;
std::size_t size2;
std::vector<std::vector<T> > data;
public:
tableau2d(
const std::size_t & size10 = 0,
const std::size_t & size20 = 0,
const T & default_value = T()
):
size1(size10),
size2(size20),
data(size10,std::vector<T>(size20,default_value))
{}
inline const std::size_t & nb_row() const{
return size1;
}
inline const std::size_t & nb_col() const{
return size2;
}
inline T & get(const std::size_t & col,const std::size_t & row){
if(col >= nb_row()) throw;
if(row >= nb_col()) throw;
return data[col][row];
}
inline const T & get(const std::size_t & col,const std::size_t & row) const{
if(col >= nb_row()) throw;
if(row >= nb_col()) throw;
return data[col][row];
}
inline void set(const std::size_t & col,const std::size_t & row,const T & val){
if(col >= nb_row()) throw;
if(row >= nb_col()) throw;
data[col][row] = val;
}
};
template <typename T>
inline std::ostream & operator << (std::ostream & out,const tableau2d<T> & x){
const std::size_t &
nb_row = x.nb_row(),
nb_col = x.nb_col();
for(std::size_t i=0;i<nb_row;++i){
for(std::size_t j=0;j<nb_col;++j){
out << x.get(i,j) << '\t';
}
out << std::endl;
}
return out;
}
template <typename T>
T rand(
const T & min = std::numeric_limits<T>::min(),
const T & max = std::numeric_limits<T>::max()
){
if(min > max) throw;
return min + ((max - min + 1) * (rand() / (RAND_MAX + 1.0)));
}
template <typename T>
void random_init(
tableau2d<T> & x,
const T & min = std::numeric_limits<T>::min(),
const T & max = std::numeric_limits<T>::max()
){
if(min > max) throw;
const std::size_t &
nb_row = x.nb_row(),
nb_col = x.nb_col();
for(std::size_t i=0;i<nb_row;++i){
for(std::size_t j=0;j<nb_col;++j){
x.set(i,j,rand<T>(min,max));
}
}
}
int main(){
tableau2d<char> tab(5,7,'x');
std::cout << tab << std::endl;
random_init(tab,'a','z');
std::cout << tab << std::endl;
// getchar(); // sous windows decommente cette instruction
return 0;
}
qui donne à l'exécution :
x x x x x x x
x x x x x x x
x x x x x x x
x x x x x x x
x x x x x x x
v k u u x f i
t h o m q j n
y x q s d p a
g d u e k d c
z f n v p h q
Les templates permettent par la même occasion de passer très facilement d'une matrice de char à une matrice de float ou d'int, il suffit de corriger le main (cf type en gras) et les bornes du random (ici 'a' et 'z'), et la valeur initiale (ici 'x')
Bonne chance
Afficher tableau 2d c
