Discussion :

[grizzli06]

Bonjour,

J'ai un programme dans lequel je vois le bout de code suivant:

Code :

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

1
2
3
4
struct fir_filter {
  short *coeffs;		// short means a range from -32 768 to 32 767
  short num_coeffs;    // num_coeffs must be an even number, 4 or higher
};

D'après ce que j'ai compris, ce struct est donc composé de 2 éléments:
-des coefficients "coeffs"
-un nombre entier "num_coeffs" représentant le nombre de ces coefficients.

Ce qui m'ennuie c'est que je ne vois nulle part dans le reste du programme la définition en dur de ces coeffcients, ni la définition de la valeur de "num_coeffs".

Je voudrais donc savoir le rôle de "*" devant un élément de struct, et où doit-on définir les coefficients ?

Merci
P.S.: pour info, je définissais mes coefficients comme suit:

Code :

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

1
2
3
4
5
6
7
8
const short LPF_Coeffs[5] = ( //le nombre de coefficients doit etre > à 4 d'après la doc Teensy.
 
(short) (32768 * -0.635640527595689),
(short) (32768 * -0.20976263263201292),
(short) (32768 * 0.6981598830670951),
(short) (32768 * -0.20976263263201292),
(short) (32768 * -0.635640527595689)
);

mais bien sûr je voudrais comprendre "struct" désormais.
Merci pour votre éclairage

[foetus]

Tu es dans la section C++ et ta question est + 1 question de base du C

L'étoile veut dire pointeur, c'est à dire 1 adresse vers 1 variable/ quelque chose/ rien NULL.
Le pointeur va de paire avec l'allocation dynamique sur le tas ("heap") avec le couple

• pour le C: malloc/ free
• pour le C++: new/ delete et new []/ delete [] pour les tableaux

En C++ on privilégie les collections de la STL, la librairie standard, comme std::vector ou std::array et on évite les allocations dynamiques "brutes" (surtout depuis 2011 et les nouvelles normes C++11, C++14, C++17, C++20, ...)
Pour le reste

[grizzli06]

Merci foetus,

je pensais bien aussi que * c'était un pointeur, mais je m'interrogeais surtout sur le fait que ces coefficients ne sont définis nulle part dans le reste du programme... or ce sont des constantes (ça c'est sûr) donc elles devraient être définies.

Pour le reste je ne veux pas cous embêter avec mes questions basiques, donc je vais essayer de trouver un forum pour les débutants...

Mille mercis,

[foetus]

mais je m'interrogeais surtout sur le fait que ces coefficients ne sont définis nulle part dans le reste du programme... or ce sont des constantes (ça c'est sûr) donc elles devraient être définies.

Que les variables ne soient pas définies dans le code, cela peut être normal
les valeurs 0.635640527595689, 0.20976263263201292, 0.6981598830670951 semblent être des sin/ cos/ racines carrées/ ... (et cycliques) ... donc être mises dans 1 boucle avec la formule pour remplir le tableau.

Le code est mauvais
En C++, la structure n'est plus trop utilisée. La différence entre 1 classe et 1 structure, c'est que l'encapsulation est privée pour la classe et publique pour la structure (lorsqu'on ne met pas private, public, protected).
Donc les structures sont plutôt réservées à des DTO (les objets sans logique)

Le code est mauvais car il manque 1 constructeur et 1 destructeur ... surtout avec 1 tableau dynamique.
L'autre truc c'est qu'il manque 1 membre. num_coeffs est plutôt 1 maximum (le nombre total de cases du tableau coeffs), mais jamais on sait réellement le nombre de valeurs mises dans le tableau.
Par exemple, coeffs peuvent avoir la taille [maximale] de 4, 8, ... mais seulement 2 valeurs de mises.

Et plus général tu sembles être en train de coder le containeur de la librairie standard STL, std::vector - lien cplusplus en anglais.
Même avec les histoires de maximum pair et multiple, tu peux coder facilement avec 1 vecteur.
D'autant plus, qu'en C++ on n'a pas le realloc du C ... ou alors tu codes tout en C

1 code sûrement plantogène ... et qui ne met pas à zéro les cases vides

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
#include <iostream>
 
 
struct fir_filter {
public:
 
    fir_filter(): coeffs(NULL), num_coeffs(0), count(0) {}
 
    ~fir_filter() {
        if (coeffs != NULL) {
            delete[] coeffs;
        }
    }
 
public:
 
   void add_coeff(short new_coeff) {
        if (num_coeffs > 0) {
            if (count < num_coeffs) {
                coeffs[count] = new_coeff;
                ++count;
            } else { // no realloc in C++, you must destroy and recreate
                short* tmp;
 
                num_coeffs += 2;
                tmp = new short[num_coeffs]; // maybe test if is ok
                for(size_t i=0; i < count; ++i) { tmp[i] = coeffs[i]; }
 
                delete[] coeffs;
                coeffs = tmp;
 
                coeffs[count] = new_coeff;
                ++count;
            }
        } else {
            coeffs     = new short[4]; // maybe test if is ok
 
            coeffs[0]  = new_coeff;
            count      = 1;
            num_coeffs = 4;
        }
   }
 
   friend std::ostream& operator<< (std::ostream&, fir_filter const&);
 
public: // pour 1 structure, les membres sont souvent publiques
 
    short* coeffs;
    short  num_coeffs;
 
private:
 
    size_t count;
};
 
 
std::ostream& operator<< (std::ostream& os, fir_filter const& str) {
    os << "[ ";
    for(size_t i=0; i < str.count; ++i) { os << str.coeffs[i] << " "; }
    os << "]";
 
    return os;
}
 
 
int main()
{
    fir_filter str;
 
    std::cout << "init fir_filter: " << str << std::endl;
 
    str.add_coeff((short) (32768 * -0.635640527595689));
    str.add_coeff((short) (32768 * -0.20976263263201292));
    str.add_coeff((short) (32768 * 0.6981598830670951));
    str.add_coeff((short) (32768 * -0.20976263263201292));
    str.add_coeff((short) (32768 * -0.635640527595689));
 
    std::cout << "fir_filter: " << str << std::endl;
 
    for(size_t i=0; i < 4; ++i) { str.add_coeff(32 * i); }
 
    std::cout << "fir_filter: " << str << std::endl;
 
    return 0;
}

[grizzli06]

Merci foetus !

Ton expertise est telle, qu'il me faudra du temps pour digérer ça (!!), mais j'ai opté pour une autre méthode qui me convient davantage.

Le code que j'avais récupéré est en effet pourri, et pas uniquement sur ce point(...), donc je suis reparti from scratch: ça passe à la compil et au moins je maîtrise ce que je fais...

J'ai également adopté une méthode où mon tableau est rempli à partir d'une liste de coeffs et d'un pointeur: c'est limpide et ça fonctionne !

Je passe le topic en résolu en te remerciant à nouveau