Mettre des octets d'un fichier dans un string

Résolu
ddraper
Messages postés
34
Date d'inscription
dimanche 18 septembre 2011
Statut
Membre
Dernière intervention
14 janvier 2012
- 18 sept. 2011 à 23:04
ddraper
Messages postés
34
Date d'inscription
dimanche 18 septembre 2011
Statut
Membre
Dernière intervention
14 janvier 2012
- 4 oct. 2011 à 19:02
Bonjour à tous !
Malgrès mes recherches, je suis toujours bloqué.

En fait, je ne sais pas comment mettre les octets d'un fichier quelconque dans une variable string.
Oublions la méthode d'un tableau de char, car traduire des caractères en octets selon la langue utilsée ne me parait
pas judicieux (portabilité, endianess, etc).


Bref, existe-t-il une classe, une fonction ou quoi que ce soit en c++ qui permet de mettre le contenu binaire ("0 et 1")
d'un fichier dans une variable string (sans passer par du texte)? Et dans les autres langages de programmation'Est-ce
possible en java?


Si vous avez un bout de code expliqué,
une fonction ou quoi que ce soit, je prends!!!!




Merci d'avance pour vos réponses pédagogiques !

70 réponses

ddraper
Messages postés
34
Date d'inscription
dimanche 18 septembre 2011
Statut
Membre
Dernière intervention
14 janvier 2012

28 sept. 2011 à 18:04
oui, un octet à chaque fois.

"Ton format a-t-il une taille fixe ? "
Le format de quel variable ? Pour celle qui contient la suite binaire (0 et/ou 1) c'est toujours un multiple de 8 (un octet donc).
En fait, tout est basé sur un multiple de 8, un ensemble d'octet en fait.
0
ddraper
Messages postés
34
Date d'inscription
dimanche 18 septembre 2011
Statut
Membre
Dernière intervention
14 janvier 2012

28 sept. 2011 à 20:13
merci mais c'est pas du tout ce que je demande ...

Désolé de t'être fatigué pour rien, mais moi je cherche l'erreur dans mon code. Je ne cherche pas un autre code.

Logiquement mon code marche, mais j'ai oublié ou mal fait quelque chose. Merci de m'indiquer où mon code contient une erreur!
0
cs_LA_Tupac
Messages postés
305
Date d'inscription
jeudi 29 avril 2004
Statut
Membre
Dernière intervention
18 janvier 2012
1
28 sept. 2011 à 20:33
Logiquement mon code marche

Rien n'est moins sûr
Il est vrai que le code que tu as pondu n'a aucune chance de fonctionner, tu copie des valeurs sans vraiment savoir ce que tu manipules, pointeur, ref, array ... comme ce
g=aa.at(ii);

C'est faux a coup sur, std::string.at() renvoie un char... du coup g ne dépassera pas 1 caractère.
Y'en a pas mal d'autres comme juste après la ligne ci-dessus, un block {} sans utilité...
Sans être méchant, il faut voir les fondamentaux.
Comme disait Pingu, même les découpages de fonctions ne sont pas acquis.
J'étais entrain de pondre les fonctions "charenoctet" "octetenchar" pour les poster quand j'ai vu que Pingu m'avait pris de vitesse. Mais c'est évident qu'il fallait commencer par ça
Je te conseille de travailler le découpage en fonctions, puis en class et enfin les types de données, les tableaux, et les pointeurs et références.
Tu aura plus de recul sur ton code et le fonctionnement mémoire qui va avec. (et ouai c'est pas du C# ou du java le c++ faut mettre les mains dans le cambouis )

ps: ceci n'est pas un troll.
0
cs_LA_Tupac
Messages postés
305
Date d'inscription
jeudi 29 avril 2004
Statut
Membre
Dernière intervention
18 janvier 2012
1
28 sept. 2011 à 20:34
reps: très joli ton code Pingu c'est très pro
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
cptpingu
Messages postés
3834
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
20 octobre 2021
124
29 sept. 2011 à 00:30
C'est faux a coup sur, std::string.at() renvoie un char... du coup g ne dépassera pas 1 caractère.


C'est complètement sous efficient de stocker un char dans un string, puis de trouver la valeur entière en passant par un std::istringstream, alors qu'on peut directement faire un: gchiffre = aa[ i] - '0';
Néanmoins ça reste juste, car un char rentre dans un std::string (ta remarque reste valable, il y avait de toute façon un souci à ce niveau là).

J'étais entrain de pondre les fonctions "charenoctet" "octetenchar" pour les poster quand j'ai vu que Pingu m'avait pris de vitesse.

Oupss... :D

très joli ton code Pingu c'est très pro

Merci :p

Pas grand chose à rajouter de plus que LA_Tupac, au vu du code, j'ai préféré tout revoir que de partir sur une base bancale.
Au niveau de ton code:
- Si on ne donne pas de fichier, ça plante.
- Pour tester, j'ai crée un fichier qui contient: "a" (juste un caractère).
Je me suis alors rendu compte que ton "bb" (qui vaut 8 * jj - 1) commençait à 7. Donc au lieu de faire un subtr(0, 8) au premier tour, tu fais un substr(7, 8). Et donc tu es décalé...
Je n'ai pas osé investiguer plus loin, le code pique vraiment au yeux (trop de variable de partout, pas de découpage en petite fonction).



________________________________________________________________________
Historique de mes créations, et quelques articles:
[ http://0217021.free.fr/portfolio http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée si un post répond à votre question
0
ddraper
Messages postés
34
Date d'inscription
dimanche 18 septembre 2011
Statut
Membre
Dernière intervention
14 janvier 2012

29 sept. 2011 à 16:17
Tout d'abord, mea culpa à CptPingu. Je ne pouvais savoir que mon bout de code était si mauvais. Merci de m'avoir corriger de A à Z!

En lisant ton code, j'ai pu apprécié le fruit d'un travail bien fait. Tes fonctions et variables telles que "restoreFormat" et "binFormat" m'ont procuré une joie indescriptible !! Bien que je comprenne leur usage, et non leur sens propre,tout ça reste du charabia pour moi ...
Effectivement, j'ai très peu de base concernant les flux sur c++. Faut bien dire que je ne connais que les 100 premières pages d'un livre qui en fait 8OO . Donc, sache que c'est avec milles excuses et milles merci que je te remercie.

Pour la petite histoire, je voulais (et veux toujours) vérifier par la pratique un système de cryptage fait maison (qui est sensé coder une suite binaire). Le système en lui-même nécessitait de connaitre le minimum en programmation (variable, fonction et comment les lier entre eux ou plutôt comment manipuler des 0 et 1 dans un string). Pour faire simple, je sais travailler des 0 et 1 dans un string. Mais, je n'avais pas la méthode pour prendre les bits d'un fichier pour les crypter. Maintenant, grâce à vous 2, je sais le faire.

Néanmoins, je ne sais toujours pas créer un fichier de sortie à partir de ma variable string de départ (que j'aurais cryptée entre temps). Donc, pouvez-vous (CptPingu, LA_Tupac ou tout autre intervenant) me créer et copier-coller un bout de code qui à une variable string "binFormat" de départ ( taille fixe=un multiple 8 comme d'hab) me créer un fichier de sortie (qui contient les bits de ma chaine, comme pour prendre les bits d'un fichier et les mettre dans un string mais ici l'inverse) ?

Je vois encore le chemin que j'ai à parcourir dans l’apprentissage du c++ ... Et c'est avec la plus grande espérance que je vous demande un code qui crée un fichier à partir de bits dans un string ... et vous aurez la personne la plus heureuse du monde.

En espérant que mon ton mielleux pourra y faire quelque chose,

Bonne journée/soirée !
0
cptpingu
Messages postés
3834
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
20 octobre 2021
124
29 sept. 2011 à 16:45
ça reste du charabia pour moi

Pointe chaque partie que te poses problème, même après relecture et je les détaillerais.

un système de cryptage

Chiffrement, pas cryptage :). Lis ceci: http://www.cppfrance.com/forum/sujet-CS-CORRECTION-TITRE-THEME-FORUM_1387875.aspx

qui contient les bits de ma chaine, comme pour prendre les bits d'un fichier et les mettre dans un string mais ici l'inverse)

C'est quelque chose que tu sais faire, puisque tu l'as fait dans ton code !
Tu stockes le résultat de binaryFormat dans un std::string.
Tu écris ce std::string dans un fichier, à l'aide d'un std::ofstream.

Ou alors tu te fais une fonction qui écris une chaine de caractère dans un fichier donnée.
Je t'écris le prototype, mais je te laisse écrire le code, que je te corrigerais si tu doutes de son efficacité:
// Met l'intégralité d'un texte dans un fichier
bool stringToFile(const std::string& filename, const std::string& text)
{
// A toi de jouer.
// Return true si l'écriture à réussi.
}


________________________________________________________________________
Historique de mes créations, et quelques articles:
[ http://0217021.free.fr/portfolio http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée si un post répond à votre question
0
ddraper
Messages postés
34
Date d'inscription
dimanche 18 septembre 2011
Statut
Membre
Dernière intervention
14 janvier 2012

29 sept. 2011 à 17:44
Voilà, j'ai cogité la chose :

// tout ce qui suit vient à la suite de ton code, dans le int main() sans les cout
// je chiffre mon binFormat dans une autre variable "chiffrement" et m'assure que ça taille soit un multiple de 8

std::string chiffrement;
chiffrement=binFormat;
// Blabla, je commence à chiffrer avec la variable string chiffrement

// les choses sérieuses commencent !
bool stringToFile(const std::string& filename, const std::string& text) // text a déjà été initialisé dans restoreFormat non ?
{
std::ofstream file(filename.c_str(), std::ios::binary); // je ne vois pas à quoi sert "filename.c_str()", un lien avec mon fichier de sortie mais .... si je veux que mon fichier de sortie soit différent de l'entrée ? du genre TestingEntrée.txt et testingSortie.txt ?
  if (!file)
    return false;
    
// A toi de jouer.
    restoreFormat(chiffrement); // tous les caractères se retrouvent dans le buffer c'est ça?
    
    int t=chiffrement.size();
    char tableauSortie[t];
  fichier.write(tableauSortie, t);
  fichier.close();
    
    
// Return true si l'écriture à réussi.
return true;
}
0
ddraper
Messages postés
34
Date d'inscription
dimanche 18 septembre 2011
Statut
Membre
Dernière intervention
14 janvier 2012

29 sept. 2011 à 17:45
avec des erreurs et des questions si tu veux bien
0
cptpingu
Messages postés
3834
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
20 octobre 2021
124
29 sept. 2011 à 17:59
Le principe est bon, la syntaxe ne l'est pas :)
Il y a de l'idée, c'est bien.

Quelques points:
- Ce n'est pas parce que la variable d'entrée s'appelle "filename", que c'est la même qu'avant. J'aurais pu l'appeler "toto", ça aurait été tout aussi efficace.
- "c_str()" permet de convertir un std::string en "const char*"
- restoreFormat(chiffrement); => restoreFormat ne modifie pas chiffrement. Il fait une copie de celui-ci qu'il tranforme et renvoi.
- char tableauSortie[t] ne contient rien car tu as bien crée un tableau à la bonne taille, mais tu n'y créer rien. Il est de toute façon plus simple de faire appelle à "c_str()" que de créer un tableau et d'y recopier les données dedans.

J'ai vraiment l'impression que tu n'est pas encore à l'aise avec les fonctions. Avant d'aller plus loin, je t'invite à bien étudier le sujet. Il faut bien comprendre le concept de fonction, sinon tu vas être bloqué pour la suite.
La portée des variables, les fonctions, et la durée d'une vie d'une variable sont trois notions extrêmement importantes sur lesquelles tu dois te documenter. Si tu maîtrise ces notions, ton niveau grimpera en flèche :).

Enfin, ne mélange pas les logiques dans les fonctions. Chaque fonction doit avoir son rôle et ne doit en assumer qu'un seul.
La fonction stringToFile doit se moquer de savoir si le texte est chiffré ou non. Elle ne fait que son travail aveuglément: mettre un texte arbitraire dans un fichier. C'est à toi de décider avant l'appelle à la fonction si tu chiffres ou non.

Ce qui donne:
bool stringToFile(const std::string& filename, const std::string& text)
{
  std::ofstream file(filename.c_str(), std::ios::binary);
  if (!file)
    return false;

  fichier.write(text.c_str(), text.size());
  fichier.close(); // facultatif, un fichier se ferme tout seul avec un std::ofstream.

  return true;
}

int main()
{
  std::string chiffrement = binaryFormat("ton texte");
  if (!stringToFile(chiffrement))
  {
     // Erreur
  }

  // Ou pour la version "déchiffrée"
  if (!stringToFile(restoreFormat(chiffrement)))
  {
     // Erreur
  }

  return 0;
}



________________________________________________________________________
Historique de mes créations, et quelques articles:
[ http://0217021.free.fr/portfolio http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée si un post répond à votre question
0
cptpingu
Messages postés
3834
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
20 octobre 2021
124
29 sept. 2011 à 18:03
Oups j'ai oublié un argument.
stringToFile(chiffrement) => stringToFile("fichier.txt", chiffrement)
stringToFile(restoreFormat(chiffrement)) => stringToFile("fichier.txt", restoreFormat(chiffrement))


________________________________________________________________________
Historique de mes créations, et quelques articles:
[ http://0217021.free.fr/portfolio http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée si un post répond à votre question
0
ddraper
Messages postés
34
Date d'inscription
dimanche 18 septembre 2011
Statut
Membre
Dernière intervention
14 janvier 2012

29 sept. 2011 à 19:11
J'ai vraiment l'impression que tu n'est pas encore à l'aise avec les fonctions. (...) Enfin, ne mélange pas les logiques dans les fonctions.

Avec le temps, des exo et une maîtrise de la théorie... Tout viendra tout seul. En tout cas, comme ça je sais ce que je dois revoir.

Avant de rassembler tout ça, je ne comprends pas cette ligne :
std::string chiffrement = binaryFormat("ton texte");

Que veux tu dire par "ton texte" ?
0
ddraper
Messages postés
34
Date d'inscription
dimanche 18 septembre 2011
Statut
Membre
Dernière intervention
14 janvier 2012

29 sept. 2011 à 19:20
j'ai rien dis. je viens de voir la 4eme page...
0
ddraper
Messages postés
34
Date d'inscription
dimanche 18 septembre 2011
Statut
Membre
Dernière intervention
14 janvier 2012

29 sept. 2011 à 19:48
J'ai rassemblé. Pas sur que la syntaxe soit exacte. Pour rappel, j'ouvre un fichier puis je chiffre son contenu binaire et enfin j'envoie tout ça dans un fichier de sortie.

#include 
#include <fstream>
#include <sstream>
#include 

static const unsigned int SHIFT = 8;

std::string formatCharToByte(unsigned char value)
{
  const int shift = SHIFT - 1;
  const unsigned int mask = 1 << shift;
  std::ostringstream buff;

  for (int i = 1; i <= shift + 1; ++i)
  {
    buff << (value & mask ? '1' : '0');
    value <<= 1;
  }

  return buff.str();
}

unsigned char formatByteToChar(const std::string& binFormat)
{
  unsigned char res = 0;

  const int size = binFormat.size() - 1;
  for (int i = 0; i <= size; i++)
  {
    int b = 1;
    int n = binFormat[i] - '0';
    b <<= size - i;
    res += n * b;
  }
  return res;
}

void test()
{
  for (char c = 'a'; c <= 'z'; ++c)
    std::cout << c << " -> " << formatCharToByte(c)
      << " -> " << formatByteToChar(formatCharToByte(c)) << std::endl;
}

std::string fileToString(const std::string& filename)
{
  std::ifstream fichier(filename.c_str(), std::ios::binary);
  if (!fichier.is_open())
  {
    std::cerr << "Impossible d'ouvrir le fichier en lecture !" << std::endl;
    return "";
  }

  fichier.seekg(0, std::ios_base::end);
  const int nbOctet = fichier.tellg();
  fichier.seekg(0, std::ios_base::beg);

  char tableau[nbOctet];
  fichier.read(tableau, nbOctet);
  fichier.close();

  return tableau;
}

std::string binaryFormat(const std::string& text)
{
  std::ostringstream buff;
  for (size_t i = 0; i < text.size(); ++i)
    buff << formatCharToByte(text[i]);

  return buff.str();
}

std::string restoreFormat(const std::string& text)
{
  std::ostringstream buff;
  for (size_t i = 0; i < text.size(); i += SHIFT)
    buff << formatByteToChar(text.substr(i, SHIFT));

  return buff.str();
}

bool stringToFile(const std::string& filename, const std::string& text)
{
  std::ofstream file(filename.c_str(), std::ios::binary);
  if (!file)
    return false;

  fichier.write(text.c_str(), text.size());
  fichier.close(); // facultatif, un fichier se ferme tout seul avec un std::ofstream.

  return true;
}

int main()
{
  //ouverture d'un fichier et obtention de ses 0 et 1 dans un string
  const std::string chiffrement = binaryFormat(fileToString("testingEntree.txt"));
   if (!fileToString("testingEntree.txt", chiffrement) )
  {
     stt::cout<<"Erreur sur fichier d'entree"<<  std::endl;
  }


   //je chiffre alors la variable string chiffrement. Pr préciser, je chiffre et créer un autre fichier qui contient le chiffrement.


   // je mets la variable string chiffrement qui vient d'être chiffrée
   stringToFile("testingSortie.txt", restoreFormat(chiffrement)); // transforme mon string en fichier de sortie. pas sur de moi là ...
   if (!stringToFile("testingSortie.txt", restoreFormat(chiffrement)))
  {
     stt::cout<<"Erreur sur fichier de sortie"<<  std::endl;
  }

  return 0;
}

0
cs_LA_Tupac
Messages postés
305
Date d'inscription
jeudi 29 avril 2004
Statut
Membre
Dernière intervention
18 janvier 2012
1
29 sept. 2011 à 21:25
Oula! y'a encore du taf on dirait
Premièrement je veux revenir sur:
Néanmoins ça reste juste

Effectivement je ne m'étais pas relu ce jour là (grognon )
Ensuite tu n'as pas compilé le code que tu nous montré car ça donne 6 erreurs de compil, c'est un peut la moindre des choses, ton meilleur coach c'est ce que gueule ton compilo.
Je passe sur "file" qui devient "fichier", l'appel avec 2 argulments de "fileToString()" dans le main et par la même occasion un opérateur '!' devant comme si elle ne retournait pas un string mais un bool...
Bref, utilise le code exact de Pingu (j'espère que ça ne gène pas que j'écorche un peut ton pseud, moi je préfère Tupac tout court ) et ajoute seulement ce dont tu as besoin.
Je comprend bien que tu cherches à piger "sur le tas" le fonctionnement du truc et j'aime bien ces démarches mais il faut un minimum de maîtrise et tu galère encore sur les fonctions
Je te conseille de travailler le découpage en fonctions, puis en class et enfin les types de données, les tableaux, et les pointeurs et références.

J'avais bien fait gaffe à l’ordre dans lequel j'avais écris ça google te donnera des bons cours
C'est pas une galère et des mois d'apprentissage, juste une soirée ou deux bien attentif pour avoir les idée claires et ensuite des petits projets perso comme celui-ci c'est très bien
0
ddraper
Messages postés
34
Date d'inscription
dimanche 18 septembre 2011
Statut
Membre
Dernière intervention
14 janvier 2012

30 sept. 2011 à 00:15
Allez ... ça fait 4 pages de topic et des heures à se casser la tête. J'ai compris le principe, et la syntaxe ne s'apprend pas en une soirée! Faut du temps... C'est comme connaitre son vocabulaire sans sa grammaire! Tu ne peux rien faire!!! Et quoi que tu disses, ça restera du charabia.

En ayant le code en entier, je serais en mesure de comprendre le tout. Pour l'instant, j'ai l'impression de comprendre variable par variable et non le pourquoi du comment de la variable qui entre dans la fonction. Je suis de ceux qui pensent qu'un tout compréhensible est une somme d'incohérence propre. J'ai assez cherché ! Une réponse entière svp! Corriger mes erreurs et donnez moi un truc valable! hé là je ferai haaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!!! Je vois maintenant!

Je voulais aussi dire que j'ai besoin de ce code pour avoir ma chaine de 0 et 1 à chiffrer ... J'aimerai chiffrer (le coté mathématique est plus simple que le c++ )! Je le demande humblement! J'aurai le temps d'apprendre.


bonnne nuit à tous
0
ddraper
Messages postés
34
Date d'inscription
dimanche 18 septembre 2011
Statut
Membre
Dernière intervention
14 janvier 2012

30 sept. 2011 à 00:21
je viens de relire vos messages. Pour l'erreur du debug: j'y comprends rien. ça va vous paraitre mal approprié mais est-ce possible de me fournir une version final de ce que j'essaie de faire (une correction de mon dernier mauvais code)? Histoire qu'on en finisse... Et que je puisse chiffrer mon string!

Je comprendrai un jour! Mais hélas, ce jour n'est pas encore arrivé.
0
cptpingu
Messages postés
3834
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
20 octobre 2021
124
30 sept. 2011 à 10:29
J'ai assez cherché ! Une réponse entière svp!

Ce n'est pas que je ne voulais pas te répondre, mais il y avait un moment où j'ai été faire dodo, tout simplement :p

J'ai remis au propre:
#include 
#include <fstream>
#include <sstream>
#include 

static const unsigned int SHIFT = 8;

std::string formatCharToByte(unsigned char value)
{
  const int shift = SHIFT - 1;
  const unsigned int mask = 1 << shift;
  std::ostringstream buff;

  for (int i = 1; i <= shift + 1; ++i)
  {
    buff << (value & mask ? '1' : '0');
    value <<= 1;
  }

  return buff.str();
}

unsigned char formatByteToChar(const std::string& binFormat)
{
  unsigned char res = 0;

  const int size = binFormat.size() - 1;
  for (int i = 0; i <= size; i++)
  {
    int b = 1;
    int n = binFormat[i] - '0';
    b <<= size - i;
    res += n * b;
  }
  return res;
}

bool fileToString(const std::string& filename, std::string& text)
{
  std::ifstream fichier(filename.c_str(), std::ios::binary);
  if (!fichier)
  {

    return false;
  }

  fichier.seekg(0, std::ios_base::end);
  const int nbOctet = fichier.tellg();
  fichier.seekg(0, std::ios_base::beg);

  char tableau[nbOctet];
  fichier.read(tableau, nbOctet);
  fichier.close();

  text.assign(tableau);
  return true;
}

bool stringToFile(const std::string& filename, const std::string& text)
{
  std::ofstream file(filename.c_str(), std::ios::binary);
  if (!file)
    return false;

  file.write(text.c_str(), text.size());
  file.close();

  return true;
}

std::string binaryFormat(const std::string& text)
{
  std::ostringstream buff;
  for (size_t i = 0; i < text.size(); ++i)
    buff << formatCharToByte(text[i]);

  return buff.str();
}

std::string restoreFormat(const std::string& text)
{
  std::ostringstream buff;
  for (size_t i = 0; i < text.size(); i += SHIFT)
    buff << formatByteToChar(text.substr(i, SHIFT));

  return buff.str();
}

int main()
{
  const std::string inputFile = "testingEntree.txt";
  const std::string outputFile1 = "testingSortie1.txt";
  const std::string outputFile2 = "testingSortie2.txt";

  std::string text;
  if (!fileToString(inputFile, text))
  {
    std::cerr << "Impossible d'ouvrir le fichier en lecture !" << std::endl;
    return 1;
  }

  const std::string chiffrement = binaryFormat(text);
  if (!stringToFile(outputFile1, chiffrement))
  {
    std::cout << "Erreur sur fichier de sortie" << std::endl;
    return 2;
  }

  if (!stringToFile(outputFile2, restoreFormat(chiffrement)))
  {
    std::cout << "Erreur sur fichier de sortie" << std::endl;
    return 3;
  }

  return 0;
}


________________________________________________________________________
Historique de mes créations, et quelques articles:
[ http://0217021.free.fr/portfolio http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée si un post répond à votre question
0
ddraper
Messages postés
34
Date d'inscription
dimanche 18 septembre 2011
Statut
Membre
Dernière intervention
14 janvier 2012

30 sept. 2011 à 13:15
Une dernière fois pour être sur qu je le place au bon endroit mon code de chiffrement :

#include 
#include <fstream>
#include <sstream>
#include 

static const unsigned int SHIFT = 8;

std::string formatCharToByte(unsigned char value)
{
  const int shift = SHIFT - 1;
  const unsigned int mask = 1 << shift;
  std::ostringstream buff;

  for (int i = 1; i <= shift + 1; ++i)
  {
    buff << (value & mask ? '1' : '0');
    value <<= 1;
  }

  return buff.str();
}

unsigned char formatByteToChar(const std::string& binFormat)
{
  unsigned char res = 0;

  const int size = binFormat.size() - 1;
  for (int i = 0; i <= size; i++)
  {
    int b = 1;
    int n = binFormat[i] - '0';
    b <<= size - i;
    res += n * b;
  }
  return res;
}

bool fileToString(const std::string& filename, std::string& text)
{
  std::ifstream fichier(filename.c_str(), std::ios::binary);
  if (!fichier)
  {

    return false;
  }

  fichier.seekg(0, std::ios_base::end);
  const int nbOctet = fichier.tellg();
  fichier.seekg(0, std::ios_base::beg);

  char tableau[nbOctet];
  fichier.read(tableau, nbOctet);
  fichier.close();

  text.assign(tableau);
  return true;
}

bool stringToFile(const std::string& filename, const std::string& text)
{
  std::ofstream file(filename.c_str(), std::ios::binary);
  if (!file)
    return false;

  file.write(text.c_str(), text.size());
  file.close();

  return true;
}

std::string binaryFormat(const std::string& text)
{
  std::ostringstream buff;
  for (size_t i = 0; i < text.size(); ++i)
    buff << formatCharToByte(text[i]);

  return buff.str();
}

std::string restoreFormat(const std::string& text)
{
  std::ostringstream buff;
  for (size_t i = 0; i < text.size(); i += SHIFT)
    buff << formatByteToChar(text.substr(i, SHIFT));

  return buff.str();
}

int main()
{
  const std::string inputFile = "testingEntree.txt";
  const std::string outputFile1 = "testingSortie1.txt";
  const std::string outputFile2 = "testingSortie2.txt";

  std::string text;
  if (!fileToString(inputFile, text))
  {
    std::cerr << "Impossible d'ouvrir le fichier en lecture !" << std::endl;
    return 1;
  }

  const std::string chiffrement = binaryFormat(text);
  if (!stringToFile(outputFile1, chiffrement))
  {
    std::cout << "Erreur sur fichier de sortie" << std::endl;
    return 2;
  }

  // ici je peux mettre mon code de chiffrement sans problème hein ?!

  if (!stringToFile(outputFile2, restoreFormat(chiffrement)))
  {
    std::cout << "Erreur sur fichier de sortie" << std::endl;
    return 3;
  }

  return 0;
}




aussi une autre chose: il y a 2 sortie. Une qui crée un fichier texte de sortie avec les binaires, et l'autre avec les caractères. J'ai juste besoin d'avoir le string qui contient les données binaires du fichier d'entrée pour les modifier et les renvoyer vers un fichier de sortie qui contient les données binaires chiffrer. En sommes, j'ai pas besoin du fichier de sortie avec les binaires en caractère. Ou bien je peux pas modifier ma chaine string de départ qui est dans le buffer ?
Comment enlever du code "testingSortie1.txt" mais garder le "testingEntree.txt" ==> chiffrement de la chaine string ==> "testingSortie2.txt" ?

voilà, après ça j'ai quelque question sur la taille limite d'un fichier que je pourrais traiter selon la ram. Et ça sera tout!
0
cptpingu
Messages postés
3834
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
20 octobre 2021
124
30 sept. 2011 à 13:23
En sommes, j'ai pas besoin du fichier de sortie avec les binaires en caractère.

Il suffit de juste retirer la procédure qui écrit le premier fichier !

// ici je peux mettre mon code de chiffrement sans problème hein ?!

Oui. Tu agis directement sur la variable "chiffrement". Soit tu retournes une copie modifiée, soit tu écris directement sur chiffrement (mais dans ce cas, tu retires le "const" devant la déclaration de chiffrement).

J'aimerais tout de même soulever le fait qu'une fonction de chiffrement se fait directement sur la donnée et non sur la représentation binaire de la donnée. (En gros ça sert à rien de transformer un texte en sa réprésentation binaire textuel, il suffit d'agir directement sur la donnée, qui est peut être du texte visuellement, mais reste du binaire pour la machine).

La taille limite d'un fichier que je pourrais traiter selon la ram.

Limite de ton système, pas du langage. Tant que tu as de la RAM c'est bon. Pour la taille max d'un fichier, c'est 4 GO pour du 32 bits, et "beaucoup" pour du 64 bits.

________________________________________________________________________
Historique de mes créations, et quelques articles:
[ http://0217021.free.fr/portfolio http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée si un post répond à votre question
0