Discussion :

[lOeil]

Bonsoir,

j'aimerais créer en C++ (donc avec les new) un tableau 4D
La première dimension serait de type int tandis que les 3 autres dimension seraient de type char*


Pour 1 numéro je voudrais 3 char*

exemple :

[int numero1] [int numero2] [int numero3]
[char* champ1.1] [char* champ2.1] [char* champ3.1]
[char* champ1.2] [char* champ2.2] [char* champ3.2]
[char*champ1.3] [char*champ2.3] [char*champ3.3]

ca fait un bon moment que je suis dessus et je ne vois toujours pas comment faire :S


Merci bien pour votre aide

[Syrmonsieur]

OK si je comprends bien, en fait tu veut faire un tableau à une dimension dont chaque élément est un triplet de char*

Donc (toujours si je comprend bien la question) il faudrait (possibilité, il y en a d'autre) définir une classe groupant 3 char* :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
class triplet
{
public:
    triplet(const char* c1 = 0,
              const char* c2 = 0,
              const char* c2 = 0)
    :    champ1(c1),
         champ2(c2),
         champ3(c3){}
 
    const char* champ1;
    const char* champ2;
    const char* champ3;
}

Ensuite plusieurs cas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
// Voici une table de taille fixe et prévu à la compilation
triplet table[constante];
// Accès au champ 1 de l'élement premier :
table[0].champ1;
 
// Autre méthode, pointeurs, fixé après coup.
triplet table2 = new triplet[variable];
//...
delete[] table2;
 
// Maintenant une table de taille variable
std::vector<triplet> table3;
table3.push_back(triplet("Salut", "Tout", "Le monde"));

J'espère ne pas être à coté de la question
++

[Luc Hermitte]

Rien compris.
Je n'ai pas l'impression que l'on ait les mêmes définitions pour "tableau" et pour "dimension de tableau".

Tu t'en servirais comment de ton truc ?


EDIT: Si Syrmonsieur a bien compris ce que tu voulais faire, son code causera des gros ennuis relativement à la gestion de la mémoire. Là, ça passe car il n'utilise que des chaines constantes littérales dans son exemple.

[loufoque]

il suffit de faire un tableau de tuple<int, std::string, std::string, std::string>

[Syrmonsieur]

EDIT: Si Syrmonsieur a bien compris ce que tu voulais faire, son code causera des gros ennuis relativement à la gestion de la mémoire. Là, ça passe car il n'utilise que des chaines constantes littérales dans son exemple.

En effet, pour éviter les problèmes, il vaudra mieux utiliser des std::string.
Enfin, ça dépends de ce que tu veux faire...ça représente quoi au juste ? (ça m'aurait aider pour bien comprendre ta question, là je suis peut etre à coté...)


++

[Médinoc]

On ne peut pas utiliser autre chose qu'un type entier comme indice de tableau "tableau".
Si tu veux indicer un tableau avec une chaîne, il te faut un tableau associatif.


Ou bien, tu as mal dit ce que tu voulais et tu cherches plutôt un ensemble (genre std::set) de tuples (entier, chaine, chaine, chaine)

[lOeil]

Ou bien, tu as mal dit ce que tu voulais et tu cherches plutôt un ensemble (genre std::set) de tuples (entier, chaine, chaine, chaine)

Merci pour vos réponses.
Alors en fait mon esprit était un peu confu et je voulais réaliser ce que tu décris Médinoc.

Mais en lisant les réponses il me suffit de créer un tableau de triplet
Je ne vois pas en quoi un tableau de triplet peu poser un pb de mémoire.
ma classe triplet comportera 3 string et le tour est joué

Merci bien pour votre aide

[Luc Hermitte]

Le problème viendra avec la manipulation de char* qu'il faudra systématiquement allouer, copier et désallouer sans se prendre les pieds dans les exceptions.
En C++, on préfère utiliser des types dédiés comme std::string.

[lOeil]

ok merci
mais bon je ne pense pas pouvoir changer partour car j'utilise des classes prenant comme parametre des char *

[Médinoc]

Si tu as des fonctiosn bien faites qui prennent en paramètre des const char *, tu peux utiliser tes std::string.

Mais si tu as des fonctions soit mal faites, soit qui ont réellement besoin d'un buffer, tu devras rester en char * (ou utiliser ta propre classe), car il n'y a aucun équivalent à ATL::CSimpleStringT::GetBuffer() dans les std::string...

[lOeil]

bon j'hésite à ouvrir un nouveau topic mais comme le sujet devie pourquoi ne pas approfondir la conversion string -> const char *

et voila :O





D'autre part ma fonction a comme parametre un const char* mais si je met le string sans conversion j'obtient ce message d'erreur

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
cannot convert parameter 2 from 'class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> 
>' to 'const char *'

[Médinoc]

Il nous faut plus de code, là...
Et vérifie que l'appel à length() ne modifie pas les entrailles de la chaîne (même si en théorie, ça ne devrait rien changer)...

De plus, il est connu que l'implémentation de la STL livrée avec Visual 6 est buggée.

[lOeil]

ba j'ai une chaine de caractères de la base étendue ASCII
j'en ai 49 :

la voici en binaire

00111000 00001000 01111010 00001010 00000101 01010100
00011111 10010011 01111110 00011000 00111000 11011000
00101100 01011010 11100101 00000000 11011001 11100100
00001001 10001110 00101111 00001001 10110001 00010110
00100001 01110001 01011111 00001001 01000011 11110111
00000010 10110001 10101000 00000011 10111001 00001110
00111111 11110100 11101110 00000000 00011101 10000000
00001010 10110100 01111000 00011000 11001100 11000110
00100100


et lors de la conversion en char* il ne me reste que les 15 premiers caractères, le reste a ... disparu ?

[Médinoc]

00111000 00001000 01111010 00001010 00000101 01010100
00011111 10010011 01111110 00011000 00111000 11011000
00101100 01011010 11100101 00000000 11011001 11100100
00001001 10001110 00101111 00001001 10110001 00010110
00100001 01110001 01011111 00001001 01000011 11110111
00000010 10110001 10101000 00000011 10111001 00001110
00111111 11110100 11101110 00000000 00011101 10000000
00001010 10110100 01111000 00011000 11001100 11000110
00100100

Ce n'est pas une vraie chaîne de caractères, c'est un buffer d'octets.

Donc si tu veux stocker des buffers d'octets, tu peux garder les char* (ou plutôt, char*+size_t pour la longueur), car std::string n'est pas approprié ici.

[Laurent Gomila]

std::string n'est pas plus inapproprié qu'autre chose, ce ne sont que les opérations qui interpètent une chaîne C terminée par \0 qui poseront problème.

Si on utilise des itérateurs à la place de const char* par exemple, il n'y a aucun problème.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
const char Buffer = [... plein de '\0' dedans ...];
 
// Initialisation qui ne s'arrête pas au premier \0
std::string StrBuffer(Buffer, Buffer + sizeof(Buffer));
 
// Extraction qui va bien jusqu'à la fin
char Buffer[... assez grand ...];
std::copy(StrBuffer.begin(), StrBuffer.end(), Buffer);
 
// Pour ne pas faire de copie, on peut aussi utiliser string::data() + string::length()

Après, en interne, il n'y a pas non plus de problème puisque c'est la taille stockée qui est utilisée pour délimiter la fin de la chaîne, et non un potentiel zéro terminal.

Bon, à part ça si le buffer n'a vraiment rien à voir avec une chaîne de caractères, effectivement on peut aussi utiliser std::vector<char> ou autre (mais pas char* !).

[lOeil]

Ce n'est pas une vraie chaîne de caractères, c'est un buffer d'octets.

Je pense que je me suis mal exprimé, ma chaine ne contient pas des octects, j'avais donné la version binaire de la chaine car la pluparts des caractères ne sont pas visibles.
C'etait bien pour montrer la longueur.

Cependant tu as fait remarqué 00000000.
c'est équivalent à '\0' et ca serait pour cela que ma chaine se tronque.
Je n'avais vraiment pas fait attention.

Cependant les méthodes des classes que j'importe utilisent des const char * donc si j'utilise des std::vector<char> ca ne va pas aller.

Il faudrait donc utiliser la solution des buffers que donne Laurent Gomila, cependant il faut avouer que je ne comprend pas tres bien ton code, donc je vais étudier ca voir si j'arrive a mettre ca en place.

En tout cas merci pour m'avoir montrer "00000000"



EDIT: voila ce que je test mais ca me met le même probème

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
//string ClefUtilisateurCryptee -> clef avec plein de caractères non imprimable
char * ClefUtilisateurCharCryptee = new char[ClefUtilisateurCryptee.length()];
copy(ClefUtilisateurCryptee.begin(), ClefUtilisateurCryptee.end(),ClefUtilisateurCharCryptee);

[Laurent Gomila]

Comment as-tu initialisé ta chaîne avant ça ?

Cependant les méthodes des classes que j'importe utilisent des const char * donc si j'utilise des std::vector<char> ca ne va pas aller.

Il faudrait donc utiliser la solution des buffers que donne Laurent Gomila, cependant il faut avouer que je ne comprend pas tres bien ton code, donc je vais étudier ca voir si j'arrive a mettre ca en place.

http://c.developpez.com/faq/cpp/?pag...teneurs_avec_c

[loufoque]

tu peux très bien obtenir un char* à partir d'un std::vector<char>....
Il suffit de prendre l'adresse du premier élément.

[lOeil]

Comment as-tu initialisé ta chaîne avant ça ?

C'est à dire ? comment dois-je l'initialiser ?

Après, en interne, il n'y a pas non plus de problème puisque c'est la taille stockée qui est utilisée pour délimiter la fin de la chaîne, et non un potentiel zéro terminal.

La taille tu la mets ou ? c'est ton [...assez grand...] ?

[lOeil]

et si je crypte ma chaine cryptée en base64 ma nouvelle chaine sera contenue dans la table ASCII classique et donc plus ce problème ...

en base64 c'est bien possible de crypter une chaine de caracatère de l'ASCII étendue ?