Bonjour,
j'essaye de déclarer des variables automatiquement.
Par exemple ce que je voudrais c'est:
Et le programme a en mémoire les variables: variable1,variable2,variable3. ....variable10 et sont toutes égales à 1Code:#include <stdio.h> int main(){ int i; for (i = 1; i <= 10; i++){ int variablei = 1; } return 0; }
Ou en matlab
Code:for i = 1:10 variablei = 1 end
Et variable1 = 1, variable2 = 1.....
Merci beaucoup de m'aider, j'ai énormement besoin de cela.
Merci
Bonsoir,
Faites un tableau (C) ou un vecteur (Matlab).
En C:
En Matlab:Code:#include <stdlib.h> #include <stdio.h> int main(int argc, char **argv) { /* Allocation de la mémoire: 10 entiers. */ int *variable = (int*)malloc(sizeof(int)*10); for(int i = 0; i < 10; i++) { variable[i] = 1; } /* Libération de la mémoire */ free(variable); return 0; }
Code:variable = ones(1, 10); % Toutes les entrées valent 1.
Dernière modification par Paraboloide_Hyperbolique ; 26/05/2014 à 19h39. Motif: Correction code C
Bonjour,
je vous remercie, mais je n'ai pas précisé le contexte excusez-moi, en fait, je dois répéter plusieurs fois (des centaines) un certain bout de code, la seule chose qui change c'est le nom des variables, qui sont dans mon cas déjà un tableau.
Je peux faire un tableau de tableau en matlab (cellule) mais je ne peux pas le faire (erreur d'interprétation dans tout le reste du programme) et je ne sais pas comment le faire en C, de plus j'ai encore besoin de ce truc pour d'autres fonctions.
Je vous remercie de toutes propositions.
Si tu as un même algorithme qui tourne sur des variables différentes, tu encapsules ton algorithme dans une fonction dont les arguments sont tes variables, puis tu appelles autant de fois que nécessaire ta fonction sur tes différentes variables (que ce soit matlab ou C).je vous remercie, mais je n'ai pas précisé le contexte excusez-moi, en fait, je dois répéter plusieurs fois (des centaines) un certain bout de code, la seule chose qui change c'est le nom des variables, qui sont dans mon cas déjà un tableau.
En C tu as toujours la possibilité de faire de la "meta-programmation" grâce au préprocesseur... Mais c'est à réserver aux cas extrèmes car le principal inconvénient est que tu pourris la lisibilité de ton programme...
Oui mais si je dois le faire 100 fois, je dois retourner la valeur sur 100 variable
exemple:
for i = 1:100 (ou for (i = 1; i <= 100; i++)
v1 = algo(var1, var2,i)
v2 = ....
v3 = ....
...
v100
end
Voilà je dois recreer v1, v2 v3.... sans compter que l'algo retourne un tableau (une matrice).
Je ne connais pas la méta-programmation, est-ce que je pourrai avoir quelques exemples?
Bonsoir,
En C, si vos variables sont déjà des tableaux (de mêmes types ?), il est toujours possible de construire un pointeur sur tableaux, c'est-à-dire quelque chose du type:
Code:// Si la variables sont toutes de type int**. int*** p = (int***)malloc(sizeof(int**)*100); p[0] = variable1; p[1] = variable2; ... // Travailler ensuite avec le pointeur p.
Bonjour,
En C, tu peux essayer ce code:
A+Code:#include <stdio.h> #define DECLARATION(var,index,value) \ int variable##index = value; int main() { int i; for (i = 1; i <= 10; i++) { DECLARATION(variable,i,1) } return 0; }
C'est une solution proposée par lou_ibmix_xi (message #4). Il la trouve cependant peu élégante (et moi aussi).Envoyé par narakphysics
Merci de toutes vos réponses.
Si jutilse le pointeur sur pointeur, je dois tout de même faire 100 initialisation, si je ne me trompre pas.
Pour le code message 7 merci beaucoup, mais je ne comprends pas le "##" et la ligne :"DECLARATION(variable,i,1) " où est stocké le resultat?
Le problème est de savoir d'où viennent les valeurs des variables. En effet je ne comprends pas pourquoi tu tiens absolument à créer 100 variables dont l'accès sera difficile (pour l'initialisation comme pour l'utilisation), alors qu'il est très simple de créer un seul tableau pouvant contenir 100 valeurs, alors l'accès à une seule se fait par un indice, et répéter une opération identique se faisant par une boucle itérant sur chaque indice...Si jutilse le pointeur sur pointeur, je dois tout de même faire 100 initialisation, si je ne me trompre pas.
C'est de la "méta-programmation" grâce au préprocesseur, avant la compilation, chaque occurance de "DECLARATION" sera remplacée par "int variableX = value;" où X est la valeur de l'indice passée à ta macro. L'opérateur "##" est l'opérateur de concatenation: il colle bout à bout.Pour le code message 7 merci beaucoup, mais je ne comprends pas le "##" et la ligne :"DECLARATION(variable,i,1) " où est stocké le resultat?
Ca règle ton problème d'initialisation, mais ça ne changera pas le problème des opérations que tu dois effectuer sur toutes tes variables d'un coup...
Merci lou_ibmix_xi
En fait je programme en matlab, et je dois traduire mon code matlab en C.
Vu comme cela, c'est très étrange, mais c'est juste qu'il y a certaines contraintes en C, qu'il n'y a pas en matlab (retourner deux ou 3 matrices, voire des cellules pour une fonction, manque de tableau de tableau....) tous ces problèmes font que la création de plusieurs variables constituent une solution.
Je n'ai jamais fais de méta-programmation, le C est encore meilleur que ce que je pense. Je conaissais le # define, mais pas le ##.
Les opérations, peuven maintenant être faites dans un tableau non?
Une fonction en C peut très bien retourner un ou plusieurs objets (que ce soit des matrices ou n'importe quoi d'autre): il suffit de passer les adresses des objets en arguments lors de l'appel de la fonction. L'équivalent des "cellules" en Matlab sont les structures en C. Enfin, il n'y a aucun problème à créer des tableaux de tableaux en C.
La création de 100 variables est peut-être une solution, mais (c'est mon avis personnel) c'est peu élégant, peu pratique et difficile à manier.
Bonjour,
oui en effet avec l'utilisation des pointeurs on peut renvoyer 3,4,...valeurs. Moi je parlais de fonction genre
int fonction(....)
En matlab on fait [v1 v2 v3] = fonction(...)
Avec les structures, si j'ai 100 tableaux, il faut
Code:struct matrice{ float tab1[]; float tab2[]; ..... }
Encore le même problème
Bonsoir,
Une manière équivalente de l'écrire en C est:
Code:void fonction(float *v1, float *v2, float *v3) {...}
Problème qui peut être résolu par un pointeur sur un pointeur:
Ou par un pointeur simple et avec un peu d'arithmétique:Code:float **matrice; int ncol = ..., nrow = ...; // Allocation mémoire. matrice = (float**)malloc(sizeof(float*)*nrow); for(int i = 0; i < nrow; i++) matrice[i] = (float*)malloc(sizeof(float)*ncol); // Accès à l'élément j du tableau i: matrice[i][j] = ...; // Libération de la mémoire. for(int i = 0; i < nrow; i++) free(matrice[i]); free(matrice);
Ou encore au moyen de structures (cependant une classe C++ est plus élégante):Code:float *matrice; int ncol = ..., nrow = ...; // Allocation mémoire. matrice = (float*)malloc(sizeof(float)*ncol*nrow); // Accès à l'élément j du tableau i: matrice[i*ncol+j] = ...; // Libération de la mémoire. free(matrice);
Et je parie qu'on pourrait encore trouver des alternatives intéressantes.Code:struct vecteur { float tab[...]; // Un tableau. }; struct matrice { vecteur tab[...]; // Tableau de tableaux. };
Merci beaucoup pour tout ça.
Je suis en train de lire ça, j'en profites pour vous remercié maintenant que vous êtes connecté.
Demande typique de ceux qui ont utilisé des langages de scripts un peu pourris type PHP ? je me trompe ?
Ta question mélange la problématique avec la solution.
Bonjour,
merci de vos réponses.
J'ai bien cette solution:
Elle me fait penser aux cellules.Code:struct vecteur { float tab[...][]; // Un tableau. }; struct matrice { vecteur tab[...][]; // Tableau de tableaux. }; Mais le truc, c'est que je dois connaitre la taille des tableaux, à moins que je ne les surdimensionne, puis j'utilise realloc. Matlab, lui ça ne le dérange pas de faire des matrices de tailles inconnues, voire vide. Comment on fait un malloc avec un tableaux à 2 dimensions?
Sinon, je n’utilise pas PHP(jamais). Je fais plutôt des maths.Après oui, j'utilise des scripts.
Mais ma question ne mélange pas problématique et solution, elle est une solution à mon problème, tout fonctionne bien pour l'instant (j'ai du tout taper. J'ai largement dépassé les 2000 lignes).
Mais je sais que l'on peut le réduire par cette méthode.
Bonsoir,Bonjour,
merci de vos réponses.
J'ai bien cette solution:
Elle me fait penser aux cellules.Code:struct vecteur { float tab[...][]; // Un tableau. }; struct matrice { vecteur tab[...][]; // Tableau de tableaux. }; Mais le truc, c'est que je dois connaitre la taille des tableaux, à moins que je ne les surdimensionne, puis j'utilise realloc. Matlab, lui ça ne le dérange pas de faire des matrices de tailles inconnues, voire vide. Comment on fait un malloc avec un tableaux à 2 dimensions?
Sinon, je n’utilise pas PHP(jamais). Je fais plutôt des maths.Après oui, j'utilise des scripts.
Mais ma question ne mélange pas problématique et solution, elle est une solution à mon problème, tout fonctionne bien pour l'instant (j'ai du tout taper. J'ai largement dépassé les 2000 lignes).
Mais je sais que l'on peut le réduire par cette méthode.
Attention: telle qu'écrite, cette "solution" ne me semble pas adéquate pour ce que vous voulez faire: votre "matrice" est un tableau à 4 dimensions et votre "vecteur" un tableau à deux dimensions. Si vous faites référence à une de mes propositions de code*, je n'ai jamais écrit cela.
Quant à allouer un tableau de tableaux en C (ou équivalent), un de mes posts précédent détaille par le menu deux manières différentes de le faire.
*J'écris cela car le code que vous montrez est indenté exactement comme j'ai l'habitude de le faire, avec exactement les mêmes commentaires.
Dernière modification par Paraboloide_Hyperbolique ; 05/06/2014 à 19h38.
Merci, mais rien ne vaut un exemple.
Imaginons que j'ai 4 matrices, la premières uniquement de un, la seconde de 2, la troisième de 3, la 4eme de 4. Et que je veux mettre ces quatre matrice, dans un tableau de 4 cases (case 1 que la matrice de 1, case 2 celle de 2...)
En C:
Code:#include<stdio.h> int main(){ int i,j; matrice m1, m2, m3, m4, cellule c; /*On remplit nos matrices*/ for (i = 0; i < 4; i++){ for (j = 0; j < 4; j++){ m1[i][j] = 1; m2[i][j] = 2; m3[i][j] = 3; m4[i][j] = 4; } } for (i = 0; i < 4; i++){ for (j = 0; j < 4; j++){ c.tab[1] = m1[i][j]; c.tab[2] = m2[i][j]; c.tab[3] = m1[i][j]; c.tab[4] = m1[i][j]; } } /*Je sais qud ça ne marche pas, mais comment faire?*/ return 0; }
Bonsoir,
Sans vouloir vous offenser: avez-vous déjà fait de la programmation auparavant (Matlab et les langages de scripts ne comptent pas) ?
Je vous conseillerais également d'étudier un cours de programmation de base, notamment pour comprendre comment la mémoire et les pointeurs sont gérés en C.
Voici ce que j'écrirais. C'est plus cours, plus clair et potentiellement plus rapide à l'exécution*.
Le seul "inconvénient" (si c'est un inconvénient), c'est que c'est moins "joli" qu'avec des structures. Cependant, pour le moment et vu ce que vous codez, je vous déconseillerais de les utiliser.
*La différence ne se verra que pour des opérations lourdes et sur de grandes quantités de mémoire (style multiplication ou inversion de matrices denses 20000 x 20000).Code:#include <stdio.h> #include <stdlib.h> int main(){ int a, i,j; int nmatrices = 4, /* Nombre de matrices. */ nrows = 4, /* Nombre de lignes dans une matrice. */ ncols = 4; /* Nombre de colonnes dans une matrice. */ float *c; /* c va representer un tableau de matrices (tenseur d'ordre 3). */ /* Allocation de la mémoire: on alloue un tenseur de 4*4*4 flottants. */ c = (float*)malloc(sizeof(float)*nrows*ncols*nmatrices); /*On remplit nos matrices. Ceci fait ce que vos deux boucles imbriquées devaient faire.*/ for(a = 0; a < nmatrices; a++) { for(i = 0; i < nrows; i++) { for(j = 0; j < ncols; j++) { /* La matrice a sera remplie par (a+1). */ c[a*nrows*ncols + i*ncols + j] = (float)(a+1); /* Conversion (explicite) de type int --> float. */ } } } /* Exemple: accès à la matrice 2, à l'entrée (3, 2): c[1*nrows*ncols + 2*ncols + 1] = ... ; */ /* Libération de la mémoire. */ free(c); return 0; }
Bonjour, et merci beaucoup.
J'ai déjà fait de la programmation (C, JAVA, C++, assembleur) mais c'était il y a un bon bout de temps(~3 ans, hors matlab),. Du coup certaines choses reviennent tout doucement.
Ce que vous avez fait est très astucieux, en fait les valeurs sont stockées dans un tableau à une dimension. Afin de voir si j'ai bien compris, ce que vous avez fait, j'ai refait votre code, mais sans le regarder, juste en m'aidant de ce que j' ai compris, voici ce que j'ai fais:
J'ai mis en rouge les différences, pourquoi ce que j'ai fait est faux?Code:#include <stdio.h> #include <stdlib.h> int main(){ int a, i,j; int nmatrices = 4, /* Nombre de matrices. */ nrows = 4, /* Nombre de lignes dans la matrice. */ ncols = 4; /* Nombre de colonnes dans la matrice. */ float *c; /* c va representer un tableau de matrices (tenseur d'ordre 3). */ /* Allocation de la mémoire: on alloue un tenseur de 4*4*4 flottants. */ c = (float*)malloc(sizeof(float)*nrows*ncols*nmatrices); /*On remplit nos matrices. Ceci fait ce que vos deux boucles imbriquées devaient faire.*/ for(a = 0; a < nmatrices; a++) { for(i = 0; i < nrows; i++) { for(j = 0; j < ncols; j++) { /* La matrice a sera remplie par (a+1). */ c[a*nrows*ncols + j*ncols + i] = (float)(a+1); /* Conversion (explicite) de type int --> float. */ } } } /* Exemple: accès à la matrice 2, à l'entrée (3, 2): c[1*nrows*ncols + 2*ncols + 1] = ... ; */ /* Libération de la mémoire. */ free(c); return 0; }
Bonjour,
Ok, cela devrait vous revenir progressivement dans ce cas.
C'est en effet astucieux, mais ce n'est pas de moi. Il s'agit en fait d'une méthode assez standard dans le domaine des méthodes numériques.
Le principe revient à "coller" les lignes d'une matrice les unes derrières les autres. J'ai juste généralisé ce cas pour un tableau de matrice (tenseur d'ordre 3). On peut aisément généraliser cela à tout tenseur d'ordre n.
L'avantage de cette technique est de stocker la mémoire de manière contiguë, optimisant les temps d'accès en mémoire; au détriment toutefois du temps calcul (puisque quelques opérations arithmétiques sont nécessaires).
Excellente initiative !
C'est faux parce que dans le code "i" représente le nombre de lignes et "j" le nombre de colonnes. Votre code aurait été correct dans le cas inverse.
Dans mon code si A est une matrice, disons, (3x2), je la représente par un vecteur v de longueur 6 ou je "colle" les lignes les unes derrières les autres.
Si l'on part de l'entrée (i=0, j=0) et que l'on veut parcourir une colonne:
- A(0, 0) <-> v(0)
- A(0, 1) <-> v(1)
Si je veux maintenant passer à la ligne suivante en début de colonne, c-à-d accéder à A(i=1, j=0), je dois accéder à v(2):
- A(1, 0) <-> v(2)
- A(1, 1) <-> v(3)
Et pour la dernière ligne:
- A(2, 0) <-> v(4)
- A(2, 1) <-> v(5)
Mathématiquement parlant, je suis en train de définir une bijection entre les points du plan à coordonnées entières positives et les naturels. Cette bijection est linéaire et s'écrit:
a*i+b*j = k
Les relations entre A(i, j) et v(k) ci-dessus me permette de trouver les inconnues a et b qui sont: a = 2 (le nombre de colonnes) et b = 1: A(i, j) = v(k = 2*i+j).
Dans votre code, vous avez inversé les rôles de i et j. Il est possible de travailler avec ces rôles inversés. Cela revient en fait à travailler avec la transposée de A (ou, de manière équivalente, de "coller" les colonnes de A les unes derrières les autres). Dans ce cas là, la bijection devient:
3*j+i = k.
On peut travailler avec l'une ou l'autre bijection. On se réfère à la première comme "row major" (c'est la convention utilisée en C) et à la seconde comme "column major" (c'est la convention utilisée en Fortran).
