1
2
3
char*  buffer = new char[length];
double d = std::stod( "hello" ); // => exception et le delete n'est jamais fait!
delete[] buffer;
Et bing, tu as une fuite mémoire!

Il a plein d'autres manières possible par exemple:

	
Code: [Affichage]
	
1
2
std::vector<char>  buffer(length);
/*code*/
	
Code: [Affichage]
	
1
2
3
4
5
6
7
8
9
10
11
main.cpp: In function ‘int main()’:
main.cpp:8:10: error: cannot convert ‘std::vector<char>’ to ‘std::basic_istream<char>::char_type*’ {aka ‘char*’}
    8 |   F.read(tampon,taille);
      |          ^~~~~~
      |          |
      |          std::vector<char>
In file included from /usr/include/c++/11/fstream:38,
                 from main.cpp:1:
/usr/include/c++/11/istream:486:23: note:   initializing argument 1 of ‘std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::read(std::basic_istream<_CharT, _Traits>::char_type*, std::streamsize) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_istream<_CharT, _Traits>::char_type = char; std::streamsize = long int]’
  486 |       read(char_type* __s, streamsize __n);
      |            ~~~~~~~~~~~^~~
une idée?
						Si tu ne respecte pas les type de données en argument des fonctions, ca ne peut pas compiler.

La fonction read attend un tableau de caractères en entrée:

https://en.cppreference.com/w/cpp/io/basic_istream/read

Tu veux faire quoi exactement ?
						Pour un buffer/tampon, moi, je serais plus sur du std::byte que du "char" tout moisi du C.

https://en.cppreference.com/w/cpp/types/byte
  F.read(p,taille);
  for(int i=0;i<tampon.size();i++)
    std::cout<<tampon[i]<<' '<<std::endl;
  return 0;
  std::vector<std::byte>tampon(taille);
  std::byte* p=tampon.data();
  F.read(p,taille);
  for(int i=0;i<tampon.size();i++)
    std::cout<<tampon[i]<<' '<<std::endl;
  return 0;
ça donne:

	
Code: [Affichage]
	
1
2
3
4
5
6
7
$ g++ main.cpp -g
main.cpp: In function ‘int main()’:
main.cpp:11:10: error: cannot convert ‘std::byte*’ to ‘std::basic_istream<char>::char_type*’ {aka ‘char*’}
   11 |   F.read(p,taille);
      |          ^
      |          |
      |          std::byte*
						Cela montre que l'utilisation de "std::ifstream.read" n'est pas "bien fait pour" et qu'il faut faire méga gaffe à la manière de l'utiliser.

https://codereview.stackexchange.com...nto-vectorbyte
	
Code: [Affichage]
	
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
#include <iostream>
#include <cstdint>
#include <fstream>
#include <string>
#include <vector>
using bytes = std::vector<std::byte>;
bytes read_block(uint32_t length,
                 const std::string& filename) {
  std::ifstream is(filename, std::ios::binary);
  bytes data;
  data.resize(length);
  is.read(reinterpret_cast<char*>(data.data()), length);
  return data;
int main(){
  std::string nom="toto";
  bytes tampon=read_block(15,nom);
  for(int i=0;i<15;i++)
    std::cout<<tampon[i]<<' ';
  std::cout<<std::endl;
  return 0;
	
Code: [Affichage]
	
1
2
3
4
$ g++ main.cpp
main.cpp: In function ‘int main()’:
main.cpp:23:14: error: no match for ‘operator<<’ (operand types are ‘std::ostream’ {aka ‘std::basic_ostream<char>’} and ‘__gnu_cxx::__alloc_traits<std::allocator<std::byte>, std::byte>::value_type’ {aka ‘std::byte’})
   23 |     std::cout<<tampon[i]<<' ';
						Cela montre qu'afficher du binaire dans la console, c'est pas très fino (caractères non imprimables, séquences d'échappement de terminaux, etc...).

Pourquoi pas utiliser un débogueur ou de "vraies" primitives de logs ,
	
Code: [Affichage]
	
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
#include <iostream>
#include <cstddef>
#include <fstream>
#include <string>
#include <vector>
using bytes = std::vector<std::byte>;
bytes read_block(uint32_t length,
                 const std::string& filename) {
  std::ifstream is(filename, std::ios::binary);
  bytes data;
  data.resize(length);
  is.read(reinterpret_cast<char*>(data.data()), length);
  return data;
int main(){
  std::string nom="toto",sortie="";
  bytes tampon=read_block(15,nom);
  for(int i=0;i<15;i++)
    sortie+=(char)tampon[i];
  std::cout<<sortie<<std::endl;
  return 0;
Casser le thermomètre n'a jamais soigné.

Non, il ne pas faire croire au compilateur qu'on gère la situation quand c'est absolument pas le cas.

Ce n'est pas un problème de typage que vous avez.

Vous devez rendre vos "std::byte" contenant du binaire en un truc contenant des chaines de caractères "imprimables".

C'est l'ambiguïté du char qui fout la merde.

Avec "std::byte", on ne passe pas du binaire au texte sans s'en rendre compte, et c'est très bien.

Si c'est bien du binaire, l'affichage en hexadecimal est bien plus cohérent :

https://stackoverflow.com/questions/9893497/how-to-convert-byte-array-to-hexadecimal-string-in-c

char, c'est bien pour des caractères, pas pour faire du "void*" du pauvre.

P.S.: votre fonction read_byte est une abomination en termes de performance.

Clairement, vos références sur le C++ datent du C with class, non ?

Et évitez de déclarer plusieurs variables par ligne, SVP.
ça vient du post que tu m'as conseillé de lire: https://codereview.stackexchange.com...nto-vectorbyte

que me conseilles-tu pour ajouter les octets du fichier dans un string?
Si c'est du binaire, ne pas utiliser de string mais un std::vector<std::byte>>.

Si c'est du texte et que les conversions automatiques des caractères de fin de ligne, des séquences d'échappement, etc... vous arrange, c'est fonction de l'encodage de votre fichier en entré (ASCII US, UTF-8, BOM ou pas, etc...).

Il y a des primitives dédiées à cela et pas cette antiquité de "std::ifstream".

						je veux bien charger le fichier en entier, mais Il faut que je puisse faire des strings avec car la classe lexical lit les caractères un par un en suivant des diagrammes de transition, et renvoie une unité lexicale, éventuellement avec un attribut en string, de cette unité lexicale.

que me conseilles-tu?