error: a brace-enclosed initializer is not allowed here before '{' token

Version imprimable

1 pièce(s) jointe(s)

Salut ,j'écris une structure de données qui contient 11 paramètres en c++ ;lors de compilation du code sur vivado HLS j'ai quelque erreur:aidez-moi à corriger.merci

../../../../main.cpp:181:28: error: a brace-enclosed initializer is not allowed here before '{' token
../../../../main.cpp:181:65: error: ISO C++ forbids initialization of member 'parameters' [-fpermissive]
../../../../main.cpp:181:65: error: making 'parameters' static [-fpermissive]
../../../../main.cpp:181:65: error: invalid in-class initialization of static data member of non-integral type 'double [5][1]'

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
struct model
	{
		double parameters[5][1] ={{1},{1},{1},{10},{0.150000000000000}};
 
		double *nr_class[1][1]={3};	/* number of classes, = 2 in regression/one class svm */
		double *totalSV[1][1]= {38};			/* total #SV */
		//double svm_node **SV=SVs=
			           double *rho[3][1]= {{3.85250072056665},{1.98260813354295},{-9.85381777928213}};
 
 
	          double *label[3][1]= {{1},{2},{3}};	/* label of each class (label[k]) */
		      double *sv_indices[38][1]= {{1},{3],{11},{18},},{70},{71},{72},{73},{75},{82},{83},{90},{94},{98},{102},{104},{107},{110},{113},{119}};       /* sv_indices[0,...,nSV-1] are values in [1,...,num_traning_data] to indicate SVs in the training set */
 
 
		      double *probA[3][1]= {{-3.04020468884611},{-3.02985537320699},{-1.22838128162279}};		/* pariwise probability information */
		      double *probB[3][1]= {{-0.143832034298135},{-0.331592706939798},{-0.317353460209991}};
			            double *sv_coef [38][2]= {
			  {0.0441014900184046,0},
			  {0.115481676752995,0.0247201450973238},
			  {0.0284525394158882,0},
		      {0.115481676752995,0.0247201450973238},
			  {0,2.56566567302770},
			  {-0.115481676752995,0},
			  {-0.115481676752995,0},
			  {-0.115481676752995,0},
						  {0,-2.56566567302770},
			  {-0.0247201450973238,-2.56566567302770},
			  {-0.0247201450973238,-0.106867010440775},
			  {0,-1.24158009628657},
			  {-0.0247201450973238,-2.56566567302770},
			  {-0.0247201450973238,-1.28942381799513}};	/* coefficients for SVs in decision functions (sv_coef[k-1][l]) */
 
				/* constants in decision functions (rho[k*(k-1)/2]) */
		/* for classification only */
 
		//double *label= [1;2;3];	/* label of each class (label[k]) */
		double *nSV[3][1] ={{10},{17},{11}};	/* number of SVs for each class (nSV[k]) */
					/* nSV[0] + nSV[1] + ... + nSV[k-1] = l */
	    double *SVs[38][14]={
		{-0.579400000000000,-0.924500000000000,-0.878900000000000,-0.907400000000000,-0.902800000000000,-0.979600000000000,-0.977000000000000,-0.918200000000000,-0.904600000000000,-0.965100000000000,-0.972900000000000,-0.941700000000000,-0.961900000000000,-0.936700000000000},
	{-0.422700000000000,-0.443500000000000,-0.809000000000000,-0.880800000000000,-0.879800000000000,-0.924100000000000,-0.930800000000000,-0.978100000000000,-0.949100000000000,-0.970100000000000,-0.990400000000000,-0.975300000000000,-0.981400000000000,-0.953000000000000},
	{-0.604400000000000,-0.850700000000000,-0.851100000000000,-0.788000000000000,-0.885200000000000,-0.825500000000000,-0.921000000000000,-0.933900000000000,-0.966800000000000,-0.917600000000000,-0.965200000000000,-0.930500000000000,-0.948600000000000,-0.938700000000000},
	,-0.711100000000000,-0.884900000000000,-0.735900000000000,-0.878500000000000,-0.868500000000000,-0.913100000000000,-0.938700000000000,-0.925300000000000,-0.932200000000000,-0.958400000000000,-0.848600000000000}};
 
		/* XXX */
		//int free_sv;		/* 1 if svm_model is created by svm_load_model*/
					/* 0 if svm_model is created by svm_train */
	};

Pièce jointe 324005

01/11/2017, 16h34
Bousk

Autant parameters devrait pouvoir être initialisé inline de cette façon si tu actives C++11 (même si j'ai des doutes sur la syntaxe réelle avec tous ces tableaux impliqués mais elle semble correcte, mais quel est l'intérêt d'avoir une seconde dimension de taille 1 ?).
Autant double *nr_class[1][1]={3}; et tout ce qui suit ne fait absolument aucun sens. :weird:
Et un simple copier/coller dans VS montre entre autre : une accolade fermante remplacée par un crochet fermant, des accolades un peu au hasard puisque la structure se ferme après sv_indices, des virgules qui se balladent n'importe où et surement d'autres.
01/11/2017, 16h40
koala01

Salut,

A la base, quelle idée te prend déjà tout simplement de vouloir manipuler des tableaux à deux dimensions (que les dimensions soient connues ou non à la compilation), surtout quand on constate que l'une de ces dimensions est systématiquement de taille 1!!!!

Il faut en effet savoir que quand on veut représenter un tableau à deux dimensions de L lignes et de C colonnes, c'est généralement parce que l'on veut pouvoir représenter un ensemble de L*C éléments, et qu'il est bien plus facile dés lors de les représenter sous la forme d'un tableau à une seule dimension. Pour accéder à un des élément se trouvant à la ligne l et à la colonne c, on utiliseras alors la formule indice élément recherché = l* nombre de colonnes + c.

Au pire, nous pourrons créer une petite classee "matrice" qui fera la conversion pour nous (et, tant qu'à faire, qui vérifiera que les valeurs soient "dans les clous"). Si mes souvenirs sont bons, j'ai proposé (une fois de plus) le code d'une telle classe il n'y a pas si longtemps sur le forum ;)
01/11/2017, 19h10
dalfab

Bonjour,

En passant à C++11, le premier tableau a une initialisation correcte.

Pour le second et les autres, si le type souhaité est bon, on pourrait l'initialiser avec double *nr_class[1][1] = { { new double(3) } }; car il s'agit d'un tableau de tableaux de pointeurs sur des double. Mais je pense que le type ne correspond peut-être pas à ce que tu souhaites faire.

Cette structure parait posée avant d'avoir appris le C++. Peut être que le langage C serait suffisant pour ton cas.
01/11/2017, 21h06
aycha mabrouk

Citation:

Envoyé par dalfab

Bonjour,

En passant à C++11, le premier tableau a une initialisation correcte.

Pour le second et les autres, si le type souhaité est bon, on pourrait l'initialiser avec double *nr_class[1][1] = { { new double(3) } }; car il s'agit d'un tableau de tableaux de pointeurs sur des double. Mais je pense que le type ne correspond peut-être pas à ce que tu souhaites faire.

Cette structure parait posée avant d'avoir appris le C++. Peut être que le langage C serait suffisant pour ton cas.

j'ai tester avec: double parameters[5][1] ={{1},{1},{1},{10},{0.150000000000000}};

double *nr_class[1][1]={ { new double(3) } }; mais j'ai les même erreurs, comment je peux les corriger pour que le code compile

./main.cpp:181:28: error: a brace-enclosed initializer is not allowed here before '{' token
../../../../main.cpp:181:65: error: ISO C++ forbids initialization of member 'parameters' [-fpermissive]
../../../../main.cpp:181:65: error: making 'parameters' static [-fpermissive]
./main.cpp:181:65: error: making 'parameters' static [-fpermissive]
../../../../main.cpp:181:65: error: invalid in-class initialization of static data member of non-integral type 'double [5][1]'
../../../../main.cpp:183:26: error: a brace-enclosed initializer is not allowed here before '{' token
../../../../main.cpp:183:46: error: ISO C++ forbids initialization of member 'nr_class' [-fpermissive]
../../../../main.cpp:183:46: error: making 'nr_class' static [-fpermissive]
01/11/2017, 21h58
dalfab

1) Apprendre le C++
2) utiliser un compilateur d'après 2011 et activer le C++11 (dépend de ton compilateur, il y a la réponse pour chacun dans le forum.)
3) comprendre les exemples donnés qui ne sont certainement pas la solution à ton problème (es-tu sûr d'avoir besoin d'un tableau de 1 x 1 pointeur sur double?)
4) adapter les exemples à ton problème.
01/11/2017, 22h04
aycha mabrouk

oui,j'ai besoin d'un tableau de 1 x 1 pointeur sur double
02/11/2017, 02h51
koala01

Citation:

Envoyé par aycha mabrouk

oui,j'ai besoin d'un tableau de 1 x 1 pointeur sur double

La question est: pourquoi :question: :question:

Et si tu me dis que tu as une "quelque part" interface qui a besoin d' un double ***, je mords, car ca, ce n'est pas une raison valable ;)

C'est vrai que c'est une structure de donnée particulière. Ça fait 30 ans que je pratique, j'ai vu des structures parfois étonnantes mais pas celle là.
Donc ton tableau doit contenir un pointeur qui doit pointer quelque part et ce quelque part contient un 3.0. Quand on a besoin d'un pointeur en C++, le plus important est le 'quelque part' qui doit être défini. Dans l'exemple que j'ai donné, le 'quelque part' vaut 'n'importe où' ce qui a peu de chance d'avoir un sens, c'est à toi de voir. Et si tu souhaites plus d'aide, il faudrait peut-être un exemple ou une explication de comment tu te sert de cette donnée.

Pour en revenir à la nécessité d'utiliser le C++11. Pré-initialiser les données d'un type n'existe que depuis 2011, avant on ne pouvait pré-initialiser que les données d'une instance. Le comité d'étude qui a qui mis en place le C++11 a aussi déclaré que les pointeurs nus (ceux que tu souhaites) n'avaient plus à être utilisés car ont désormais des équivalents plus sains.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 // avant C++11, struct A { double* tab1[1][1]; // initialisation impossible ici static double* tab2[1][1]; // autre possibilité, utiliser un static }; double x = 3.0; A a = {{{ &x }}/*,*/}; // le tabtab[0][0] pointe sur x qui vaut 3 // on pourrait initialiser à la place de /*,*/ les autres champs non static de A double* A::tab2[1][1] = {{{ &x }}}; // toutes les instances de A auront ce tab2 en commun // depuis C++11 struct A { double* tab1[1][1]{{ adresseDUneGlobale }}; // Mais C++11 propose d'éviter les pointeurs (car peu fiables) static double* tab2[1][1]; // static pointeur nu à éviter std::array<std::array<std::unique_ptr<double>,1>1> tab3{{std::make_unique(3.0)}}; static std::array<std::array<std::unique_ptr<double>,1>1> tab4; }; double* A::tab2[1][1] = {{{ &x }}}; // toutes instances auront ce tab2 en commun std::array<std::array<std::unique_ptr<double>,1>1> A::tab4{{std::make_unique(3.0)}}; // et aussi le tab4 A a; // L'objet créé est auto-initialisé avec les valeurs recommandés dans le type A pour tab1 et tab3, et les valeurs communes tab2 et tab4.
Tu peux utiliser le format tab1 tab2 tab3 ou tab4 suivant ton besoin. Si une seule instance de ton type existe, il faut préférer les cas static (tab2 ou tab4)
Toutes ces notations ne sont que les bases à connaître sur le langage.