Discussion :

[orichimaru]

salutation
alors voila, ce que je demande est tres simple : copier l'integralité d'un fichier dans la ram le plus rapidement possible

je sais que fopen existe et ausse CreateFile de l'api windows et pis y'a aussi les comandes de la classe stream (ofstream et tout )ou je sé pu trop
enfin bref

ce que je voudrais faire c avoir directement acces au disque dur : lui demander de mettre morceau par morceau un fichier dans sa memoire cache pour ensuite le copier dans la ram

donc : comment commande-t-on au dd ? il faut passer par un fichier msi info ?
comment accede-t-on a la memoire cache ?

a oui et une derniere toute petite question qui ne merite pas qu'on deplace mon topic : jai pas trouver dans la faq, comment on fait de l'asm sous VC6++ ? et c'est quoi le type de syntaxe (GNU-AS,MASM,NASM,TASM,..) ?

merci infiniment pour toute vos reponses !

[orichimaru]

a oui et j'ai oublié, comment fait on pour qu'un constructeur d'une classe alloue une classe,cad lorsque il est appelé il alloue l'objet de la classe, je ve dire faire comme en C avec les structures :
par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
class test {
public:
 char gniagnia;
 test(test testn)
 {testn=(test*)malloc(sizeof(test));}
};

et quant je tapes

test* t; et ba ca marche pas ....
pourquoi ca marche pas ?????

[Luc Hermitte]

La méthode C++ est normalement donnée dans la FAQ je crois. -- Pour les autres, se référer au C ou aux API que tu utilises.

Pour ce qui est de ton allocation ou je ne sais trop quoi, ce que tu veux écire n'a aucun sens.
D'abord malloc() n'est pas utilisable sur des objets (dans 99.99% des cas qui nous concernent, et 100% pour les débutants).
Ensuite, le constructeur s'occupe de construire l'objet pas de lui réserver de la place. Cela se fait à part : au moment de construire un nouvel objet. C'est d'ailleurs à ce moment là que l'on décidera où il vivra (tas, pile, zone statique).

Un conseil, oublie tout ce que tu as vu en C et apprend le C++ -- avec un vrai cours qui ne suppose pas que tu connaisses le C.

[orichimaru]

merci Luc skywalker

je l'avais vu dans la faq mais bon, ce n'est pas exactement ce que je recherche : en fait, il faut que ce soit le plus rapide possible : j'ai plusieurs centaines de petits fichiers a traiter et il faut vraiment que ca se depeche car ma conversion est rapide(un peu trop)
alors je me demandais si on pouvais faire du bas niveau en interrogant le dd directement ( a moins que les fnc de fstream ne le fassent ...)

sinon pour l'histoire de ma clasee :
en fait voila, imaginons que j'ai une classe : machin

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class machin 
{
public:
    char* unmachin; //un machin
 
    machin()   //mon constructeur
    {
 
      this->unmachin=(char*)malloc(5);  //on alloue
      strcpy(this->unmachin,"1234");      // on initialise
      *(this->unmachin+4)=0;    
    }
    ~machin()
    {
     free(this->unmachin);                    //on libere
     }
};

comment faire pour faire un pointeur sur un machin construit?
cad que si je fait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

machin* truc

j'ai un truc pret alloué et tout et tout et si je fait truc->unmachin j'ai bien "1234"

SANS FAIRE :
machin truct
machin *truc=&truct

[orichimaru]

en fait ce que je demande c 'est comment faire pour allouer this dans un constructeur

[Laurent Gomila]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

machin* truc = new machin;

Tu alloueras un nouvel objet machin sur le tas, son constructeur sera appelé (par new), et ses données seront donc bien initialisées.

[Luc Hermitte]

Le plus efficace est de se tourner vers les API du système d'exploitation => HS ici.


On n'alloue pas this dans un constructeur. Cela n'est strictement aucun sens. Un constructeur construit un objet et s'occupe éventuellement d'allouer et construire des ressources gérées par l'objet. L'allocation est extérieure à la construction => trouve toi un vrai cours de C++ et oublie ton C.

Pour les alloc dynamiques correctes, qui peuvent intervenir à plusieurs niveaux différents.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
// classe non copiable
struct NC
{ 
    NC() : ptr_(new T(p1, p2)) {}
    void f() { ptr_->do_smthg(v); }
private:
    // la ressource de NC, allouée et construite dynamiquement
    const std::auto_ptr<T> ptr_;
    // mieux:: boost:scope_ptr<T> ptr_;
};
 
// obj sur le tas, dit "automatique"
NC nc;
nc.f();
 
NC nc2 = nc; // interdit!!
NC nc3;
nc3 = nc; // interdit aussi
 
// obj sur le tas ; hyper simplifié
NC * pnc = new NC();
try { ... ; pnc->f(); .... }
catch ...... { ... }
delete pnc;
 
// obj sur tas bis -> localisé à un bloc
{ ... std::auto_ptr<NC> pnc2( new NC ); .... }
 
// obj sur le tas ter -> peut voyager entre des portées différentes
boost::shared_ptr<NC> pnc3( new NC );
 
 
//-----------------------
// classe copiable
struct C
{
    C() : ptr_(new T(p1, p2)) {}
    void f() { ptr_->do_smthg(v); }
private:
    boost::shared_ptr<T> ptr_;
};
 
// utilisation tout pareil, sauf que
C c2 = c;
C c3;
c3 = c;
// marchent
 
//--------------------------
// classe copiable, fait main; version valide pour une et 
// une seule ressource ; ici un pointeur
struct CM {
    CM() : ptr_(new T(p1, p2 )) {}
    ~CM() { delete ptr_; } // nécessaire
 
    CM( CM const& rhs )  // nécessaire
    : ptr_( new T(rhs.ptr_) )
    // ou "ptr_( rhs.ptr_->clone() )" suivant la sémantique de T
    {} // toujours pas de corps
 
    CM & operator=(CM const & rhs) // nécessaire également
    { CM tmp(rhs); swap(tmp); return *this; }
 
    void swap( CM & other ) { std::swap(ptr_, other.ptr_); }
 
    void f() { ptr_->do_smthg(v); }
private:
    T ptr_;
};
 
// utilisation comme pour la classe C

[HRS]

indépendamment de C/C++, Win9X permet d'utiliser la RAM comme un
lecteur disque, en mettant dans le config.sys

device=C:\WINDOWS\ramdrive.sys

voir si pour Win2K ou XP, il y a l'équivalent

[tut]

pour ton histoire de pointeurs et fichier,
il éxiste des fonctions de l'API Windows qui permettent de faire ça, ça s'appelle les fichiers mappés. Ca permet d'obtenir un pointeur sur le début d'un fichier.
J'ai remarqué, dans le cadre d'une utilisation particulière sur des fichiers de taille entre 0 et 10 Mo, nécessitant une multitude de lectures entre 1 et 100 octets que c'était plus rapide que les fonctions classiques fopen(), stream et CreateFile().

Cherche dans la MSDN les fonctions suivantes :
CreateFileMapping()
MapViewOfFile().

Comment le mapping est géré par Windows, je n'en sais rien, est-ce qu'il copie l'intégralité du fichier en RAM ? est-ce qu'il copie seulement ce dont il a besoin ? aucune idée...

[orichimaru]

merci infiniment pour toute vos reponses et
excusez moi monsieur hermitte de n'a pas avoir bien sais le concept de constructeur, mais maintenant ca va mieu, par contre eu .... votre code, c pas de mon level

sinon, HRS, je comprend pas, ca va forcer windows a utiliser la ram comme buffer lorsque'il lit qqchose sur le disque ? c pas deja ce qu'il fait ?

et merci bcoup tut, je vais tester tous ca, et je vais voir laquelle des fonctions est la plus rapide pour mettre un fichier en ram

merci encore a tous !