Ubuntu-fr

temps

[résolu] ecriture dans fichier en c++

Bonjour, j'en suis à la quatrième et dernière étape de mon projet audio en format texte pour linux.
Cette quatrième étape consiste à lier directement plusieurs formes de 200 ondes sonores.
Le projet est de pouvoir indiquer plusieurs applications avec chacune ses arguments, et que l'exécutable produise un fichier audio qui serait la somme des fichiers.
Un compositeur pourra directement créer ses musiques.
La première difficulté est de dire que je veux écrire à la suite du début du fichier audio quand j'écris

std::ofstream f ("audiojo.wav", std::ios::binary,app);

j'obtiens une erreur à la compilation, j'ai besoin de binary, et de app pour dire d'écrire en dessous
l'idée est d'avoir un main qui écrit l'entête et la première forme sonore, puis un main1 sans entête qui écris dessous la deuxième forme sonore ...
Et à la fin ajouter dans le dernier main le calcul du poids des fichiers avec

f.seekp(0, ios::end);  //je me mets à la fin du fichier audio
int ou = f.tellp();//je récupère le poids du fichier	
f.seekp(5, ios::beg);// je place le curseur à la première adresse du poids du fichier le 5,6,7,8
f.seekp(41, ios::cur); //je place le curseur à la deuxième adresse à modifier 41,42,43,44

mais là encore, je dois trouver comment transformer en binaire avec le poids à l'envers (little endian)
Le projet complet est ici : https://letime.net/son/ap
Cordialement

Dernière modification par temps (Le 10/05/2024, à 21:42)

---

Parce que l'USB bootable est le support des systèmes experts,
Parce que l'USB bootable contient sa propre image au démarrage.
L'USB bootable permet de créer un monde à la dimension de son imagination
https://www.letime.net

temps

Re : [résolu] ecriture dans fichier en c++

j'ai trouvé la solution pour la première question ici https://en.cppreference.com/w/cpp/io/basic_filebuf/open
le code qui fonctionne est

std::ofstream f ("audiojo.wav", std::ios::binary | std::ios::app);

par contre j'obtiens

main1.cpp:334:12: error: ‘ios’ has not been declared
  334 | f.seekp(0, ios::end);  //je me mets à la fin du fichier audio
      |            ^~~
main1.cpp:336:12: error: ‘ios’ has not been declared
  336 | f.seekp(5, ios::beg);// je place le curseur à la première adresse du poids du fichier le 5,6,7,8
      |            ^~~
main1.cpp:337:13: error: ‘ios’ has not been declared
  337 | f.seekp(41, ios::cur); //je place le curseur à la deuxième adresse à modifier 41,42,43,44

quand je compile, c'est la partie qui récupère le poids du fichier

---

Parce que l'USB bootable est le support des systèmes experts,
Parce que l'USB bootable contient sa propre image au démarrage.
L'USB bootable permet de créer un monde à la dimension de son imagination
https://www.letime.net

temps

Re : [résolu] ecriture dans fichier en c++

Bonjour,
je pense avoir la solution du début de la deuxième partie

je modifie l'ouverture du fichier en sortant le string comme ça

std::string const f1("audiojo.wav");
std::ofstream f (f1.c_str(), std::ios::binary | std::ios::app);
	if(!f) {

et après j'ajoute std devant ios comme ça

	//2
f.seekp(0, std::ios::end);  //je me mets à la fin du fichier audio
int ou = f.tellp();//je récupère le poids du fichier	
f.seekp(5, std::ios::beg);// je place le curseur à la première adresse du poids du fichier le 5,6,7,8
f.seekp(41, std::ios::cur); //je place le curseur à la deuxième adresse à modifier 41,42,43,44
	
//fin de la fonction
}

ce qui me permet de compiler.
Il ne me reste plus qu'à trouver comment transformer la valeur en hexa et remplacer dans 5,6,7,8, puis 41,42,43,44
j'ai testé et j'arrive bien à associer plusieurs formes avec cette technique, il me manque l'écriture du poids des fichier, je vais écrire un code qui automatise en demandant les applications (formes) et les arguments (qui vont avec) pour pouvoir créer, en provisoire je mettrais un poids très lourd en attendant que j'arrive à écrire le bon

A la fin, je vais essayer de reprendre les codes pour qu'ils soient le plus lisible possible, et aussi de donner le maximum de commentaires pour que se quelqu'un veuille créer sa propre version, il puisse le faire.

Dernière modification par temps (Le 07/05/2024, à 14:21)

---

Parce que l'USB bootable est le support des systèmes experts,
Parce que l'USB bootable contient sa propre image au démarrage.
L'USB bootable permet de créer un monde à la dimension de son imagination
https://www.letime.net

temps

Re : [résolu] ecriture dans fichier en c++

Je pense avoir la solution pour le poids, ça compile mais je dois vérifier que ça marche bien en vérifiant avec ghex ce qui est écrit
c'est :

	//2
f.seekp(0, std::ios::end);  //je me mets à la fin du fichier audio
int ou = f.tellp();//je récupère le poids du fichier	
f.seekp(5, std::ios::beg);// je place le curseur à la première adresse du poids du fichier le 5,6,7,8
f<< std::hex << ou;
f.seekp(41, std::ios::cur); //je place le curseur à la deuxième adresse à modifier 41,42,43,44
f<< std::hex << ou;	
//fin de la fonction
}

P.S. après vérif avec ghex, le code ne change pas les octets 5... et41 ...
Je pense qu'il doit y avoir plusieurs erreurs, la première est que je dois mieux faire l'implantation, le code n'est peut-être pas entre les parenthèses qui ouvrent le fichier, et je ne suis pas sur que le code place et écrive ce qu'il faut en ce moment j'en suis à :

	}
/*
f.seekp(0, std::ios::end);  //je me mets à la fin du fichier audio
int ou = f.tellp();//je récupère le poids du fichier	

f.seekp(5, std::ios::beg);// je place le curseur à la première adresse du poids du fichier le 5,6,7,8
//f<< std::hex << ou;
//f<< std::format("{:#02x}", ou) ;
f<< "0x" << std::setfill('0') << std::setw(2) << std::hex << ou;
//fprintf(f, ou); 
//printf ("%02x", ou);
f.seekp(41, std::ios::beg);//je place le curseur à la deuxième adresse à modifier 41,42,43,44
//f<< std::hex << ou;	
f<< "0x" << std::setfill('0') << std::setw(2) << std::hex << ou;
	
*/	
	
	
	}
	
	//2

//fin de la fonction
}

P.S. cette technique est impossible car j'ai besoin

std::ios::app

dans l'ouverture du fichier de manière à pouvoir ajouter les formes au fur et à mesure de la composition. Cette fonction pousse l'écriture à la fin du fichier et est incompatible avec

f.seekp

j'ai donc supprimé ce bout de code de l'appli
J'ai basculé sur une autre technique à savoir l'ajout d'une application qui vient corriger l'entête après la fermeture du fichier généré.
Avec cette nouvelle technique j'écris bien à l'endroit désiré, mais je récupère un int que je doit transformer en little endian
Au moment, j'ai testé plusieurs codes mais aucun ne va comme il faut au controle avec ghex
le code que j'ai écris est encore à améliorer c'est celui qui s'approche le plus est celui-là

#include <fstream>
using namespace std;
#include <iomanip>
#include <iostream>
#include <bit>
#include <cstdlib>
#include <string>
#include <regex>

using namespace std;


typedef unsigned char byte;

using namespace std;

/**pour compiler g++ 'poids.cpp'   -std=c++11 -Wall -Wextra -o 'poids' ********************/ 
int main()
{

    unsigned char tabn[257] = {0x0000,0x0001,0x0002,0x0003,0x0004,0x0005,0x0006,0x0007,0x0008,0x0009,0x000A,0x000B,0x000C,0x000D,0x000E,0x000F,0x0010,0x0011,0x0012,0x0013,0x0014,0x0015,0x0016,0x0017,0x0018,0x0019,0x001A,0x001B,0x001C,0x001D,0x001E,0x001F,0x0020,0x0021,0x0022,0x0023,0x0024,0x0025,0x0026,0x0027,0x0028,0x0029,0x002A,0x002B,0x002C,0x002D,0x002E,0x002F,0x0030,0x0031,0x0032,0x0033,0x0034,0x0035,0x0036,0x0037,0x0038,0x0039,0x003A,0x003B,0x003C,0x003D,0x003E,0x003F,0x0040,0x0041,0x0042,0x0043,0x0044,0x0045,0x0046,0x0047,0x0048,0x0049,0x004A,0x004B,0x004C,0x004D,0x004E,0x004F,0x0050,0x0051,0x0052,0x0053,0x0054,0x0055,0x0056,0x0057,0x0058,0x0059,0x005A,0x005B,0x005C,0x005D,0x005E,0x005F,0x0060,0x0061,0x0062,0x0063,0x0064,0x0065,0x0066,0x0067,0x0068,0x0069,0x006A,0x006B,0x006C,0x006D,0x006E,0x006F,0x0070,0x0071,0x0072,0x0073,0x0074,0x0075,0x0076,0x0077,0x0078,0x0079,0x007A,0x007B,0x007C,0x007D,0x007E,0x007F,0x0080,0x0081,0x0082,0x0083,0x0084,0x0085,0x0086,0x0087,0x0088,0x0089,0x008A,0x008B,0x008C,0x008D,0x008E,0x008F,0x0090,0x0091,0x0092,0x0093,0x0094,0x0095,0x0096,0x0097,0x0098,0x0099,0x009A,0x009B,0x009C,0x009D,0x009E,0x009F,0x00A0,0x00A1,0x00A2,0x00A3,0x00A4,0x00A5,0x00A6,0x00A7,0x00A8,0x00A9,0x00AA,0x00AB,0x00AC,0x00AD,0x00AE,0x00AF,0x00B0,0x00B1,0x00B2,0x00B3,0x00B4,0x00B5,0x00B6,0x00B7,0x00B8,0x00B9,0x0BA,0x00BB,0x00BC,0x00BD,0x00BE,0x00BF,0x00C0,0x00C1,0x00C2,0x00C3,0x00C4,0x00C5,0x00C6,0x00C7,0x00C8,0x00C9,0x00CA,0x00CB,0x00CC,0x00CD,0x00CE,0x00CF,0x00D0,0x00D1,0x00D2,0x00D3,0x00D4,0x00D5,0x00D6,0x00D7,0x00D8,0x00D9,0x00DA,0x00DB,0x00DC,0x00DD,0x00DE,0x00DF,0x00E0,0x00E1,0x00E2,0x00E3,0x00E4,0x00E5,0x00E6,0x00E7,0x00E8,0x00E9,0x00EA,0x00EB,0x00EC,0x00ED,0x00EE,0x00EF,0x00F0,0x00F1,0x00F2,0x00F3,0x00F4,0x00F5,0x00F6,0x00F7,0x00F8,0x00F9,0x00FA,0x00FB,0x00FC,0x00FD,0x00FE,0x00FF};

std::string const f1("audiojo.wav");
std::ofstream f (f1.c_str(), std::ios::binary | std::ios::in | std::ios::out);
	if(!f) {
		std::cerr << "Impossible d'ouvrir le fichier en écriture !" << std::endl;
		//return 1;
	}
    f.seekp(0, std::ios::end);  //je me mets à la fin du fichier audio 
 
  
    int poids = f.tellp();//je récupère le poids du fichier
             
            if (poids > (16*16*16) )
            {
            int a,b,c;
            a = poids % (16*16*16);
            b=  poids % (16*16);
            c = poids % (16);
            f.seekp(4, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[a];
            f.seekp(5, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[b];
            f.seekp(6, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[c];
            f.seekp(40, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[a];
            f.seekp(41, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[b];
            f.seekp(42, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[c];
            }
            if (poids < (16*16*16))
            {
            int a,b;
            a= poids % (16*16);
            b= poids % (16);
            f.seekp(4, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[a];
            f.seekp(5, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[b];
            f.seekp(40, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[a];
            f.seekp(41, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[b];
            }

    f.close();
  }          

Dernière modification par temps (Le 10/05/2024, à 18:37)

---

Parce que l'USB bootable est le support des systèmes experts,
Parce que l'USB bootable contient sa propre image au démarrage.
L'USB bootable permet de créer un monde à la dimension de son imagination
https://www.letime.net

temps

Re : [résolu] ecriture dans fichier en c++

Et voila, c'est fait je poste en résolu et je pousse dans le git. Je ne sais pas pourquoi, je dois enlever 1 aux valeurs obtenues dans la boucle, mais aux controles avec ghex et les logiciels audio il y a toujours ce décallage de 1, j'ai mis -1
Le code qui permet de calculer et corriger le poids des fichiers audio est :

#include <cstdlib>
#include <string>
#include <regex>

using namespace std;


typedef unsigned char byte;

using namespace std;

/**pour compiler g++ 'poids.cpp'   -std=c++11 -Wall -Wextra -o 'poids' ********************/ 
int main()
{

    unsigned char tabn[257] = {0x0000,0x0001,0x0002,0x0003,0x0004,0x0005,0x0006,0x0007,0x0008,0x0009,0x000A,0x000B,0x000C,0x000D,0x000E,0x000F,0x0010,0x0011,0x0012,0x0013,0x0014,0x0015,0x0016,0x0017,0x0018,0x0019,0x001A,0x001B,0x001C,0x001D,0x001E,0x001F,0x0020,0x0021,0x0022,0x0023,0x0024,0x0025,0x0026,0x0027,0x0028,0x0029,0x002A,0x002B,0x002C,0x002D,0x002E,0x002F,0x0030,0x0031,0x0032,0x0033,0x0034,0x0035,0x0036,0x0037,0x0038,0x0039,0x003A,0x003B,0x003C,0x003D,0x003E,0x003F,0x0040,0x0041,0x0042,0x0043,0x0044,0x0045,0x0046,0x0047,0x0048,0x0049,0x004A,0x004B,0x004C,0x004D,0x004E,0x004F,0x0050,0x0051,0x0052,0x0053,0x0054,0x0055,0x0056,0x0057,0x0058,0x0059,0x005A,0x005B,0x005C,0x005D,0x005E,0x005F,0x0060,0x0061,0x0062,0x0063,0x0064,0x0065,0x0066,0x0067,0x0068,0x0069,0x006A,0x006B,0x006C,0x006D,0x006E,0x006F,0x0070,0x0071,0x0072,0x0073,0x0074,0x0075,0x0076,0x0077,0x0078,0x0079,0x007A,0x007B,0x007C,0x007D,0x007E,0x007F,0x0080,0x0081,0x0082,0x0083,0x0084,0x0085,0x0086,0x0087,0x0088,0x0089,0x008A,0x008B,0x008C,0x008D,0x008E,0x008F,0x0090,0x0091,0x0092,0x0093,0x0094,0x0095,0x0096,0x0097,0x0098,0x0099,0x009A,0x009B,0x009C,0x009D,0x009E,0x009F,0x00A0,0x00A1,0x00A2,0x00A3,0x00A4,0x00A5,0x00A6,0x00A7,0x00A8,0x00A9,0x00AA,0x00AB,0x00AC,0x00AD,0x00AE,0x00AF,0x00B0,0x00B1,0x00B2,0x00B3,0x00B4,0x00B5,0x00B6,0x00B7,0x00B8,0x00B9,0x0BA,0x00BB,0x00BC,0x00BD,0x00BE,0x00BF,0x00C0,0x00C1,0x00C2,0x00C3,0x00C4,0x00C5,0x00C6,0x00C7,0x00C8,0x00C9,0x00CA,0x00CB,0x00CC,0x00CD,0x00CE,0x00CF,0x00D0,0x00D1,0x00D2,0x00D3,0x00D4,0x00D5,0x00D6,0x00D7,0x00D8,0x00D9,0x00DA,0x00DB,0x00DC,0x00DD,0x00DE,0x00DF,0x00E0,0x00E1,0x00E2,0x00E3,0x00E4,0x00E5,0x00E6,0x00E7,0x00E8,0x00E9,0x00EA,0x00EB,0x00EC,0x00ED,0x00EE,0x00EF,0x00F0,0x00F1,0x00F2,0x00F3,0x00F4,0x00F5,0x00F6,0x00F7,0x00F8,0x00F9,0x00FA,0x00FB,0x00FC,0x00FD,0x00FE,0x00FF};

std::string const f1("audiojo.wav");
std::ofstream f (f1.c_str(), std::ios::binary | std::ios::in | std::ios::out);
	if(!f) {
		std::cerr << "Impossible d'ouvrir le fichier en écriture !" << std::endl;
		//return 1;
	}
    f.seekp(0, std::ios::end);  //je me mets à la fin du fichier audio 
 
  
    int poids = f.tellp();//je récupère le poids du fichier
             
            if (poids > (65536) )
            {
            int a,b,c,d,k=0,j=0;
            a = poids % (256);            
            for (int i = 0; i < poids; i=i+65536) {  k++;}
            c=k-1;
            d =  poids % (65536);
            for (int i = 0; i < d; i=i+256) {  j++;}
            b=j-1;
            f.seekp(4, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[a];
            f.seekp(5, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[b];
            f.seekp(6, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[c];
            f.seekp(40, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[a];
            f.seekp(41, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[b];
            f.seekp(42, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[c];
            }
            if (poids < 65536)
            {
            int a,b,j=0;
            a= poids % (256);
            for (int i = 0; i < poids; i=i+256) {  j++;}
            b=j-1;
            f.seekp(4, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[a];
            f.seekp(5, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[b];
            f.seekp(40, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[a];
            f.seekp(41, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[b];
             for (int i = 0; i < poids; i=i+256) {  j++;}
             b=j;
            }

    f.close();
  }        

---

Parce que l'USB bootable est le support des systèmes experts,
Parce que l'USB bootable contient sa propre image au démarrage.
L'USB bootable permet de créer un monde à la dimension de son imagination
https://www.letime.net

iznobe

Re : [résolu] ecriture dans fichier en c++

Bonjour , je ne suis pas expert en c++ , je te propose cependant quelques optimisations basiques :

Il me semble que la partie avec les if , peut être améliorée .
d' une part en indiquant un else if , a la place d' un if , ( cela fait une condition de moins a verifier ) , et d ' autre part en utilisant moins de variables qui alourdit inutilement le programme .
on voit par exemple que tu declares 2 fois les meme variables dans les conditions , il vaut mieux declarer les variables que tu utiliseras a chaque fois  en dehors des conditions mais qu ' une seule fois ( moins de code ) .

De plus ton programme peut ne pas traiter un cas : tu ne traites pas le cas ou un fichier a un poids de 65536 , je ne suis pas certain que ce soit voulu :

if (poids > (65536) )
...
if (poids < 65536)

donc soit tu inclus le poids de 65536 dans un des 2 if :

if (poids >= (65536) )

, soit tu fais un cas special :

else if (poids = 65536)

soit tu ne fais rien car c' est ton intention , il n' y a rien a faire dans ce cas precis .

la variable " d " est inutile .

je ne comprends pas a quoi servent les 2 derniere lignes ...

#include <cstdlib>
#include <string>
#include <regex>

using namespace std;


typedef unsigned char byte;

using namespace std;

/**pour compiler g++ 'poids.cpp'   -std=c++11 -Wall -Wextra -o 'poids' ********************/ 
int main()
{

    unsigned char tabn[257] = {0x0000,0x0001,0x0002,0x0003,0x0004,0x0005,0x0006,0x0007,0x0008,0x0009,0x000A,0x000B,0x000C,0x000D,0x000E,0x000F,0x0010,0x0011,0x0012,0x0013,0x0014,0x0015,0x0016,0x0017,0x0018,0x0019,0x001A,0x001B,0x001C,0x001D,0x001E,0x001F,0x0020,0x0021,0x0022,0x0023,0x0024,0x0025,0x0026,0x0027,0x0028,0x0029,0x002A,0x002B,0x002C,0x002D,0x002E,0x002F,0x0030,0x0031,0x0032,0x0033,0x0034,0x0035,0x0036,0x0037,0x0038,0x0039,0x003A,0x003B,0x003C,0x003D,0x003E,0x003F,0x0040,0x0041,0x0042,0x0043,0x0044,0x0045,0x0046,0x0047,0x0048,0x0049,0x004A,0x004B,0x004C,0x004D,0x004E,0x004F,0x0050,0x0051,0x0052,0x0053,0x0054,0x0055,0x0056,0x0057,0x0058,0x0059,0x005A,0x005B,0x005C,0x005D,0x005E,0x005F,0x0060,0x0061,0x0062,0x0063,0x0064,0x0065,0x0066,0x0067,0x0068,0x0069,0x006A,0x006B,0x006C,0x006D,0x006E,0x006F,0x0070,0x0071,0x0072,0x0073,0x0074,0x0075,0x0076,0x0077,0x0078,0x0079,0x007A,0x007B,0x007C,0x007D,0x007E,0x007F,0x0080,0x0081,0x0082,0x0083,0x0084,0x0085,0x0086,0x0087,0x0088,0x0089,0x008A,0x008B,0x008C,0x008D,0x008E,0x008F,0x0090,0x0091,0x0092,0x0093,0x0094,0x0095,0x0096,0x0097,0x0098,0x0099,0x009A,0x009B,0x009C,0x009D,0x009E,0x009F,0x00A0,0x00A1,0x00A2,0x00A3,0x00A4,0x00A5,0x00A6,0x00A7,0x00A8,0x00A9,0x00AA,0x00AB,0x00AC,0x00AD,0x00AE,0x00AF,0x00B0,0x00B1,0x00B2,0x00B3,0x00B4,0x00B5,0x00B6,0x00B7,0x00B8,0x00B9,0x0BA,0x00BB,0x00BC,0x00BD,0x00BE,0x00BF,0x00C0,0x00C1,0x00C2,0x00C3,0x00C4,0x00C5,0x00C6,0x00C7,0x00C8,0x00C9,0x00CA,0x00CB,0x00CC,0x00CD,0x00CE,0x00CF,0x00D0,0x00D1,0x00D2,0x00D3,0x00D4,0x00D5,0x00D6,0x00D7,0x00D8,0x00D9,0x00DA,0x00DB,0x00DC,0x00DD,0x00DE,0x00DF,0x00E0,0x00E1,0x00E2,0x00E3,0x00E4,0x00E5,0x00E6,0x00E7,0x00E8,0x00E9,0x00EA,0x00EB,0x00EC,0x00ED,0x00EE,0x00EF,0x00F0,0x00F1,0x00F2,0x00F3,0x00F4,0x00F5,0x00F6,0x00F7,0x00F8,0x00F9,0x00FA,0x00FB,0x00FC,0x00FD,0x00FE,0x00FF};

std::string const f1("audiojo.wav");
std::ofstream f (f1.c_str(), std::ios::binary | std::ios::in | std::ios::out);
	if(!f) {
		std::cerr << "Impossible d'ouvrir le fichier en écriture !" << std::endl;
		//return 1;
	}
    f.seekp(0, std::ios::end);  //je me mets à la fin du fichier audio 
 
  
    int poids = f.tellp();//je récupère le poids du fichier
			# declaration des variables
            int a=poids % (256),b,c,k=0,j=0;
            # int a,b,c,d,k=0,j=0; # on peut supprimer la variable " d " de cette liste en modifiant une boucle voir plus bas .

            if (poids > (65536) )
            {
            # int a,b,c,d,k=0,j=0; # deplacement des declarations des variables
			
            #a = poids % (256); # on supprime car initialiser directement         
            for (int i = 0; i < poids; i=i+65536) {  k++;}
            c=k-1;
            #d =  poids % (65536);
            #for (int i = 0; i < d; i=i+256) {  j++;} # plutot que d' utiliser une variable " d " ici qui ne sert pas ailleurs , il vaudrait mieux remplacer directement par " poids % (65536) et supprimer la variable , ca allege le programme en memoire , mais le rends un peu moins " lisible ".
			
			for (int i = 0; i < (poids % (65536)); i=i+256) {  j++;}
            b=j-1;
            f.seekp(4, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[a];
            f.seekp(5, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[b];
            f.seekp(6, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[c];
            f.seekp(40, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[a];
            f.seekp(41, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[b];
            f.seekp(42, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[c];
            }
            else if (poids < 65536) # utilisation d' un else le poids ne peut apprement pas etre a la fois superieur ou inferieur . ca sera forcément sot un cas soit l' autre , soit egal a 65536 .
            {
            # int a,b,j=0; devenu inutile de les remettre ici 
            #a = poids % (256); # on supprime car initialiser directement 
            for (int i = 0; i < poids; i=i+256) {  j++;}
            b=j-1;
            f.seekp(4, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[a];
            f.seekp(5, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[b];
            f.seekp(40, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[a];
            f.seekp(41, std::ios::beg);//je me place ou il faut remplacer
            f<<tabn[b];
            for (int i = 0; i < poids; i=i+256) {  j++;} # tu as deja fait cette boucle juste en dessus , quel interet de recommencer ?
            b=j; # a quoi sert cette derniere affectation de valeur ?
            }
			else # les autres cas dont : else if (poids = (65536) )
			{
				# ??????
			}
    f.close();
  }    

Dernière modification par iznobe (Le 11/05/2024, à 09:06)

---

retour COMPLET et utilisable de commande
MSI Z490A-pro , i7 10700 , 32 GB RAM .

temps

Re : [résolu] ecriture dans fichier en c++

Bonjour,
Mille mercis pour ces précieuses informations.
Je vais essayer d'assimiler et d'appliquer.
Il est possible de faire un fork sur le GIT car les possibilités d'ouverture sont nombreuses (format peut-être destiné à telle ou telle forme de sonorité, reprendre le nombre d'unité de temps qui compose le générateur ....
En fait je perçois le monde avec trop de caractère, et pour que le projet avance, il faudrait que d'autres s'impliquent en récupérant les parties qu'ils trouvent interessant dans ma proposition.
C'est sous licence GNU
Quoiqu'il en soit, ce soir j'essaie d'appliquer et je reviens poster pour dire.
Encore une fois merci pour l'info.
Cordialement

---

Parce que l'USB bootable est le support des systèmes experts,
Parce que l'USB bootable contient sa propre image au démarrage.
L'USB bootable permet de créer un monde à la dimension de son imagination
https://www.letime.net

iznobe

Re : [résolu] ecriture dans fichier en c++

Malheureusement , je ne suis qu ' un " bidouilleur " autodidacte .
je n' ai que des connaissances superficielles dans quelques domaines .
je pense pas etre d' une grande aide sur le long terme

Dernière modification par iznobe (Le 11/05/2024, à 14:24)

---

retour COMPLET et utilisable de commande
MSI Z490A-pro , i7 10700 , 32 GB RAM .

temps

Re : [résolu] ecriture dans fichier en c++

J'ai commencé à lire la réponse.
Pour commencer moi aussi je suis un bidouilleur en c++, je préfère utiliser un langage bien plus bas qui me permet d'avoir beaucoup d'effets avec peu de moyen, un langage bien plus puissant composé de "goto". Je n'utilise ce langage que pour rappeler les techniques d'associations d'idées qui m'ont été enseignées, en passant par la démonstration ,que ce sont les variations cinétiques, qui créent les sons. En d'autres mots, j'essaie d'apporter au libre un format audio ultra léger qui ouvre l'esprit. Un format qui permet de créer des mélodies entièrement imaginées consommant très peu de ressources. La création est ce qui apporte le plus à l'homme, et je pense que le libre mérite d'avoir des outils comme celui-là.

Pour revenir au sujet, j'utilise trois boucles, elles sont différentes, la première est par rapport aux valeurs "i < poids; i=i+65536" la deuxième par rapport à "i < d; i=i+256)" et la troisième entre poids et i+256, il n'y a pas de répétition, chacune des boucle a une utilité différente.
Concernant les if c'est la partie non fini, mais fonctionnelle. Dans l'idée, je voulais mettre un switch, car il y a 4 octets en little endian donc une valeur différente pas octet. Comme en ce moment c'est le début, j'ai laissé pour plus tard l'ajout du quatrième octet. En détail, il y a 4 cas, mais 3 cas seulement possible avec 200 ondes nous somme sure d'avoir plus de 256 bit, un switch semble tout indiqué pour savoir sr combien d'octet nous allons écrire.

Concernant les variables, c'est pour séparer celle qui a servit dans la boucle de celle qui sert, de plus au controle avec ghex, je me suis aperçu qu'il fallait faire une correction de -1, par rapport au poids affichée par les logiciels audio testé. En théorie, c'est vrai que j'ajoute une variable inutile à chaque boucle. Sans doute un reste du temps ou je programmais les boucles de sécurité qui protégeaient des vies humaines. C'est vrai que ce n'est plus à la mode de doubler les sécurités, mais d'avoir une variable séparée laisse des ouvertures.
Id pour la ligne de fin, je préfère dire que je ferme le fichier, c'est totalement inutile puisque la fermeture de l'application le fait, mais je préfère le faire. Imaginez pour quelle raison qu'il y est une saturation qui perturbe le system
L'actualité pour moi, est de finir d'injecter les générateurs  dans le git, puis d'essayer de détailler le plus possible comment utiliser l'outil. Seulement à la fin je m'occuperai des langages de l'outil comme l'indentation.
Cordialement

---

Parce que l'USB bootable est le support des systèmes experts,
Parce que l'USB bootable contient sa propre image au démarrage.
L'USB bootable permet de créer un monde à la dimension de son imagination
https://www.letime.net