Discussion :

[el kantara]

salut
j'ai le code suivant:

Code :

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

1
2
3
4
5
6
7
8
 
...
include<string>
string s1="123456789";
string s2="hello1world2elkantara3prés";
for(char c:s1){
std::replace(s2.begin(),s2.end(),c,"\n");
...

et parce que cette boucle(for(char c:s1))est fonctionne en mode (c++11);
je veux une quelque chose qui fait le même travaille de for mais dans les autre mode non pas c++11;
parce que j'utilise visuel studio 2010 qui ne supporte pas ce mode ;et ca c'est un exercice d'un prof qui demande un code n'utilise pas c++11!!
alors s'il vous plait est ce qu'il ya une solution ?

[Iradrille]

Je me permet juste de rajouter qu'utiliser un code sans comprendre ce qu'il fait n'est clairement pas la meilleure façon d'apprendre.
Comprends la ligne qui te poses problème (for(char c: s1)) et tu pourras la remplacer très simplement.
voir ici par exemple.

edit:
La première chose qu'on apprend en info c'est "RTFM" (perso c'était les premiers mots de mon prof de c++).
Et à l'heure actuelle avec le développement d'Internet ya tellement de doc partout sur à peu près tous les problèmes possibles et imaginable, que c'est probablement le meilleur conseil que j'ai reçu.

[Médinoc]

En gros, tu veux traduire ce for de C++11 en C++98?

Eh bien la traduction mot-à-mot, ça doit être un truc du genre:

Code C++ :

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

1
2
3
4
5
6
7
8
9
10
#include<string>
using namespace std;
...
 
string s1="123456789";
string s2="hello1world2elkantara3prés";
for(string::iterator it=s1.begin() ; it!=s1.end() ; ++it)
{
	char c = *it;
	std::replace(s2.begin(),s2.end(),c,"\n");

Par contre, il doit y avoir plus "efficace" qu'un itérateur pour parcourir une std::string.

[Gugelhupf]

Je pense que la solution avec les itérateurs doit plaire aux profs (ils aiment tellement se compliquer la vie).

Une astuce en C++11 pour cette boucle for serait d'utiliser la référence pour éviter les copies :

Code :

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

1
2
3
string s1 = "123456789";
for(char &c:s1){
    // Instructions

Et si lecture seul :

Code :

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

1
2
3
string s1 = "123456789";
for(const char &c:s1){
    // Instructions

[gbdivers]

Je vois pas très bien en quoi utiliser les itérateurs complique la vie Ecrit le code sans itérateur, tu verras que c'est pas plus simple

Et ton code avec référence n'a pas de sens pour un char

[Gugelhupf]

Et ton code avec référence n'a pas de sens pour un char

Bonjour,

Pourquoi n'aurait-t-il pas de sens ?

Voici un exemple de code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include <string>
#include <iostream>
using namespace std;
 
 
int main(){
    string s1 = "123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789";
    for(char c : s1){
        cout<<c<<endl;
    }
    return 0;
}

Sans référence : 3022Ko (test ici).
Avec référence : 2988Ko (test ici).

J'ai répété l'opération plusieurs fois avec une nouvelle opération et j'obtiens les mêmes chiffres, je ne suis sur de rien, mais il me semble qu'on évite la copie et économise de la mémoire.

[Neckara]

J'ai répété l'opération plusieurs fois avec une nouvelle opération et j'obtiens les mêmes chiffres, je ne suis sur de rien, mais il me semble qu'on évite la copie et économise de la mémoire.

Il me semble que derrière les références se cache un pointeur.

Or la taille d'un pointeur est bien supérieur à celle d'un char.

Je pense que le résultat viendrait plutôt d'une optimisation du compilateur.
En effet, je suppose que pendant le parcours on reçoit une référence sur l'élément et non une copie (sinon utiliser une référence dans un for serait une aberration) ainsi le compilateur, plutôt que de créer une nouvelle référence, utilise celle retournée (?)

C'est à dire que je pense que pour :

Code :

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

for(char c : maString)

On exécute un code du type :

Code :

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

1
2
3
//pour chaque element de maString
       c = maString[i]; //maString[i] retournant une référence (version de operator[] non constant).
//fin pour

[gbdivers]

Alors, 34 octets comme économie, on est quand même dans la micro optimisation, ça me semble pas suffisant pour justifier une version ou une autre du code

Ensuite, est tu sur que la différence vient de la référence et pas ailleurs ?

Le code asm généré est le même pour les 2 boucles (si je pose la question... ) Comme le dit Neckara, une référence peut correspondre à un pointeur au niveau assembleur. Ou pas.

Code :

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

1
2
3
int a;
int& b = a; // b est un alias de a et n'a pas d'empreinte mémoire
void foo(int &c); // c sera stocké dans le Pile, similaire à un pointeur (adresse)

Le range-based for utilise de toute façon les fonctions begin() et end() donc travaille sur des itérateurs (similaire à des pointeurs) (on a un beau "call __ZN9__gnu_cxx17__normal_iteratorIPcSsEppEv" dans l'asm généré par gcc)

La différence est en amont, sur la gestion de la chaîne et de cout. Regarde les codes suivante : http://ideone.com/vvHxAP et http://ideone.com/r203JX. L'empreinte mémoire est la même (2988 ko), avec et sans référence.

[Ehonn]

Regarde les codes suivante : http://ideone.com/vvHxAP et http://ideone.com/r203JX. L'empreinte mémoire est la même (2988 ko), avec et sans référence.

En lisant les messages précédents, j'ai testé la même chose mais je n'avais pas la même conclusion...

Si on remplace le const char c par char const c, l'empreinte mémoire est memory: 3032 ko... http://ideone.com/xNiUaC
Un explication ? (la règle sur le const : http://cpp.developpez.com/faq/cpp/?p...har_const_char)

[Joker-eph]

Et ton code avec référence n'a pas de sens pour un char

Le fait de pouvoir le modifier directement dans la chaîne ?

[Gugelhupf]

J'avoue ne pas avoir compris la phrase suivante :

Et ton code avec référence n'a pas de sens pour un char

Maintenant je suis peut-être allé trop vite en disant qu'on faisait de l'économie en mémoire avec les références pour ce qui est des char.

Ici un char doit faire 1 octet et un pointeur sur un char 4 octets ( voyez avec sizeof() test ici ), mais ça ne s'accumule pas à chaque itération, donc l'économie en mémoire ne se situe pas à ce niveau.

Lorsqu'on passe un objet sans référence, je pense qu'on effectue une copie de cet objet :
Sans référence : char de retour (1 octet) + étape de la copie + char de copie (1 octet).
Avec référence : char de retour (1 octet) + pas de copie + pointeur char (4 octets).
Et sa se répète, 2 octets pour le premier, 5 octets pour l'autre.

Les char ne sont pas très intéressants ici, mais si on a un plus gros objet comme dans l'exemple suivant :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
using namespace std;
 
class Type{
    int v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13v, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30; 
};
 
int main(){
    cout<<sizeof(char)<<endl; // 1 octet
    cout<<sizeof(char*)<<endl; // 4 octets
    cout<<sizeof(Type)<<endl; // 120 octets !!!
    cout<<sizeof(Type*)<<endl; // 4 octets
    return 0;
}

Test ici.

Alors je pense que :
Sans référence : Type de retour (120 octets) + étape de la copie + Type de copie (120 octets).
Avec référence : Type de retour (120 octets) + pas de copie + pointeur Type (4 octets).
Et sa se répète, 240 octets pour le premier, 124 octets pour l'autre.

Donc pour finir, je ne sais pas ce que génère le code assembleur, mais logiquement, le passage par référence permet d' "aller plus vite" en évitant la phase de copie.

N'hésitez pas à me rectifier sur ce sujet.

[gbdivers]

Le fait de pouvoir le modifier directement dans la chaîne ?

Oui bien sur. Mais :
1. dans le contexte du problème présenté, le char n'est pas modifié
2. l'utilisation ou non d'une référence se justifie par le fait de modifier ou non la variables, pas l'empreinte mémoire ici (qui est la même)

@Gugelhupf
Hum, ça devient compliqué, tu parles de plusieurs choses différentes...
Bon, ma phrase n'était peut être pas claire au départ

1. Comme je l'ai déjà dit, une référence peut correspondre (en termes d'asm) à un alias (le compilateur utilise 2 noms pour la même chose en mémoire, donc pas de mémoire réservée par la référence) ou à une adresse (pointeur, et donc avoir un coût en mémoire)

2. La copie d'un seul char (ou de n'importe quelle type primitive) ou d'un référence/pointeur, c'est la même chose. Nos systèmes ne bossent pas en 8 bits et tu ne peux pas faire une copie de 8 bits, mais en général 32/64 (sur les PC "classiques", c'est pas forcement vrai sur de l'embarqué).

Donc, dans le cas où une référence est traitée comme un pointeur par le compilateur, la copie d'une référence/pointeur ou un seul char, c'est pareil

3. Tu essaies de montrer avec ton code que pour un type non primitif de taille importante, le passage par référence est moins coûteux qu'une copie ? Là, on est d'accord sans problème

4. Par contre, comme je l'ai déjà dit, dans le range-based for, les itérateurs sont utilisés, donc pas de différence entre une référence constante et une copie, même pour un type non primitif
Par exemple : http://ideone.com/zhmPc0 et http://ideone.com/tNd7ej

J'espère que c'est plus clair ?


(5. je sais pas très bien à quoi correspond ce "memory" retourné par ideone, ni comment c'est calculé. Il faut parfois se méfier des mesures de mémoire (par exemple par le gestionnaire de taches de Windows) qui ne sont pas fiables. Mais la mesure est peut être correcte avec ideone, mais a prendre avec du recul)

[Gugelhupf]

Merci pour tes explications gbdivers.

Donc d'après ton point n°2, lorsque l'on travaille avec des petits objets comme les variables primitives (char, int, double etc...), il n'y a pas une grosse différence entre "avec" ou "sans" référence pour la consommation mémoire.

Pour le point n°3, ok, mieux vaut travailler avec les références pour les gros objets, c'est "moins couteux"... moins couteux en mémoire ou en vitesse d'exécution des instructions ?

Enfin, ne penses-tu pas que passer par des références augmente la vitesse d'exécution des instructions ?
PS: Je t'avouerais que je ne sais pas exactement ce qui se cache derrière les range-based for ou les itérateurs, mais comme la syntaxe est plus longue avec les itérateurs, je préfère les éviter.

[Médinoc]

Cela dépend du coût de la copie, et des registres disponibles pour garder en cache l'adresse "finale" de l'objet. Généralement si la copie inclut une allocation dynamique et copie de tableau, (ex: std::vector<> et std::string si elles ne sont pas implémentées en copy-on-write), la référence sera plus performante.

[Gugelhupf]

Bonjour,

Donc si je résume :

Pour les petits objets, les variables primitives (char, int, float...) :

• Performance mémoire : équivalente avec ou sans référence.
• Performance vitesse : équivalente avec ou sans référence.

Utiliser les références si besoin de modifier le contenu d'un tableau.


Pour les gros objets :

• Performance mémoire : privilégier les références pour éviter la copie en mémoire.
• Performance vitesse : privilégier les références pour éviter la phase de copie.

?

Merci

[Médinoc]

En gros, c'est ça.