Discussion :

[handmade]

Bonjour à tous,

C'est la première fois que je post sur ce forum alors j'espère ne pas me tromper d'endroit pour poser ma question. J'apprends le C++ toute seule alors je m'en excuse à l'avance si je n'utilise pas le bon vocabulaire.

Je souhaite coder la chose suivante à l'aide de boucles for :

J'ai une liste de composés auxquels je voudrais appliquer une équation. Mais bien entendu les équations sont différentes selon le composé et reviennentt en boucle. exemple ci-dessous

Liste de composés [0] [1] [2] [3] [4] [5] etc.... (nombre de composés ncomp inconnu)
Liste d'équations A B C

association composés/équations

[0] A
[1] B
[2] C
[3] A
[4] B
[5] C

Je voudrais faire une boucle du style

for (i=0, i<ncomp, i++) {
etc car là je ne sais plus quoi faire. Je ne sais pas comment écrire que

pour [0] on applique l'équation A ainsi que pour [0]+3
pour [1] on applique l'équation B ainsi que pour [1]+3
pour [2] on applique l'équation C ainsi que pour [2]+3

etc jusqu'à la fin du vecteur ncomp

Pouvez-vous m'expliquer comment on fait?

Merci d'avance

handmade

[Bousk]

Salut,

par équation on va supposer que tu parles de fonction à appeler...
La solution est sans doute d'avoir un vector de function. Mais pour en être sûr il faudrait plus d'infos comme ce qu'est réellement l'opération à réaliser.

[handmade]

Salut et merci pour ta réponse,
Oui équation = fonction pour moi
on n'a qu'à prendre 3 fonctions lambda, par exemple

y=2x
y=3x
y=4x

En fait je voudrais pouvoir réaliser ceci :

pour les indices [0] et [3] ( [6] et [9] et ainsi de suite jusqu'à i<ncomp) appliquer l'équation y=2x sur la données d'entrée appelée x
pour les indices [1] et [4] ( [7] et [10] et ainsi de suite jusqu'à i<ncomp) appliquer l'équation y=3x sur la données d'entrée appelée x
pour les indices [2] et [5] ( [8] et [11] et ainsi de suite jusqu'à i<ncomp) appliquer l'équation y=4x sur la données d'entrée appelée x

Donc il faut lire l'ensemble de mes indices puis en fonction de l'indice de départ appliquer l'une ou l'autre des 3 équations.
C'est plus clair ce que j'ai écrit

Je suppose qu'il faut créer plusieurs boucles for

Je pensais faire un truc comme ça

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
VectorDbl y(ncomp);
 
for (size_t i=0; i<ncomp;i++) {
 
  for (int countj=i;countj<ncomp;countj+3){
    y[i] =2x[countj];
   }
  for (int countk=i+1;countk<ncomp;countk+3){
    y[i] =3x[countk];
  }
  for (int countl=i+2;countl<ncomp;countl+3){
    y[i] =4x[countl];
  }
}

ça pourrait le faire?

Merci d'avance

[Bktero]

Ce n'est pas l'opérateur % (modulo) que tu cherches ?

Exemple :

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
#include <iostream>
#include <array>
 
void f(int v) {
    std::cout << v << '\n';
}
 
int main() {
    std::array array = {0,1,2,3,4,5,6,7,8,9,10};
    for (auto v : array) {
        if (v % 3 == 0) {
            f(v);            
        }
    }
}

Sortie :

0
3
6
9

[handmade]

Bonjour et merci,

non non, je cherche vraiment à appliquer une fonction particulière tous les 3 index

[handmade]

Rebonjour à tous,

A priori je viens de trouver. Je ne sais pas si c'est la façon la plus élégante de le faire mais ça ne plante plus.

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
16
		VectorDbl y(ncomp);
 
		for (size_t i = 0; i < ncomp; i++) {
			int j = 0;
			int k = 1;
			int l = 2;
			for (j = i; j < ncomp; j +=3){
				y[j] = 2 * x[j];
			}
			for (k = i + 1; k < ncomp; k += 3){
				y[k] = 3 * x[k];
			}
			for (l = i + 2; l < ncomp; l += 3){
				y[l] = 4 * x[l];
			}
		}

Si vous avez plus élégant, je suis preneuse d'idée, histoire de monter en compétence

[Bysbobo]

Salut!

Bktero t'a propose une bonne solution avec le modulo que tu as reimplemente par toi meme ensuite.
En utilisant les infos au dessus (et ce que j'en ai compris), ca donnerai un truc du genre:

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
16
17
18
19
20
21
22
23
24
#include <iostream>
#include <array>
 
void f2(int v) {
    std::cout << 2*v << '\n';
}
void f3(int v) {
    std::cout << 3*v << '\n';
}
void f4(int v) {
    std::cout << 4*v << '\n';
}
 
int main() {
    std::array array = {0,1,2,3,4,5,6,7,8,9,10};
    for (auto v : array) {
        switch(v % 3) {
            case 0: f2(v); break;
            case 1: f3(v); break;
            case 2: f4(v); break;
            default: break;
        }
    }
}

Je ne suis pas chez moi, j'ai jete ca comme ca mais devrait etre fonctionnel.
J'ai laisse comme Bktero des cout pour les fonctions, a toi de les adapter.
Bon couarge

[koala01]

Salut,

Voyons si on a bien compris:

On part du principe qu'il existe trois fonctions, que nous pourrions définir sous la forme de

Code :

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

1
2
3
4
5
6
7
8
9
10
 
void a(int i){
	std::cout<<"A called with value "<<i<<"\n";
}
void b(int i){
	std::cout<<"B called with value "<<i<<"\n";
}
void c(int i){
	std::cout<<"C called with value "<<i<<"\n";
}

(il va de soi que le code que je donne pour ces fonctions devrait être adapté à tes besoins, mais qu'il suffira très bien à pour mon exemple )

Et que, pour pouvoir les appeler successivement, tu les a placés dans un tableau sous la forme de

Code :

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

std::vector<std::function<void(int)>> functions{&a,&b,&c};

(nécessite l'inclusion du fichier <vector> et du fichier <functional> et l'utilisation de C++11 au minimum pour compiler)

Le plus cohérent est alors d'effectivement utiliser le modulo, qui fourni le reste de la division d'un nombre par un autre pour parcourir ce tableau, mais, d'utiliser le résultat obtenu comme indice du tableau à utiliser, au lieu de l'utiliser dans un test, comme l'avait montré Btkero, par exemple, un code proche de

Code :

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

1
2
3
4
5
6
7
int main(){
	std::vector<std::function<void(int)>> functions{&a,&b,&c};
	for(int i = 0; i<15; ++i){
		functions[i%3](i);
	}
	return 0;
}

provoquera l'affichage

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
16
a.exe
A called with value 0
B called with value 1
C called with value 2
A called with value 3
B called with value 4
C called with value 5
A called with value 6
B called with value 7
C called with value 8
A called with value 9
B called with value 10
C called with value 11
A called with value 12
B called with value 13
C called with value 14

Maintenant, si tu dispose d'un ensemble d'éléments qui doivent servir de paramètre pour l'appel de ces fonctions dont on va considérer que cet ensemble d'éléments est représenté sous la forme de

Code :

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

std::vector<int> elements{3,5,10,15,9,7,2,3,45,32,64,128,35,45,54};

rien de plus simple : il suffira de modifier l'appel pour prendre la valeur qui trouve à l'indice représenté par le compteur, en modifiant un tout petit peu le code pour lui donner la forme de

Code :

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

1
2
3
4
5
6
7
8
int main(){
	std::vector<std::function<void(int)>> functions{&a,&b,&c};
	std::vector<int> elements{3,5,10,15,9,7,2,3,45,32,64,128,35,46,54};
	for(int i = 0; i<15; ++i){
		functions[i%3](elements[i]);
	}
	return 0;
}

qui provoquera l'affichage de

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
16
a.exe
A called with value 3
B called with value 5
C called with value 10
A called with value 15
B called with value 9
C called with value 7
A called with value 2
B called with value 3
C called with value 45
A called with value 32
B called with value 64
C called with value 128
A called with value 35
B called with value 46
C called with value 54

Est-ce suffisamment proche de ce que tu cherches à faire