Bonjour,
que pensez-vous de ceci:j'ai trouvé ça dans cette page:https://cplusplus.com/reference/istream/istream/seekg/Code:
1
2
3 char * buffer = new char [length]; /code/ delete[] buffer;
Version imprimable
Bonjour,
que pensez-vous de ceci:j'ai trouvé ça dans cette page:https://cplusplus.com/reference/istream/istream/seekg/Code:
1
2
3 char * buffer = new char [length]; /code/ delete[] buffer;
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:
Et bing, tu as une fuite mémoire!Code:
1
2
3 char* buffer = new char[length]; double d = std::stod( "hello" ); // => exception et le delete n'est jamais fait! delete[] buffer;
Il a plein d'autres manières possible par exemple:
Code:
1
2 std::vector<char> buffer(length); /*code*/
comment charger un tampon en vector depuis un fichier? Avec une boucle?
merci pour la réponse.
Si je compile ceci:ça donne à la compilation: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; }
une idée?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); | ~~~~~~~~~~~^~~
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
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.
ça donne: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; }
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*
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]<<' ';
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 ,
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; }
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.
ç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>>.Citation:
que me conseilles-tu pour ajouter les octets du fichier dans un string?
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".
Ce n'était qu'un exemple pour montrer une simple lecture de fichier, pas la bible.Citation:
ça vient du post que tu m'as conseillé de lire
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)
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?