char array with multiple entries

[Mirandole]

Salut. Gros problème en C avec les tableaux à plusieurs entrée :

#include <math.h>
#include <stdio.h>
#define maxt 12
#define maxh 50

Void main(int narg, char ** argv)
{
char tabl[maxt][maxh][1][1024]; // tableaux de chaînes
1024 à triple entrée
unsigned int i, k, j;

for (i=0;i<9;i++){
k=i/3;
j=fmod(i,3);
sprintf(tabl[k][j][0],"bla%d",i);
sprintf(tabl[k][j][1],"bla%d",i); // la même chose
}

for (i=0 ; i<9 ; i++ ) {
k=i/3;
j=fmod(i,3);
fprintf(stderr, "%s\n%s\n\n " , tabl[k][j][0] , tabl[k][j][1] )
}
}

Bon, hé bien au lieu d'écrire comme espéré :
bla0
bla0

bla1
bla1

bla2
bla2
etc...


j'ai :
bla0
bla1

bla1
bla2

bla2
bla2

bla3
bla4




bref, j'y comprend rien...

[Jean-Marc]

Re: char array with multiple entries

> char tabl[maxt][maxh][1][1024]; // tableaux de chaînes

Well it seems you did not set up correctly the size of the third
dimension of your array. The size should be 2, not 1.

[Peter_Julian]

Re: char array with multiple entries


"Mirandole" <gouailles@hotm ail.com> wrote in message
news:441d70fc$0 $21020$79c14f64 @nan-newsreader-05.noos.net...
| Salut. Gros problème en C avec les tableaux à plusieurs entrée :

Ceci est un groupe qui fait du C++, mais de toute façon, ton programme
du point de vue du langage C présente plusieurs anomalies.

|
| #include <math.h>
| #include <stdio.h>
| #define maxt 12
| #define maxh 50
|
| Void main(int narg, char ** argv)

même en C, void est illégale (d'ailleurs, Void n'existe pas).
main() doit toujours retourner int. donc:

int main()

| {
| char tabl[maxt][maxh][1][1024]; // tableaux de chaînes
| 1024 à triple entrée

devrait être...
char tabl[maxt][maxh][2][1024];

| unsigned int i, k, j;
|
| for (i=0;i<9;i++){
| k=i/3;
| j=fmod(i,3);
| sprintf(tabl[k][j][0],"bla%d",i);
| sprintf(tabl[k][j][1],"bla%d",i); // la même chose
| }
|
| for (i=0 ; i<9 ; i++ ) {
| k=i/3;
| j=fmod(i,3);
| fprintf(stderr, "%s\n%s\n\n " , tabl[k][j][0] , tabl[k][j][1] )
| }
| }
|
| Bon, hé bien au lieu d'écrire comme espéré :
| bla0
| bla0
|
| bla1
| bla1
|
| bla2
| bla2
| etc...
|
|
| j'ai :
| bla0
| bla1
|
| bla1
| bla2
|
| bla2
| bla2
|
| bla3
| bla4
|
|
|
|
| bref, j'y comprend rien...

Tu devrais avoir deviner à partire du résultat que tu sortais de la
plage en ce qui est du double-champ de rangée de caractères.
Ceci...
char c[2][1024]
représente deux champs:

c[0][1024]
c[1][1024]

c[2][1024] n'existe pas

Pourquoi une rangée de caractères quand on peut avoir des champs de
caractères ? En plus, une rangée implique une taille fixe pendant qu'un
champ a une taille dynamique.

C'est a dire:

int A[12]; // une taille fixe de 12

std::vector<int > vn; // une taille dynamique.

std::vector<int > vn(12); // une taille de 12 mais dynamique.

// taille 12, dyn et tous les éléments initialiser a 0
std::vector<int > vn(12, 0);

____

#include <iostream>
#include <ostream>
#include <string>
#include <vector>
#include <sstream>

const int maxt(12);

// fonction pour transfusion type T a std::string
template< typename T >
std::string toString(const T& t)
{
std::ostringstr eam oss;
oss << t;
return oss.str();
}

int main()
{
typedef std::vector< std::string > Champ; // 2 dimensions
typedef std::vector< Champ > Tableau; // 3 dimensions

Tableau tableau;
for(unsigned u = 0; u < maxt; ++u)
{
Champ champ;
for(unsigned v = 0; v < 2; ++v)
{
champ.push_back ("bla" + toString(u)); // deux fois
}
tableau.push_ba ck( champ ); // maxt fois
}
// dimension
std::cout << "dimension du tableau = " << tableau.size();
std::cout << std::endl;
std::cout << "dimension d'un champ = " << tableau[0].size();
std::cout << std::endl;
// output
for(u = 0; u < maxt*2; ++u)
{
std::cout << tableau[u/2][u%2] << std::endl;
}
return 0;
}

/*
dimension du tableau = 12
dimension d'un champ = 2
bla0
bla0
bla1
bla1
bla2
bla2
bla3
bla3
bla4
bla4
bla5
bla5
bla6
bla6
bla7
bla7
bla8
bla8
bla9
bla9
bla10
bla10
bla11
bla11
*/