Discussion :

[emmesse]

Bonjour,

que pensez-vous de ceci:

Code :

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

1
2
3
char * buffer = new char [length];
/code/
delete[] buffer;

j'ai trouvé ça dans cette page:https://cplusplus.com/reference/istream/istream/seekg/

[Bousk]

C'était très bien y'a 40 ans, depuis on a inventé std::vector.

[dalfab]

Bonjour,

C'est une utilisation d'un autre temps. Exemple:

Code :

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

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 :

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

1
2
std::vector<char>  buffer(length);
/*code*/

[emmesse]

comment charger un tampon en vector depuis un fichier? Avec une boucle?

[dalfab]

comment charger un tampon en vector depuis un fichier? Avec une boucle?

Un std::vector c'est un buffer comme un autre. Le choix de la manière dépend du besoin.

[emmesse]

merci pour la réponse.

Si je compile ceci:

Code :

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

1
2
3
4
5
6
7
8
9
10
#include <fstream>
#include <vector>
 
int main(){
  std::ifstream F("toto");
  int taille=15;
  std::vector<char>tampon(taille);
  F.read(tampon,taille);
  return 0;
}

ça donne à la compilation:

Code :

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

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?

[Bousk]

https://cplusplus.com/reference/vector/vector/data/

[deedolith]

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 ?

[bacelar]

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

[emmesse]

Merci Boosk, ça marche:

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 <fstream>
#include <vector>
#include <iostream>
 
int main(){
  std::ifstream F("toto");
  int taille=15;
  std::vector<char>tampon(taille);
  char* p=tampon.data();
  F.read(p,taille);
  for(int i=0;i<tampon.size();i++)
    std::cout<<tampon[i]<<' '<<std::endl;
  return 0;
}

[emmesse]

Pour un buffer/tampon, moi, je serais plus sur du std::byte que du "char" tout moisi du C.

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
#include <fstream>
#include <vector>
#include <iostream>
#include  <cstddef>
 
int main(){
  std::ifstream F("toto");
  int taille=15;
  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 :

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

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*

[bacelar]

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

[emmesse]

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
#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 :

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

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]<<' ';

[bacelar]

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 ,

[emmesse]

c'est que voudrais ajouter les octets du fichier à des string. Le fichier est un fichier texte. C'est si pourri que ça char?

[emmesse]

que pense-tu de ç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
#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;
}

[bacelar]

GG, un cast C bien crade, en C++ !!!
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.

[emmesse]

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

ç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?

[bacelar]

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".

ça vient du post que tu m'as conseillé de lire

Ce n'était qu'un exemple pour montrer une simple lecture de fichier, pas la bible.

Si vous ne faites pas une API à la SAX qui doit gérer des fichiers XML de plusieurs dizaines de giga, lisez tout le fichier d'un coup. (oui, on vous l'a proposé depuis le début)

[emmesse]

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?