Réserver un espace mémoire d'une taille déterminé

"Pascal" <pascal@spam.org> a écrit dans le message de news:
41f92520$0$4765$626a14ce@news.free.fr...

Bonjour,

Je dois programmer le stockage en mémoire persistante (donc un fichier)
d'une page. Une page est un espace mémoire *vive* de taille paramétrable
(mettons 512 octets). Il faut donc que j'alloue 512 octets, et que
j'écrives ces 512 octets dans un fichier.

Comment faire? Sachant qu'il faudra que je puisse travailler bit à bit sur
cette structure.
--
Pascal

bonjour,
tu peux utiliser std::malloc, qui renvoie un void *
void *ptr = std::malloc(512); // allocation de 512 octets
// on se sert de la structure
std::free(ptr); // on libere

pour travailler bit à bit c'est moins simple, puisqu'à priori on ne peut
accéder qu'octet par octet à la mémoire. Néanmoins, un bitset (une sorte de
structure C) peut convenir, par exemple :
struct OCTET
{
int bit0:1;
int bit1:1;
int bit2:1;
...
int bit7:1;
};

cette structure doit tenir sur un seul octet (attention à d'éventuels
alignements, qu'il faudra désactivement, voir suivant le compilo) et peut
être utilisée, à ce moment plutôt qu'un malloc tu peux faire :

OCTET Page[512];

ou si tu préfères allouer sur le tas et pas sur la pile
OCTET* Page=new OCTET[512];
...
delete[] Page;

et pour s'en servir :
Page[5].bit3 = 1; // passes le 3e bit de la 5e valeur de la page à 1...

"Alexandre" <alex.g@netcourrier.com> writes:

void *ptr = std::malloc(512); // allocation de 512 octets
^^^^^^

multiplets

--drkm

Pascal wrote:

Je dois programmer le stockage en mémoire persistante (donc un
fichier) d'une page. Une page est un espace mémoire *vive* de
taille paramétrable (mettons 512 octets). Il faut donc que
j'alloue 512 octets, et que j'écrives ces 512 octets dans un
fichier.

Dans quel format ? Sans savoir le format que tu vuex écrire,
c'est impossible à dire comment le faire exactement. (Note que
si ton format n'a pas d'entités plus grand que huit bits, et
n'admet pas que les entités peuvent s'échevaucher les limites
d'un octet, c'est probable que tu puisses travailler dans le
même format interne à ton programme.)

Comment faire? Sachant qu'il faudra que je puisse travailler
bit à bit sur cette structure.

Il y a plusieurs possibilités de travailler bit à bit en C++ :
std::bitset, std::vector<bool>, ou simplement avec un tableau de
unsigned char, et des fonctions qui conviennent. (Il existe
aussi d'autres alternatifs sur la toile -- il y a des ensembles
de bit à mon site, par exemple.)

Si ton problème est simplement comment lire ou écrire un seul
bit à la fois :

! void
! setBit( unsigned char* dest, int index )
! {
! dest[ index / CHAR_BIT ] |= 1 << (index % CHAR_BIT) ;
! }

! void
! resetBit( unsigned char* dest, int index )
! {
! dest[ index / CHAR_BIT ] &= ~( 1 << (index % CHAR_BIT) ) ;
! }

! bool
! testBit( unsigned char const* dest, int index )
! {
! return (dest[ index / CHAR_BIT ]
! & (1 << index % CHAR_BIT)) != 0 ;
! }

--
James Kanze GABI Software http://www.gabi-soft.fr
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34