char * buffer = new char [length];

Version imprimable

09/02/2023, 14h22
emmesse

char * buffer = new char [length];
Bonjour,

que pensez-vous de ceci:
Code:

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/
09/02/2023, 14h41
Bousk

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

Bonjour,

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

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:

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

09/02/2023, 15h19
emmesse

comment charger un tampon en vector depuis un fichier? Avec une boucle?
09/02/2023, 15h52
dalfab

Citation:

Envoyé par matser

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.

merci pour la réponse.

Si je compile ceci:

Code:

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:

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?

09/02/2023, 16h31
Bousk

https://cplusplus.com/reference/vector/vector/data/
09/02/2023, 16h36
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 ?
09/02/2023, 16h51
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

Merci Boosk, ça marche:

Code:

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;
}

Citation:

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

Code:

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:

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*

09/02/2023, 17h37
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

Code:

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:

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

09/02/2023, 18h37
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 ,
09/02/2023, 18h45
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?

que pense-tu de ça:

Code:

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;
}

09/02/2023, 19h15
bacelar

GG, un cast C bien crade, en C++ !!! :aie:
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.
09/02/2023, 19h33
emmesse

Citation:

Envoyé par bacelar

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?
09/02/2023, 21h49
bacelar

Citation:

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

Citation:

ç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)
10/02/2023, 07h32
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?

Par exemple:
Code:

1 2 3 4 5 6 7 std::vector<std::string> data; std::string line; std::ifstream input{ "monFichier.txt" }; while(std::getLine(input, line)) { data.push_back(line); }
Il ne te reste plus qu'a analyser le contenu de data.

10/02/2023, 18h11
bacelar

Espérant que les réglages par défaut de "std::ifstream" soit compatible avec l'encodage des fichiers en entré (BOM, UTF-8, CRLF vs CR vs LF, etc...).

Je comprends pas trop votre fixette de passer par un std::string qui va faire plus "de bruit" que résoudre les "problèmes".
11/02/2023, 02h04
deedolith

Ce n'est qu'un exemple.
A adapter selon les besoin.

Le principe est la:
- Charger le fichier brut dans un conteneur.
- Oublier le fichier.
- Analyser (parser) le conteneur pour instancier les classes métier.