Ubuntu-fr

temps

[résolu] concaténer hexa en langage C++

Bonjour,
je cherche à générer puis concaténer en hexadecimal dans un fichier.
L'idée est d'introduire les valeurs de 50 ondes, le fichier serait du type :

4952 4646 6414 0000 4157 4556 6d66 2074
0010 0000 0001 0001 ac44 0000 5888 0001
0002 0010 6164 6174 63f0 0000 0077 0079
0076 007c 007d 0079 0081 0079 007f 0080
007b 007e 007d 0079 007f 0077 0077 007a
006f 0077 006b 006f 0068 0068 005d 0068
004d 0067 003d 005c 003f 0047 0038 003a
002a 0033 001b 0020 0016 0010 0003 0005
ffef fff8 ffe4 ffe0 ffd9 ffcd ffc4 ffbc
ffb6 ffa8 ffa4 ff94 ff8d ff86 ff79 ff6d
ff6a ff56 ff56 ff45 ff3c ff33 ff23 ff26
ff09 ff0f fefa fef0 fef2 fed2 fee2 fec0
fec8 feb2 feb2 fe9e fea8 fe87 fe92 fe7c
fe80 fe6f fe70 fe60 fe60 fe57 fe50 fe4d
 fe48 fe40 fe3e fe35 fe37 fe32 fe2c fe2b
fe27 fe24 fe27 fe1f fe20 fe1d fe1f fe1a
fe1e fe19 fe1e fe19 fe1d fe1b fe1d fe1f
fe22 fe1b fe2b fe1d fe31 fe24 fe32 fe2f
fe37 fe3c fe3e fe45 fe4c fe4f fe5a fe61
fe62 fe79 fe74 fe88 fe8e fe9b fea4 feb7

Cordialement

Dernière modification par temps (Le 09/04/2024, à 08:15)

---

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

xubu1957

Re : [résolu] concaténer hexa en langage C++

Bonjour,

Pour ajouter toi-même les balises code à ton précédent message #1 :            Merci           

• Cliquer sur le lien « Modifier » en bas à droite du message

• Sélectionner le texte

• Cliquer sur le <> de l'éditeur de message

comme indiqué dans le : Retour utilisable de commande

Lecture conseillée > memento des balises code.

Dernière modification par xubu1957 (Le 13/03/2024, à 18:07)

---

Conseils pour les nouveaux demandeurs et pas qu'eux
Important : Pensez à passer vos sujets en [Réso|u] lorsque ceux-ci le sont, au début du titre en cliquant sur Modifier sous le premier message, et un bref récapitulatif de la solution à la fin de celui-ci. Merci.                   Membre de Linux-Azur

pingouinux

Re : [résolu] concaténer hexa en langage C++

Bonjour,
Je ne comprends pas ce que tu cherches à faire.
Il faudrait un petit exemple :
- ce que tu as en entrée
- ce que tu veux en sortie

temps

Re : [résolu] concaténer hexa en langage C++

Bonjour,
Merci pour les réponses. Je n'ai pas utilisé la balise code car ce sont des données ce n'est pas du code.
En détail, je reprends des travaux sur les lois de l'audio que j'avais laissé tombé par obligation.
Ici nous reconnaissons l'entête d'un fichier audio
Ma démarche est de générer la voix humaine, je donne les informations sur ma progression ici Essais sur l'audio
Je viens de me souvenir qu'avant le javascript j'utilisais le C++, ainsi je cherche à faire un code qui génère 30 ondes en suivant mes instructions.
En d'autres mots, je vais gratter mes anciennes notes orientées en c++, j'espère les retrouver

Pour résumer en entré, j'ai du savoir qui s'exprime à travers les codes, et en sortie j'ai un fichier audio en .wav

Cordialement

Dernière modification par temps (Le 13/03/2024, à 17:45)

---

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

xubu1957

Re : [résolu] concaténer hexa en langage C++

Dans les règles du forum > balises BB code

Balise CODE :

C'est la balise à utiliser pour donner de longs messages d'erreurs, des contenus de fichiers de configuration, des commandes à taper, etc … Elle permet des messages plus "compacts", et est moins ambiguë que d'autres polices sur certains caractères.

---

Conseils pour les nouveaux demandeurs et pas qu'eux
Important : Pensez à passer vos sujets en [Réso|u] lorsque ceux-ci le sont, au début du titre en cliquant sur Modifier sous le premier message, et un bref récapitulatif de la solution à la fin de celui-ci. Merci.                   Membre de Linux-Azur

temps

Re : [résolu] concaténer hexa en langage C++

Pour démarrer je cré l'exe avec

g++ '/home/x/main.cpp'  -std=c++11 -Wall -Wextra -o '/home/x/executable'

pour créer et commencer à écrire le fichier audio

#include <iostream>
#include <fstream>
using namespace std;
int main (void)
{
unsigned char cre = 0x0052;
unsigned char cre1 = 0x0049;
unsigned char cre2 = 0x0046;
unsigned char cre3 = 0x0046;

ofstream f ("son-o.wav", ios::out | ios::binary);
if(!f.is_open())
cout << "Impossible d'ouvrir le fichier en écriture !" << endl;
else
      {

                  f<<cre<<cre1<<cre2<<cre3<<endl;

      }

f.close();
return 0;
}

Dernière modification par temps (Le 13/03/2024, à 19:18)

---

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] concaténer hexa en langage C++

Bonjour,
l'idée est dans le code qui génère le son "ou" donné précédent.
L'objectif 1 est de générer les formes sans passer par des tableaux, mais à l'aide d'une loi qui donne la variation de l'onde.
L'objectif 2 est de créer une boucle qui lance les générateurs de forme de manière à alléger le code
l'objectif 3 est de mettre la règle qui passe le son "ou", en son "o" ...
l'objectif 4 est de mettre une règle qui place les différentes consonnes au choix à la demande devant la voyelle
Il s'entend que je ne suis qu'au début du projet.
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

grigouille

Re : [résolu] concaténer hexa en langage C++

Une version de ton code plus courte :

#include <iostream>
#include <fstream>
#include <vector>
typedef unsigned char uchar;

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


	std::ofstream f ("son-ou.wav", std::ios::binary);
	if(!f) {
		std::cerr << "Impossible d'ouvrir le fichier en écriture !" << std::endl;
		return 1;
	}

	for(std::vector<uchar> v : tab) {
		for(uchar c : v) {
			f << c;
		}
	}
}

---

Debian (xfce) 12
HP LaserJet M1132 MFP

lann

Re : [résolu] concaténer hexa en langage C++

Tu n'as pas de type. unsigned n'est pas un type.
Tu devrais mettre unsigned char je suppose.
Cela dépend du nombre d'octet que tu veux enregistrer.
Donc si je prends ta fonction :

	    unsigned char bascule1(unsigned char ba1, unsigned char ba2, unsigned char repet, unsigned char repet1)
{
for (repet1 = ba1; repet1 < ba2; repet1++) { for (repet = 0; repet < 2; repet++) { return (repet1) ; } };
}

---

<Modéré>

lann

Re : [résolu] concaténer hexa en langage C++

Pouir moi

struct base

ce n'est pas une structure mais uns constante

const

Une structure c'est au moins deux variables :

struct test
{
   int a;
   int b;
};

---

<Modéré>

krodelabestiole

Re : [résolu] concaténer hexa en langage C++

Le but à moyen terme est de prouver que les systèmes mathématiques actuel ne sont pas adaptés aux lois physiques et à l'entendement

ça avait pourtant l'air de fonctionner assez bien pour décrire pas mal de choses dans notre environnement et notre univers, et même prédire des mécanismes observés expérimentalement après coup.
si ça peut résoudre les tensions persistantes entre l'observation et la théorie...

je me demande comment sont choisies, traduites ou générées ces valeurs hexadécimales ?

---

nouveau forum ubuntu-fr on en parle là : refonte du site / nouveau design
profil - sujets récurrents - sources du site

temps

Re : [résolu] concaténer hexa en langage C++

Concernant les valeurs, mon principal problème est que je suis diminué par l'age et j'ai oublié le peu des techniques de codage que j'avais.
En fait ce sont plusieurs lois de plusieurs dimensions que je mets en équilibre.
L'expérience d'affinage de milliers de fichiers audio pendant ma carrière me permet d'avoir un acquis que j'essaie de donner
Il y a plusieurs règles à respecter, les équilibres entre les dimensions sont fragiles, un seul front (demie onde) fort ( comme un marteau acoustique) dans une zone d'assimilation d'une onde suffit à le détruire.
ici pour retrouver une base sur laquelle construire les voyelles, j'ai marié deux vagues, un peu comme si nous avions une vague dans la vague. Il aurait été plus simple de dessiner un m avec une bosse du m plus faible, mais comme le même son peut être créer d'une multitude de manière, j'ai préférer utiliser cette méthode pour ouvrir les portes. Cette forme se retrouve plus dans le chant de ceux qui ont des cordes vocales parfaites, le m est le plus courant.
Je vais affiner la forme pour présenter un "o" et un "a" et un ... plus audible, ensuite je vais montrer qu'avec la même forme nous produisons un grand nombre de consonnes

Pour passer du son "A" au son "O" en utilisant la construction que j'utilise, il faut doubler le nombre sur les fronts les plus forts du genre 1-2-1-2-1-2 le 1 étant dans ma construction environ 20 ce qui se traduit dans le code par

+20

dans mon exemple seul les fronts descendant fort dans case 5 sont modifiés, cela suffit. cela donne

int mem;
 
	          for (int j=0; j<139; j++)
          {
         
          
          if (((k3[j]-k1[j]) <= 45) && ((k3[j]-k5[j]) <= 45)) {mem =1;}
          if (((k3[j]-k1[j]) > 45)&&((k3[j]-k1[j]) < 100)&&((k3[j]-k5[j]) > 45)&&((k3[j]-k5[j]) < 100)){mem =2;}
          if (((k3[j]-k1[j]) > 45) && ((k3[j]-k5[j]) < 45)) {mem =3;}
          if (((k3[j]-k1[j]) < 45) && ((k3[j]-k5[j]) > 45)) {mem =4;}
          if (( (k3[j]-k1[j]) >= 100 ) && ( (k3[j]-k5[j]) >= 100 ))  {mem =5;}
          
switch(mem) {
  case 1:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-6); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;}
  	    for (repet1 = (k3[j]-6); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1]; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < k4[j]; repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k3[j]-5); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k3[j]-5); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;}
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < k6[j]; repet++){ f<<tabn[repet1]; }
 

    break;
  case 2:




  	    for (repet1 = (k1[j]); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++; repet1++;}
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < k4[j]; repet++){ f<<tabn[repet1]; }
 	    // fin monte 
	    
	    

  	    for (repet1 = (k3[j]); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--;repet1--; repet1--;}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < k6[j]; repet++){ f<<tabn[repet1]; }
// fin descend 

    break;
  case 3:
  	    for (repet1 = (k1[j]); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++; repet1++;}
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < k4[j]; repet++){ f<<tabn[repet1]; }
 	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-2); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-2); repet1 > (k3[j]-3); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k3[j]-3); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;}
    	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < k6[j]; repet++){ f<<tabn[repet1]; }
 // fin descend 
    break;
  case 4:
	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+3); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k1[j]+3); repet1 < (k3[j]-3); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;}
  	    for (repet1 = (k3[j]-3); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < k4[j]; repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
  	    for (repet1 = (k3[j]); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--;repet1--; repet1--;}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < k6[j]; repet++){ f<<tabn[repet1]; }
// fin descend 
  	    repet1 = k5[j]; for (repet = 0; repet < k6[j]; repet++){ f<<tabn[repet1]; }
    break;
    
   case 5:

  	    for (repet1 = (k1[j]); repet1 < (k3[j]); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++; repet1++;repet1++;}
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+20); repet++){ f<<tabn[repet1]; }
 	    // fin monte 
	    	    
  	    for (repet1 = (k3[j]); repet1 > (k5[j]); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--;repet1--; repet1--;repet1--;}
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+20); repet++){ f<<tabn[repet1]; }
// fin descend 

    break;   
    
  default:
	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;}
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < k4[j]; repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < k6[j]; repet++){ f<<tabn[repet1]; }
// fin descend 
} //fin switch

 } //fin boucle du for
 /**********************************************************/

Donc pour la voix humaine, il nous faut peu de valeurs au centre des fronts de crêtes, et beaucoup de valeurs vers les sommets. Pour éviter de dessinner un m avec une bosse plus petite, il faut décaler une onde sur deux, voici le tableau qui montre le delta entre point haut et point bas, puis différence de hauteur des points bas, puis différence de hauteur des points hauts. Vous remarquerez qu'il y a une onde haut puis une onde bas, puis une onde haut ... et ceci inversé de l'autre coté de la médiane pour la dépression :

61	6	188	4		127	4	-12
63	5	179	6		116	-2	9
61	6	188	3		127	2	-9
65	5	175	7		110	-4	13
64	7	180	7		116	1	-5
70	8	166	2		96	-6	14
70	2	170	3		100	0	-4
77	2	157	5		80	-7	13
75	6	161	5		86	2	-4
81	5	150	6		69	-6	11
79	6	156	8		77	2	-6
88	7	149	8		61	-9	7
84	8	153	8		69	4	-4
92	8	147	8		55	-8	6
88	11	149	10		61	4	-2
95	11	145	9		50	-7	4
90	12	146	12		56	5	-1
99	13	144	9		45	-9	2
91	10	146	11		55	8	-2
100	12	145	11		45	-9	1
94	11	148	10		54	6	-3

colonne 1 :crête basse, colonne  2 repet bas, colonne 3 crête haute, colonne 4 repet haut, colonne 5 delta entre crête haut et bas, colonne 6 delta entre crête bas, puis dernière colonne delta crête haut
A éviter imperativement ce sont les variations brusques qui produirait des marteaux accoustique, et il faut que chaque train d'ondes se marient pour éviter les chocs

Dernière modification par temps (Le 08/04/2024, à 13:06)

---

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

krodelabestiole

Re : [résolu] concaténer hexa en langage C++

je ne suis pas sûr que ces messages correspondent au sujet initial. ça aurait peut-être plus sa place dans Vos développements libres ?

au delà de ça d'une manière générale je déconseille d'utiliser le wiki (la doc ubuntu-fr) ou le forum pour maintenir ou partager du code (c'est d'ailleurs une remarque que je fais régulièrement ici ou sur la mailing list du wiki).
ça alourdit le travail des moteurs de recherche de ces outils qui opèrent sur ce contenu textuel et je ne pense pas que ces plateformes soient globalement adaptées (que ce soit du point de vue technique, des fonctionnalités ou de la visibilité, encore plus sur le long terme). les service fournis autour de dépôts git en particulier sont bien plus efficaces pour ce genre de choses :
framagit, gitlab, github, etc.
on peut facilement lire et télécharger le code, le modifier en conservant un historique, ou seulement proposer des modifications, etc.
on peut par contre très bien tenir informé de l'avancée de ses travaux ici ou sur un blog si on en a envie (je parle bien du code ici, et d'un point de vue technique).

---

nouveau forum ubuntu-fr on en parle là : refonte du site / nouveau design
profil - sujets récurrents - sources du site

temps

Re : [résolu] concaténer hexa en langage C++

Merci pour la réponse, je suis loin d'avoir le code comme je l'entends.
en fait j'essaie de montrer, en exemple pour avoir un son "a" plus cristallin, il faut corriger les défauts induits par ma technique de construction. J'ai commencé à corriger le début :

bascule1(127,4,137,10,125,9,139,11,124,8,140,10,121,8,141,9,121,7,143,9,117,6,143,8,118,6,146,7,113,5,145,6,115,5,149,6,109,3,147,5,112,4,152,8,105,7,149,3,109,4,155,12,101,11,151,12,106,12,158,11,97,10,153,11,103,12,161,10,93,9,155,10,100,11,164,9,89,7,157,9,97,10,167,8,85,6,159,8,94,9,170,7,81,5,161,7,91,8,173,6,77,4,163,6,88,7,176,5,73,3,165,5,85,7,179,4,69,4,167,3,82,4,182,3,65,4,169,3,79,4,185,3,61,4,171,3,76,4,188,3,57,4,173,3,73,4,191,3,53,4,175,3,70,4,194,3,49,4,177,3,67,4,197,3,45,4,179,3,64,4,200,3,41,4,181,3,61,4,203,3,37,4,183,3,58,4,206,3,33,4,185,3,55,4,209,3,29,4,187,3,52,4,212,3,25,4,189,3,49,4,215,3,21,4,191,3,46,4,218,3,17,4,193,3,43,4,221,3,13,4,195,3,40,4,224,3,9,4,197,3,37,4,227,3,5,4,199,3,40,4,224,3,9,4,197,3,43,4,221,3,13,4,195,3,46,4,218,3,17,4,193,3,49,4,215,3,21,4,191,3,52,4,212,3,25,4,189,3,55,4,209,3,29,4,187,3,58,4,206,3,33,4,185,3,61,4,203,3,37,4,183,3,64,4,200,3,41,4,181,3,67,4,197,3,45,4,179,3,70,4,194,3,49,4,177,3,73,4,191,3,53,4,175,3,76,4,188,3,57,4,173,3,79,4,185,3,61,4,171,3,82,4,182,3,65,4,169,3,85,4,179,3,69,4,167,3,88,4,176,3,73,4,165,3,91,4,173,3,77,4,163,3,94,4,170,3,81,4,161,3,97,4,167,3,85,4,159,3,100,4,164,3,89,4,157,3,103,4,161,3,93,4,155,3,106,4,158,3,97,4,153,3,109,4,155,3,101,4,151,3,112,4,152,3,105,4,149,3,115,4,149,3,109,4,147,3,118,4,146,3,105,4,145,3,115,4,143,3,101,4,143,3,112,4,140,3,97,4,141,3,109,4,137,3,93,4,139,3,106,4,134,3,89,4,137,3,103,4,131,3,85,4,135,3,100,4,128,3,81,4,133,3,97,4,125,3,85,4,131,3,100,4,122,3,89,4,129,3,103,4,119,3,93,4,127,3,106,4,116,3,97,4,165,3,109,4,160,3,101,4,150,3,112,4,140,3,120,4,130,3);

de manière à obtenir de l'aide des codeurs en c++, ensuite un fois les lois assimilées, créer une class par son de voyelle et de consonne.
En fait, je cherche de l'aide en c++

Mais il faudrait qu'un modérateur juge, et si le sujet doit être indiqué en résolu et déplacé, je ferai comme il se doit ma démarche est de suivre les règles de manière à respecter un bon fonctionnement.

J'entends la remarque et la respecte, je peux effacer les messages si la demande est renouvelée, mais cela signifie pour moi , la fin d'une éventuelle aide pour finir le code.
Cordialement

P.S. Je vais regarder au mieux et rectifier en ne laissant que les messages pertinents, je m'en occupe dans la journée.

Dernière modification par temps (Le 08/04/2024, à 23:41)

---

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

krodelabestiole

Re : [résolu] concaténer hexa en langage C++

En fait, je cherche de l'aide en c++

alors tu es dans la bonne section.
mais je ne vois pas trop où est formulée la question... il faudrait peut-être simplifier le problème (et en particulier tes exemples) ? si tu as du mal avec la syntaxe en général je pense pas contre qu'il faut que tu te formes un minimum (ou que tu engages un développeur ?).

Dernière modification par krodelabestiole (Le 08/04/2024, à 23:55)

---

nouveau forum ubuntu-fr on en parle là : refonte du site / nouveau design
profil - sujets récurrents - sources du site

temps

Re : [résolu] concaténer hexa en langage C++

Je cherche à créer des class qui générerons les fichiers sons.
Actuellement j'utilise une fonction qui se trouve dans le main
cette fonction doit pouvoir contenir des centaines d'arguments dont certains servirons à indiquer la class selon le son désiré
Si je montrais les lois ici, c'était pour avoir de l'aide pour créer les codes, mon intention étant ensuite de mettre les codes avec explications sur framacolibri et sur mon site en téléchargement
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

krodelabestiole

Re : [résolu] concaténer hexa en langage C++

ok, mais le problème ici, c'est que tu montres du code et que tu demandes de l'aide sans poser de question précise.

je pense que personne ici n'a la moindre idée de ce qu'est sensé faire ton programme (ajuster "l'équilibre entre les dimensions" si je reprends tes mots). on ne sait pas comment le programme communique avec le serveur de son (si il est seulement sensé le faire ?).
dans ce cas je pense que le seul moyen d'obtenir de l'aide est de réduire la demande à des questions précises et intelligibles : "pourquoi telle variable n'est pas renseignée à tel endroit ?" par ex.

l'hexadécimal est un format de représentation numérique utilisé en informatique parce qu'une base 16 est une puissance de 2 contrairement à 10.
hors à ma connaissance on ne concatène pas des nombres, mais des chaînes de caractères, donc je pense qu'on a déjà une erreur dans les termes.
si je concatène 10 et 3 ça donnera 103. et ça n'aura pas du tout le même effet en hexadécimal ou en binaire...

je suis pas tellement sûr que ce soit ce que tu cherches vraiment à faire ?

---

nouveau forum ubuntu-fr on en parle là : refonte du site / nouveau design
profil - sujets récurrents - sources du site

temps

Re : [résolu] concaténer hexa en langage C++

Merci pour la précision.
J'associe bien des chaînes de caractère contrains par les normes des fichiers audio. Donc en hexa concaténées.
Je dis des choses très simples, mais je me heurte aux formatages et croyances.
Il est vrai qu'un débutant en programmation m'aurait permis de montrer ce que je veux montrer dès qu'il va associer les idées comme je le décris.
Pour revenir au fil, comme dit, il est important pour moi de ne pas créer de gène dans le forum ou causer un soupçon de bruits sur les serveur.
Je pense qu'il faut protéger la communauté du libre et surtout ne pas apporter de gène.

Le temps d'effacer les bruits parasites sur mes sons, je crée sur mon site une page et je reviens en essayant de poser des questions pour résoudre les nombreux problèmes de codage qu'il me reste pour arriver à créer le format audio désiré.
Je poste en résolu, car quand je cré mes fichiers audio, maintenant j'arrive bien à concaténer.
Comme dit,
La page d'accueil du format audio est en construction ici
le code fonctionnel créé dans ce fil est ici
Cordialement

Dernière modification par temps (Le 09/04/2024, à 17:02)

---

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