C++ , les template vs vector

Programmation
#1

Hello

J’essaye de me bricoler, du moins pour le début quelque chose de fonctionnelle hum .
en bref :

le but est que l’utilisateur puisse dans le main avoir une méthode simple

maclasse objtableau;
objtableau(0,1,"string"); //tableau a plusieur dimention 0 = tableaux contenant d'autre tableaux, 1 index du tableaux, valeur

j’ai donc fait une classe template (le terme est juste?)
fichier cTableaux.tpp

#ifndef DEF_TEMPLATE_TABLEAU
#define DEF_TEMPLATE_TABLEAU
#include <iostream>
#include <vector>

template <typename T1> class Tableaux
{
public:
    //Paire();

    void affiche(T1 v);
    void setData(T1 v,T1 v2,std::string Dt);
    //{ std::cout << "Dépassement d'indice sur un tableau : " << "\n"; }
private :
    std::vector<T1> NV1;//ok
    std::vector < std::vector < T1 > > NV2;
};
template <class T1>
void Tableaux<T1>::affiche (T1 v)
{
   std::cout << "Info: " << v <<  "\n";
}

template <class T1>
void Tableaux<T1>::setData (T1 v,T1 v2,std::string Dt)
{
    NV2.push_back(NV1);
    NV2.push_back(NV1);
	NV2[v].push_back("dt"); //problème v ne doit pas être de type std::string, mai dt si , comment faire ??
    std::cout << "Info: " << v << Dt <<  "\n";
}
#endif

main

#include <iostream>
//#include "cTableaux.hpp"
#include "cTableaux.tpp"
using namespace std;
//typedef Pile<int> PileInt;

int main()
{
int  V=1;
int V2=1;
std::string Str="me";
Tableaux<std::string> B;
B.affiche(Str);
B.setData(Str,Str,Str);// évidament sa coince
return 0;
}

évidement avec les int sa passe sans problème (mettre en commentaire la ligne NV2[v].push_back(“dt”):wink:

int V=1;
int V2=1;
std::string Str="me";
Tableaux<int> B;
B.affiche(V);
B.setData(V,V2,Str);

Je débute avec les templates donc un petit exemple avec la syntax est un plus :confused:

Merci d’avance

#2

Le problème que tu as n’a rien à voir avec les templates. Donc avant de faire un template il faut savoir ce que tu veux faire précisément.

std::vector : un tableau contenant des entiers (et dont les index sont forcément des size_t çàd des entiers, y’a pas le choix c’est comme ça que fonctionne std::vector)
std::vectorstd::string : un tableau contenant des chaînes (même remarque pour les index)
std::vector< std::vectorstd::string > : un tableau contenant des tableaux de chaînes (autrement dit, un tableau à deux dimensions contenant des chaînes, les index restent toujours des entiers)

Qu’est-ce que tu veux faire exactement ? Si c’est, comme j’en ai l’impression, pouvoir utiliser des “index” du type que tu as choisi, std::vector n’est pas le bon choix il te faudrait plutôt une hashtable (conteneurs associatifs de type std::map, voire std::unordered_map si tu utilises du C++11 ou le TR1 C++0x).

#3

J’ai pas compris ton explication, tu parle d’utiliser une map pour pouvoir utiliser un int comme clef ?

@panthere > Je ne comprends pas trop ta classe. Le paramètre de généricité concerne le type contenu pas le type des indices :

[code]#ifndef DEF_TEMPLATE_TABLEAU
#define DEF_TEMPLATE_TABLEAU
#include
#include

template class Tableaux
{
public:
//Paire();

void affiche(size_t v);
void setData(size_t v,size_t v2, T1 Dt);
//{ std::cout << "Dépassement d'indice sur un tableau : " << "\n"; }

private :
// std::vector NV1;//ok // À quoi ça sert ?
std::vector < std::vector < T1 > > NV2;
};
template
void Tableaux::affiche (size_t v)
{
std::cout << "Info: " << v << “\n”;
}

template
void Tableaux::setData (size_t v, size_t v2, T1 Dt)
{
NV2.at(v).at(v1) = Dt;
// Je crois que ça marche aussi bien avec at et autant utiliser at si tu veut renvoyer une erreur en cas de dépassement de tableau

std::cout << "Info: " << v << Dt <<  "\n";

}
#endif[/code]

D’un point de vu API, j’aime beaucoup ce que propose eigen, qui remplace ça :

maclasse objtableau; objtableau.setData(0,1,"string"); //tableau a plusieur dimention 0 = tableaux contenant d'autre tableaux, 1 index du tableaux, valeur
Par ça :

maclasse objtableau; objtableau(0,1) = "string"; //tableau a plusieur dimention 0 = tableaux contenant d'autre tableaux, 1 index du tableaux, valeur

Je trouve que c’est élégant. Pour le faire il faut regarder du coté des functors (redéfinition de opérateur () ).

#4

J’ai pas compris ton explication, tu parle d’utiliser une map pour pouvoir utiliser un int comme clef ?

@panthere > Je ne comprends pas trop ta classe.[/quote]
Non justement, j’ai bien l’impression qu’il veut pouvoir utiliser des string comme index (ou autres, en fait un typename paramétré par le template), cf. son premier exemple d’utilisation avec B.setData(Str,Str,Str);
Cela dit moi non plus je ne comprends pas trop ni sa classe ni ses explications. D’où le fait que je demande avant tout des précisions même si je me hasarde à deviner son intention avec std::map. :wink:

#5

Merci pour vos réponse,
désoler pour la réponse tardive mai un peux crever a cause du boulôt. :015

En fait je cherche a en faire un conteneur, pas vraiment avec une clef. car std::map serai alors la solution.
le souci est le nombre de tableaux autrement dit une matrice, oui mai non c’est pas une matrice… :017

le but est qu’on puisse rechercher dans le contenu d’un tableau, quelque soit son type de contenu.
je résume:

1.- Un tableaux qui contien X tableau ,ceci permet donc d’avoir plusieur dimention a shouait 1 a N.
2.- le type de donnée peut être n’importe quoi. d’ou l’interet des templates.
3.- instance via un classe c’est quand meme plus pratique:)

Le problème
c’est que le(s) tableau(s) de type vector doive être du même type , écrire une fonction/methode pour chaque type c’est possible mai les template son en principe souvent citer comme solution.

comme on utilise pas une clef, on utilise donc une boucle ,de type int,long,double etc pour rechercher,lister simplement les élément.

dans le main.cpp sa donnerai en très gros,

cMeTab ObjTab(Nombre_de_tableau,type_de_donnée); ObjTab.insert(tableaux_4,type_char);

Merci de m’avoir lu

#6

Ok bon j’avais compris de travers. Mais c’est toujours pas clair…

Tu veux un tableau multidimensionnel (nombre arbitraire de dimensions) et si oui tu veux pouvoir choisir le nombre de dimensions uniquement à la compilation ou bien aussi à l’exécution ?
Ou bien tu veux juste un tableau bidimensionnel, auquel cas ton utilisation du mot “dimension” n’est pas correct dans ta phrase ?

#7

[quote=“syam”]Ok bon j’avais compris de travers. Mais c’est toujours pas clair…

Tu veux un tableau multidimensionnel (nombre arbitraire de dimensions) et si oui tu veux pouvoir choisir le nombre de dimensions uniquement à la compilation ou bien aussi à l’exécution ?
Ou bien tu veux juste un tableau bidimensionnel, auquel cas ton utilisation du mot “dimension” n’est pas correct dans ta phrase ?[/quote]

1.- Oui pour :frowning:nombre arbitraire de dimensions
2.-le tableaux est dynamique, on ne connais pas sa taille, c’est dire le nombre d’élément a contenir, sa concerne donc je pense l’exécution principalement. :question:

c’est pas le fait de comprendre qui est dure, c’est plutôt d’être claire dans ce qu’on veux expliquer ,alors forcement l’idée est la mai pour l’écrire :doh: :smiley:

#8

[quote=“panthere”]1.- Oui pour :frowning:nombre arbitraire de dimensions
2.-le tableaux est dynamique, on ne connais pas sa taille, c’est dire le nombre d’élément a contenir, sa concerne donc je pense l’exécution principalement. :question:[/quote]
La taille n’a rien à voir avec le nombre de dimensions, je partais bien du principe que la taille est variable à l’exécution. La question était est-ce que le nombre de dimensions (à ne pas confondre avec “les dimensions”) est connu à la compilation ou uniquement à l’exécution ? La différence entre les deux, c’est que le nombre de dimensions détermine le type si tu veux imbriquer des std::vector les uns dans les autres, donc c’est beaucoup plus compliqué de changer ce nombre de dimensions à l’exécution.

Et un petit dessin pour aller avec, histoire d’être certain qu’on parle bien de la même chose :

#9

[quote=“syam”][quote=“panthere”]1.- Oui pour :frowning:nombre arbitraire de dimensions
2.-le tableaux est dynamique, on ne connais pas sa taille, c’est dire le nombre d’élément a contenir, sa concerne donc je pense l’exécution principalement. :question:[/quote]
La taille n’a rien à voir avec le nombre de dimensions, je partais bien du principe que la taille est variable à l’exécution. La question était est-ce que le nombre de dimensions (à ne pas confondre avec “les dimensions”) est connu à la compilation ou uniquement à l’exécution ? La différence entre les deux, c’est que le nombre de dimensions détermine le type si tu veux imbriquer des std::vector les uns dans les autres, donc c’est beaucoup plus compliqué de changer ce nombre de dimensions à l’exécution.

Et un petit dessin pour aller avec, histoire d’être certain qu’on parle bien de la même chose :
[/quote]

On parle bien de la même chose, on parle bien de la 3eme image 3x4x2 .
Le bute des vector c est bien être redimentinonable, et pas a taille fixe. donc si a l’exécution sa passe a 4x4x2
sa ne devrai pas déranger sinon un simple tableau[] suffirait :slightly_smiling:

#10

Désolé d’être chiant, mais tu n’as toujours pas répondu clairement à la question : est-ce que le nombre de dimensions est fixe et/ou connu à la compilation, ou bien est-ce qu’il varie à l’exécution ?
Si j’insiste autant là-dessus c’est parce que le premier cas est relativement “simple” à traiter, le deuxième l’est beaucoup moins !

#11

[quote=“syam”]Désolé d’être chiant, mais tu n’as toujours pas répondu clairement à la question : est-ce que le nombre de dimensions est fixe et/ou connu à la compilation, ou bien est-ce qu’il varie à l’exécution ?
Si j’insiste autant là-dessus c’est parce que le premier cas est relativement “simple” à traiter, le deuxième l’est beaucoup moins ![/quote]
il varie a l’exécution

#12

aurait-je oublier quelque chose :confused: :question: :think:

#13

Non c’est juste que pour le moment j’ai pas trouvé de solution “évidente” pour faire varier le nombre de dimensions à l’exécution, et je n’ai pas pris le temps de chercher sur internet s’il existe une solution toute faite.
Le problème c’est que pour faire varier le nombre de dimensions, soit il faut changer le type du conteneur en fonction du nombre de dimensions (ce qui est impossible à faire à l’exécution vu que le C++ est typé statiquement), soit il faut bricoler avec des pointeurs et des casts dans tous les sens… :confused:

#14

[quote=“syam”]Non c’est juste que pour le moment j’ai pas trouvé de solution “évidente” pour faire varier le nombre de dimensions à l’exécution, et je n’ai pas pris le temps de chercher sur internet s’il existe une solution toute faite.
Le problème c’est que pour faire varier le nombre de dimensions, soit il faut changer le type du conteneur en fonction du nombre de dimensions (ce qui est impossible à faire à l’exécution vu que le C++ est typé statiquement), soit il faut bricoler avec des pointeurs et des casts dans tous les sens… :confused:[/quote]
oki , de toute façons pas de souci ce n’est pas urgent (oui bon avant la fin de l’année quand même :laughing: )

#15

[quote=“syam”]Non c’est juste que pour le moment j’ai pas trouvé de solution “évidente” pour faire varier le nombre de dimensions à l’exécution, et je n’ai pas pris le temps de chercher sur internet s’il existe une solution toute faite.
Le problème c’est que pour faire varier le nombre de dimensions, soit il faut changer le type du conteneur en fonction du nombre de dimensions (ce qui est impossible à faire à l’exécution vu que le C++ est typé statiquement), soit il faut bricoler avec des pointeurs et des casts dans tous les sens… :confused:[/quote]

Il y a bien une solution, de tout stocker dans un seul vecteur de dimension 1, mais plus grand (on concatène tout quoi)…

Par exemple, un vecteur avec 2 dimensions respectivement m, n.
On crée un std::vector de taille mn
L’accès à la vleur [i][j] se fera en accédant à la valeur [jm + i] du std::vector

3 dimensions m, n, o ?
pour accéder à [i][j][k] on cherchera [kmn + j*m + i] (si je ne me plante pas)

etc.

Une fonction qui connaît le vecteur de dimensions [m, n, o, …] (de taille variable à l’éxécution) à qui on passe un vecteur d’indexs [i, j, k, …] (de même taille) devrait pouvoir te calculer l’index composite via une boucle sans problème, et ce quelque soit le nombre de dimensions… faut juste écrire l’algo :slightly_smiling:

edit: Je sais pas si je réponds vraiment à la question initiale (que je ne comprends pas :eusa-think:) , je me suis attaché à la question : “un vecteur avec un nombre de dimensions variant à l’exécution”.

#16

intéressant l’idée, inconvenant c’est l’algo je doute que sa soie la solution car c est le cpu qui va bosser.
Bon finalement je laisse tomber plus le temps de chercher.
Merci encore pour vos réponse :023