[Mic32768]

Salut, je suis relativement nouveau dans le C++ et j'avais quelques questions:

1-Quelle est la manière la plus "propre" de convertir un char* en wchar_t*?

La raison est que j'essaie d'utiliser la fonction open pour pouvoir traiter un fichier à l'aide de la procédure suivante:

Code:

void DumpTabInFile(char * cTableau,const int & iTailleTableau,const wchar_t * cFilename)

{
ofstream fFichier;
fFichier.open(cFilename,ios::binary | ios::out | ios::trunc);
fFichier.write(cTableau,iTailleTableau);
fFichier.close();
}

Cette fonction que j'appelle comme suit:

DumpTabInFile(cTableau, iTailleTableau, "h2.txt");

Mais l'erreur suivante apparaît lors de la compilation:

Error 1 error C2664: 'DumpTabInFile' : cannot convert parameter 3 from 'const char [7]' to 'const wchar_t *' c:\documents and settings\michael\mes documents\visual studio 2005\projects\file_challenge4\file_challenge4\main.cpp 74


2-Lorsque on a une fonction simple comme ça:

Code:

void show(int nombre)
{
     cout << nombre << endl;
}

Est-il préférable de passer 'nombre' par référence (ou pointeur) plutôt que par valeur?

Du genre:

Code:

void Show(const int & nombre)

{
    cout << nombre << endl;
}

3-Est-il mieux de passer les paramètres par référence ou par pointeurs lorsque on a le choix(pour une fonction comme celle juste en haut)?

Merci de votre précieux temps
Edit: Finalement, j'ai une autre question..

Admettons qu'on créé un tableau à l'aide de l'allocation dynamique de la manière suivante:

Code:

int * tableau;
tableau = new int[5];

Est-il possible de supprimer seulement une petite partie de ce tableau et le réutiliser ensuite? Par exemple, faire en sorte qu'au lieu d'avoir 5 emplacements, il n'en ait que 4?

[neoflo]

2.

Pour un int, le passer par paramètre ou par référence ou par pointeur sera de la même efficacité.

Le pointeur est placé sur la pile d'appel ou le paramètre aussi. Mais en général, la taille d'un pointeur est le même que celle d'un entier ce qui fait que cela ne change pas grand chose.

Dans le cas de structure dont la taille n'est pas connu (ou de classe), il est souvent très recommandé de le passer par référence ou par pointeur (pour les raisons cités ci-dessus). Le fait de passer par pointeur, dans le prototype ne permet pas de montrer que l'objet ne sera pas modifié (alors qu'avec un const& i si).

Dans certains cas, on se retrouve obligé de passer un int par pointeur ou référence (dans le cas ou l'on souhaite modifier la valeur).



Il y a certains surcharges d'opérateurs ou il est également préférable (même obligatoire) d'utiliser une référence qu'un pointeur.


3. Pour le redimensionnement des tableaux. Directement comme ça, il n'est pas possible de le faire. Il faut passer par la STL (standard templates library) et utiliser des std::vector<> avec std::vector<>resize();

Une question, pourquoi as-tu besoin de faire cela ? En général, il n'y a vraiment pas souvent besoin. Il y a toujours eu des types abstraits mieux adapté pour ce que j'avais à faire que d'utiliser ce type de chose.

[Mic32768]

Thanks pour l'info neoflo!

En ce qui concerne wchar_t, je vais donner plus de détails:

Code:

void DumpTabInFile(char * cTableau,const int iTailleTableau)
{
	ofstream fFichier;
	fFichier.open("huge_cha.bin",ios::binary | ios::out | ios::trunc);
	fFichier.write(cTableau,iTailleTableau);
	fFichier.close();
}

Cette procédure fonctionne très bien mais le problème est avec la fonction open(). Je voudrais passer le nom du fichier en paramètre(bien plus pratique) mais peu importe le type que je mets(string, wstring, char..), j'ai une erreur de conversion semblable à celle-ci:

Error 1 error C2664: 'DumpTabInFile' : cannot convert parameter 3 from 'const char [7]' to 'const wchar_t *' c:\documents and settings\michael\mes documents\visual studio 2005\projects\file_challenge4\file_challenge4\main.cpp 74

On m'a parlé d'un reinterpret_cast et de quelque chose qui ressemblait à ça: ctype<wchar_t>(locale()) mais je ne sais absolument pas comment l'utiliser.

Merci d'avance!

[neoflo]

Le prototype de open est de la forme : const char*.

Tu ne peux pas faire ça :

Code:

void DumpTabInFile(char * cTableau, int  iTailleTableau,const char * cFilename)

{
ofstream fFichier;
fFichier.open(cFilename,ios::binary | ios::out | ios::trunc);
fFichier.write(cTableau,iTailleTableau);
fFichier.close();
}

Et appeler par :

Code:

DumpTabInFile(pointeur, 12, "machin.txt");

Je te signale en passant qu'en général, les conventions de codage (non officiel) en C et C++ disent que les fonctions commencent par une minuscule (les programmeurs font en général ça).

[Mic32768]

Mais dans ce cas comment on s'y prend pour utiliser cette fonction en passant le nom du fichier en paramètre?

C'est là que je bloque

[neoflo]

T'as peut être pas vu la dernière modif :

Comme ça qu'on fait :

Code:

DumpTabInFile(pointeur, 12, "machin.txt");

[Mic32768]

Je vais essayer ça.. Mais tu avais écrit: "tu ne peux pas faire ça"

En tout cas, je regarde ça tout de suite.

[neoflo]

quand j'ai dit : Tu ne peux pas faire ça

C'était une question Car tu aurais peut être absoluement voulu utiliser qqch d'autres que char*

[Mic32768]

Haha MERCI! J'ai essayé ce que tu m'as dit et ça fonctionne parfaitement! Dire que ça fait 2 jours que je me casse la tête sur quelque chose d'aussi simple.. Le wchar_t n'avait aucun rapport en plus.. C'est toujours cool de programmer quand ça fonctionne

[neoflo]

Par rapport à ta question 2, tu peux lire : http://www.vuibert.com/DOC/26-pass_cplus2.pdf (je suis en train de le lire).

Ils disent notamment :

L’emploi du passage par r´ef´erence en vue de modifier la valeur d’objets de la fonction
appelante est le sujet d’une controverse entre programmeurs. Les uns y voient une
commodit´e int´eressante, les autres le d´econseillent. Ces derniers font valoir que le
seul examen du code de la fonction appelante ne permet plus de savoir si la valeur des
arguments d’appel risque d’ˆetre modifi´ee. Il faut pour cela se reporter au prototype de
la fonction appel´ee qui peut se trouver dans un fichier en-tˆete. Ils recommandent donc
de n’utiliser le passage par r´ef´erence que pour des fonctions qui ne modifient pas les
arguments d’appel 4 ou lorsque l’objet `a transmettre est de grande taille, le passage
par r´ef´erence ´evitant la recopie sur la pile.

[Mic32768]

Ouais donc dans le fond, ça ne donne pas grand chose de faire passer, en paramètre,  un int par référence. Autrement dit, faut utiliser la référence seulement quand on a de gros paramètres.