Discussion :

[smag]

Pourquoi peut on passer un char à une fonction g(char&) mais pas un char signed ou non signé et pourquoi cela est possible à une fonction g (const char&)?

[Aurelien.Regat-Barrel]

C'est pas clair ta (tes ?) question(s).

[Ti-R]

Parce que "char" != "unsigned char"

Donc si tu as une fonction

Code :

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

1
2
 
void g(char&);

Elle est différente d'une

Code :

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

1
2
 
void g(unsigned char&);

Car même si tout est stocké sur 1 octet, le traitement de l'information n'est pas le même !

[Laurent Gomila]

Si j'ai bien compris, la réponse à ta question serait que dans le cas d'une référence constante la conversion implicite entre types peut s'appliquer, mais pas dans le cas d'une référence non-constante. Ce qui s'explique par le fait que dans le cas où le compilo doit réaliser une conversion, c'est un objet temporaire qui est passé à la fonction et il ne peut donc pas être modifié dans celle-ci (ie. pris en référence non-constante).

Même combat que ça :

Code :

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

1
2
3
4
5
void F1(std::string& s) {}
void F2(const std::string& s) {}
 
F1("hello"); // Pas ok
F2("hello"); // Ok

[smag]

Si j'ai bien compris, la réponse à ta question serait que dans le cas d'une référence constante la conversion implicite entre types peut s'appliquer, mais pas dans le cas d'une référence non-constante. Ce qui s'explique par le fait que dans le cas où le compilo doit réaliser une conversion, c'est un objet temporaire qui est passé à la fonction et il ne peut donc pas être modifié dans celle-ci (ie. pris en référence non-constante).

Même combat que ça :

Code :

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

1
2
3
4
5
void F1(std::string& s) {}
void F2(const std::string& s) {}
 
F1("hello"); // Pas ok
F2("hello"); // Ok

Ok c un peu plus clair.Alors maintenant pourquoi le cas qui marche avec g(char&) est : char c; g(c) ? Pourquoi les signé et no signé ne passe t il pas avec g(char&) mais avec h(contst char&)?

[Laurent Gomila]

Ok c un peu plus clair.Alors maintenant pourquoi le cas qui marche avec g(char&) est : char c; g(c) ? Pourquoi les signé et no signé ne passe t il pas avec g(char&) mais avec h(contst char&)?

En gros, t'as rien compris à ce que je t'ai dit en fait

Est-ce que mon exemple avec std::string et const char* te parle ? Si oui, et bien remplace std::string par char, et const char* par unsigned char, et tu retombes précisément sur ton problème. C'est la même chose.
Si tout ça ne te parle pas, ben ma foi désolé je vois pas comment l'expliquer autrement

[Ti-R]

Moi je propose de voir concrêtement ton code, ainsi que ton problème.

Tu écris ton problème en C++.
Et on essayera de t'expliquer

par exemple
code ok

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
 
void g(char &a)
{
a='f';
}
 
int main(int argc, char *argv[])
{
    char b('c');
    g(b);
    cout << b << endl; // tu verras 'f'
 
    system("PAUSE");
    return EXIT_SUCCESS;
}

code pas ok, ne compile pas car "unsigned char" ne peut être passé en paramètre à la place de "char"

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
void g(char &a)
{
a='f';
}
 
int main(int argc, char *argv[])
{
    unsigned char b('c');
    g(b);
    cout << b << endl;
    system("PAUSE");
    return EXIT_SUCCESS;
}

code ok

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
 
 
void g(unsigned char &a)
{
a='f';
}
 
int main(int argc, char *argv[])
{
    unsigned char b('c');
    g(b);
    cout << b << endl;
    system("PAUSE");
    return EXIT_SUCCESS;
}

[JolyLoic]

Peut être une précision pour faciliter la compréhension : signed char, char et unsigned char constituent non pas 2, mais 3 types différents (contrairement par exemple à int ou signed int == int).

[smag]

ok ça j'ai bien compris
maquestion est :

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
 
void f(char x){}
void g(char& x_ref){}
void h(const char& const_x_ref){}
 
 
int main()
{
 
    char c;
    unsigned char uc;
    signed char sc;
 
 
    f('a');
    f(49);
    f(3300);
    f(c);
    f(uc);
    f(sc);
  //  g('a');
  //  g(49);
  //  g(3300);
    g(c);
  //  g(uc);
  //  g(sc);
    h('a');
    h(49);
    h(3300);
    h(c);
    h(uc);
    h(sc);
}

Pourquoi tout passe en référence constante alors que ça passe pas en réf?
En gros unsigned de char ne passe pas à char& mais passe à const char&!!! Pourquoi?

[Balise [code] ajouté par netah_25 - Merci d'y penser a l'avenir]

[JolyLoic]

Comme l'a expliqué Loulou, pour passer de unsigned char à char, il faut faire une conversion, et donc créer un objet qui n'est plus unsigned char. Cet objet est temporaire, et n'apparaît nulle part explicitement dans le code.

Il n'est pas autorisé de passer un objet temporaire à une référence non constante. En effet, s'il y a une référence non constante, c'est qu'on veut modifier l'objet qui est passé, et si celui si est temporaire, fugitif, le modifier ne sert à rien.

[smag]

ça y est , j'ai compris!!
Enfin