Migration of code from Pascal to C++

Pour faire une liste de chaîne il suffit d'utiliser la STL : std::list<std::string>
https://community.hpe.com/t5/custom/page/page-id/HPPSocialUserSignonPage?redirectreason=permissiondenied&referer=https%3A%2F%2Fcommunity.hpe.com%2Ft5%2FServers-Systems-The-Right%2FSGI-com-Tech-Archive-Resources-now-retired%2Fba-p%2F6992583
https://community.hpe.com/t5/custom/page/page-id/HPPSocialUserSignonPage?redirectreason=permissiondenied&referer=https%3A%2F%2Fcommunity.hpe.com%2Ft5%2FServers-Systems-The-Right%2FSGI-com-Tech-Archive-Resources-now-retired%2Fba-p%2F6992583

Pour le memory stream le plus simple c'est d'allouer un bloc mémoire (par exemple avec un malloc) et d'écrire dedans avec la fonction write :
http://www.linux-kheops.com/doc/man/manfr/man-html-0.9/man2/write.2.html

Pour manipuler un flux sur une chaîne utilise un std::istringstream ou un std::ostringstream.

Pour manipuler un handle, cf la doc microsoft.

Bonne chance

TStringList : je vais essayer avec ce qui vous avez dis

Voici un exemple :

#include <list>
#include <string>
#include <iostream>

int main(){
    // Préparer des chaînes
    std::string
        s1 = "plop",
        s2 = "pouet",
        s3 = "tapir";

    // Mettre les chaînes au bout d'une liste (initialement vide)
    std::list<std::string> l;
    l.push_back(s1);
    l.push_back(s2);
    l.push_back(s3);

    // Ecrire la liste
    std::list<std::string>::const_iterator
        lit (l.begin()),
        lend(l.end());
    for(;lit!=lend;++lit) std::cout << *lit << std::endl;
    return 0;
}

Ce qui donne à l'exécution :

plop
pouet
tapir

j'ai trouvé quelques chose comme ca ( TMemoryStream ^ ms = gcnew

Ca c'est pas du C++ tu peux me croire.

TMemoryStream; ) il parait qu'elle marche

Pas compris.

TStringStream : j'ai trouvé stringstream object ?

Non c'est vraiment std::ostringstream (pour écrire dans un buffer) et std::istringstream (pour lire dans un buffer).

#include <sstream>
#include <iostream>

int main(){
    std::ostringstream oss;
    oss << "plop" << 1.23 << ' ' << 69;
    std::cout << oss.str();
    return 0;
}

Ce qui donne à l'exécution :

plop1.23 69

THandleStream : pas de résultat

C'est normal la notion de handle n'existe pas spécialement sous linux et sous windows il y a sans doute des fonctions spécifiques. La vraie question c'est que veux-tu faire avec des handle.

Bonne chance

le compilateur l'a accepter en modifiant une option dans les propriétés du projet et je peux travailler avec elle . Alors je peux s'assurer d'elle ou non à ton avis ?

Mais tu programmes vraiment en C++ ? Car je n'ai jamais vu cette syntaxe ? Ou alors ce sont des macros et des fonctions spécifiques à ton code.

- Pour Handle j'ai un fichier que je veux l'ouvrir -> stocker son contenu dans ce Handle stream ensuite faire le traitement necessaire pour enfin stocker le contenu de ce Handle stream dans l'object MemoryStream .

En C++ pour manipuler un flux sur un fichier on utilise un std::ifstream ou un std::ofstream. Exemple :

#include <fstream>
#include <iostream>

int main(){
  std::ofstream ofs("pouet.txt");
  if(!ofs){
    std::cerr << "can't write pouet.txt" << std::endl;
    return 1;
  }
  ofs << "plop" << 1.23;
  ofs.close();
  return 0;
}

Bonne chance

Bien entendu, n'hésite pas ;-)

Aucune idée je ne fais pas de Pascal, mais j'imagine que c'est une un tableau de couple entiers dans {0,1}. Son équivalent en C++ serait un :

std::vector<std::pair<bool,bool> >

Exemple :

#include <vector>
#include <iostream>

typedef std::vector<std::pair<bool,bool> > my_array_t;

// Ecrire une paire
template <typename T1,typename T2>
std::ostream & operator << (std::ostream & out,const std::pair<T1,T2> & p){
    out << '(' << p.first << ',' << p.second << ')';
    return out;
}

// Ecrire un vecteur
template <typename T>
std::ostream & operator << (std::ostream & out,const std::vector<T> & v){
    typename std::vector<T>::const_iterator
        vit (v.begin()),
        vend(v.end());
    out << '[';
    for(;vit!=vend;++vit) out << ' ' << *vit;
    out << " ]";
    return out;
}

int main(){
    my_array_t my_array;

    // Remplir le tableau
    my_array.push_back(std::make_pair(0,1));
    my_array.push_back(std::make_pair(1,1));
    my_array.push_back(std::make_pair(1,0));
    my_array.push_back(std::make_pair(0,0));
    my_array.push_back(std::make_pair(1,0));

    // Et l'afficher
    std::cout << my_array << std::endl;

    // Afficher le 2e élement (ils sont indexés à partir de 0)
    std::cout << my_array[1] << std::endl;
    return 0;
}

... ce qui donne à l'exécution :

[ (0,1) (1,1) (1,0) (0,0) (1,0) ]
(1,1)

Bonne chance