Discussion :

[tontonrichmon]

Bonjour tout le monde !

J'�tais entrain de r�aliser un programme permettant de crypter un message selon l�algorithme de Vigenere en C++.

A son lancement aucun probl�me probl�me ne s'affiche.
Le message est correctement crypt�, je l'affiche ensuite.

Arrive alors la partie d�cryptage pour v�rifier si j'arrivais � restituer le message, car c'est mieux de savoir d�coder quand m�me
J'appelle donc ma fonction de d�cryptage et utilise la m�me cl� que celle utilis�e pour le cryptage, mais, le message affich� ensuite ne correspond pas � mon texte d'origine.

Voici mes fichiers:

vigenere.h :

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
 
 
#ifndef VIGENERE_H
#define VIGENERE_H
 
 
#include <string>
#include <iostream>
 
using namespace std;
 
class vigenere
{
private:
 
public:
    vigenere();
    void vigenere_crypter(const string& input, string& output, const string& cle);
    void vigenere_decrypter(const string& input, string& output, string& cle);
};
 
#endif // VIGENERE_H

vigenere.cpp :

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
 
 
#include "vigenere.h"
 
vigenere::vigenere()
{
 
}
 
void vigenere::vigenere_crypter(const string& input, string& output, const string& cle)
{
    output.resize(input.size(),0);
    for(size_t i=0,j=0; i!=input.size(); ++i)
    {
        if(j==cle.size()) j = 0;
 
        output[i] = toupper(input[i]);
        if((output[i] >= 'A') && (output[i] <='Z'))
        {
            output[i] = ((output[i] + cle[j]-2*'A') % 26 + 'A');
            ++j;
        }
        else
        {
            output[i] = input[i];
        }
    }
}
 
 
void vigenere::vigenere_decrypter(const string& input, string& output, string& cle)
{
    string cle_tmp = cle;
    for(size_t j=0; j!=cle_tmp.size(); ++j)
    {
        cle_tmp[j]= 26-(cle_tmp[j] - 'A') + 'A';
    }
    vigenere_crypter(input,output,cle_tmp);
}

main.cpp :

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
 
 
#include <iostream>
#include "vigenere.h"
 
using namespace std;
 
int main()
{
    vigenere cryp;
    string str_crypt;
    string str_decrypt;
    string cle = "hello";
 
    cryp.vigenere_crypter("salut ceci est un test",str_crypt,cle);
    cout << str_crypt << endl;
 
    cryp.vigenere_decrypter(str_crypt,str_decrypt,cle);
    cout << str_decrypt << endl;
 
    return 0;
}

Je pense que mon erreur est simple mais je n'arrive pas � la voir...
Si vous pouviez m'�clairer, merci d'avance

[Pyramidev]

Bonjour.

Le message est correctement crypt�

En es-tu s�r ?

Dans la logique de ton algorithme, les caract�res de ta cl� doivent �tre compris entre 'A' et 'Z'.
Or, dans ton code, ta cl� est en minuscules.

A part �a, j'aurais plut�t �crit "vigenere.h" comme ceci :

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
#ifndef VIGENERE_H
#define VIGENERE_H
 
#include <string>
 
class vigenere
{
public:
    vigenere(const std::string& cle);
    std::string crypter  (const std::string& input) const;
    std::string decrypter(const std::string& input) const;
private:
    const std::string m_cle;
};
 
#endif // VIGENERE_H

Motifs :

• Pas besoin d'inclure <iostream> dans cet ent�te.
• Il faut �viter d'�crire "using namespace std;" dans un ent�te. Autrement, cela impacte aussi tous les ".cpp" qui incluent cette ent�te. Il vaut mieux laisser la libert� aux ".cpp" de faire les "using" qu'ils veulent.
• Tes fonctions "vigenere_crypter" et "vigenere_decrypter" sont non statiques alors que ta classe "vigenere" ne contient aucune variable membre qui modifie le fonctionnement de ces deux fonctions. Ce serait plus coh�rent d'avoir des fonctions statiques, ou bien des fonctions globales dans un espace de nom "vigenere". Mais, dans cet exemple, il me semble logique que la cl� soit une variable membre de la classe.
• En C++, il est plus simple de manipuler des fonctions qui retournent un "std::string" plut�t que des fonctions qui retournent "void" avec un param�tre suppl�mentaire "std::string& output"
• Dans tes fonctions "vigenere_crypter" et "vigenere_decrypter", le pr�fixe "vigenere_" est inutile.

[foetus]

En C++, il est plus simple de manipuler des fonctions qui retournent un "std::string" plut�t que des fonctions qui retournent "void" avec un param�tre suppl�mentaire "std::string& output"

Bof

Si tu ne retournes pas une r�f�rence, alors tu va cr�er un temporaire (donc une recopie � moins que le compilateur optimise) que tu pourras prolonger sa vie en le prenant en const.

C'est juste un truc obscure que peu de gens savent. Avec un param�tre non const il y a [nettement] moins de comprenette

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
std::string func(/**/) { /**/ }
 
// ...
 
    const std::string ret = func(/**/);

[Pyramidev]

Il est plus simple de manipuler des fonctions qui retournent un "std::string" plut�t que des fonctions qui retournent "void" avec un param�tre suppl�mentaire "std::string& output" dans le sens o�, dans le deuxi�me cas, l'utilisateur de la fonction doit cr�er l'objet "std::string" avant d'appeler la fonction :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
std::string foo();
void bar(std::string& output);
 
int main()
{
    // une ligne :
    std::string fooResult = foo();
 
    // deux lignes, ce qui est moins pratique :
    std::string barResult;
    bar(barResult);
 
    return 0;
}

Si tu ne retournes pas une r�f�rence, alors tu va cr�er un temporaire (donc une recopie � moins que le compilateur optimise) que tu pourras prolonger sa vie en le prenant en const.

C'est juste un truc obscure que peu de gens savent. Avec un param�tre non const il y a [nettement] moins de comprenette

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
std::string func(/**/) { /**/ }
 
// ...
 
    const std::string ret = func(/**/);

Je n'ai pas compris ton message.
A ma connaissance, �a se passe 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
15
16
17
18
19
20
std::string foo() {
    std::string result("car");
    result += "table";
    return result;
}
 
int main()
{
    std::string s1 = foo();
    // En théorie, il peut y avoir deux appels au constructeur de recopie de std::string :
    // -un pour créer le std::string retourné par la fonction à partir de "result" et
    // -un pour initialiser s1 à partir du std::string retourné par la fonction.
    // En pratique, le compilateur fait du NRVO et il n'y a aucun appel au constructeur de recopie de std::string.
 
    const std::string s2 = foo();
    // En théorie, il peut y avoir deux appels au constructeur de recopie de std::string ici aussi, non ?
    // En pratique, le compilateur fait du NRVO et il n'y a aucun appel au constructeur de recopie de std::string.
 
    return 0;
}

Aurais-je tort dans le cas de s2 ?

[foetus]

Dans ce cas

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
std::string foo() {
    return std::string("car");
 
//  return "car";
}

�dit: GotW #88: A Candidate For the �Most Important const�

[Pyramidev]

Ta fonction foo a une instruction de la forme "return <objet temporaire>;"
Ton lien GotW parles du cas o� on initialise une r�f�rence constante � partir d'un objet temporaire.
En prenant en compte ces cas aussi, je pense que �a marche 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
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
std::string foo() {
    std::string result("car");
    result += "table";
    return result;
}
 
std::string bar() {
    return std::string("car");
}
 
int main()
{
    std::string s1 = foo();
    // En théorie, il peut y avoir deux appels au constructeur de recopie de std::string :
    // -un pour créer le std::string retourné par la fonction à partir de "result" et
    // -un pour initialiser s1 à partir du std::string retourné par la fonction.
    // En pratique, le compilateur fait du NRVO (Named Return Value Optimization)
    // et il n'y a aucun appel au constructeur de recopie de std::string.
 
    const std::string cs1 = foo();
    // Idem.
 
    const std::string& crs1 = foo();
    // En théorie, il peut y avoir un appel au constructeur de recopie de std::string
    // pour créer le std::string retourné par la fonction à partir de "result".
    // En pratique, le compilateur fait du NRVO et il n'y a aucun appel au constructeur de recopie de std::string.
    // Dans les deux cas, crs1 réfère à un objet temporaire retourné par la fonction.
 
    std::string s2 = bar();
    // En théorie, il peut y avoir deux appels au constructeur de recopie de std::string :
    // -un pour créer le std::string retourné par la fonction à partir de "std::string("car")" et
    // -un pour initialiser s2 à partir du std::string retourné par la fonction.
    // En pratique, le compilateur fait du RVO (Return Value Optimization)
    // et il n'y a aucun appel au constructeur de recopie de std::string.
 
    const std::string cs2 = bar();
    // Idem.
 
    const std::string& crs2 = bar();
    // En théorie, il peut y avoir un appel au constructeur de recopie de std::string
    // pour créer le std::string retourné par la fonction à partir de "std::string("car")".
    // En pratique, le compilateur fait du RVO et il n'y a aucun appel au constructeur de recopie de std::string.
    // Dans les deux cas, crs2 réfère à un objet temporaire retourné par la fonction.
 
    return 0;
}

Rq : Pour ceux qui veulent plus de d�tails sur RVO et NRVO :

• http://en.cppreference.com/w/cpp/language/copy_elision
• https://isocpp.org/wiki/faq/ctors#re...e-optimization
• https://isocpp.org/wiki/faq/ctors#re...e-optimization

[foetus]

D�sol� pour le d�rangement , c'est ceci qui plante:

invalid initialization of non-const reference of type �std::string& {aka std::basic_string<char>&}� from an rvalue of type �std::string {aka std::basic_string<char>}�

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
std::string foo() {
    std::string result("car");
    result += "table";
    return result;
}
 
 
std::string bar() {
    return std::string("car");
}
 
 
int main()
{
    std::string& s1_1 = foo();
 
    std::string& s2_1 = bar();
 
    return 0;
}

[tontonrichmon]

Merci d'avoir �t� nombreux � m'aider pour mon probl�me, donc au final l'erreur �tait toute simple... la cl� en majuscule.
Sur ce niveau tout est ok du coup.
Par contre, auriez-vous une id�e d'adaptation de ce code pour permettre de crypter des chiffres ?
(des cl�s mac par exemple)