il y en a peut-être qui s´y intéresse mais qui pense que c´est quelque chose du style rpg maker et ils comprennet rien et abandonnent en un quart d´heure

c´est vrai en effet...
mais bon, il y en a, quand ils essaient, y trouve un interet dans la démarche logique, et prennent du plaisir a faire de petits algos. et c´est ça qui met, lentement mais surement, sur la voie de la prog de jeu...

J´aimerais savoir, en joignant à un programme une librairie statique qui, elle-même, en utilise d´autre ( donc, autrement dit, si je fais une lib static qui comporte un #include < string.h>) est-ce que le programme principal, en utilisant la prèmière librairie statique, se trouve à disposer automatiquement des deux ( logiquement il me semble que oui) ?

Je suis en train d´essayer de wrapper la lecture de . ini dans un objet ( lire un . ini étant un truc plutôt simple pour lequel j´ai déjà quelques fonctions de fait ici et là et ayant besoin de pratique en POO, c´est plutôt parfait ) et j´utilise un string pour être 100% positif sur l´absence de buffer overflow. Le hic c´est que je me vois mal distribuer ( j´ai pas vraiment l´intention de distribuer ça mais tant qu´à faire le travail, aussi bien le faire aussi pro que possible) une lib qui force le programme à utiliser string.h... Et je me vois tout aussi mal ajouter à mon programme une classe similaire à string mais fait de mes 10 doigts ( perte de temps).

ben si tu linkes en static, tu ne distribue rien de plus que l´exe : il contient tout ( c´est d´ailleurs l´avantage du static...)
Donc la réponse à ta question est " oui", en faisant en static ton programme récupère toutes les fonctionnalités des librairies ; en pratique tu ne distribues JAMAIS une lib, sauf si tu fournis justement une API par exemple ( des morceaux de code que d´autres utiliseront)
En dynamique la question serait toute autre ; mais tu pourrais par exemple générer une librairie dynamique ( .dll) qui contiennent des bouts de codes externes ; bref y´a pas mal de possibilités ; )

Heh bien, merci LGV, j´ai décidé de laisser tomber string.h et de faire de l´allocation dynamique. Ça m´a permis de constater un petit problème que j´ignore comment solutionner. Supposons la classe suivante:

class MyClass
{
char *txt;

public:
MyClass(void); / / Constructeur par défaut
MyClass(const char *); / / Constructeur
~MyClass(void); / / Destructeur
};

L´objectif ici étant de faire en sorte qu´il soit possible d´écrire

MyClass XXX = " voici du texte";

Et que " ..." se retrouve dans char *txt

• Idéalement il faudrait aussi overloader l´opérateur = mais c´est pas important pour le problème ici*

Alors pour qu´il n´y ait aucun buffer overflow, il faut allouer dynamiquement txt mais c´est impossible d´initialiser une variable à l´intérieur de la déclaration d´une classe ( sauf, je pense, pour les membres const static int).

Mon idée était donc de faire... ( je ne préciserai pas ici le constructeur par défaut puisque c´est pas important pour le problème en cour)

MyClass::MyClass(const char *source)
{
char *txt = new char[sizeof(source) + 1];
strcpy(txt , source);
txt[sizeof(source)] = ´\0´;
return;
}

Et, pour le destructeur...

MyClass::~MyClass(void)
{
delete[] txt;
return;
}

Hors, l´allocation dynamique avec new se fait ( à tout le moins le texte se place et j´y ai accès sans plantage ( j´ai testé avec un printf...)) mais le delete[], lui, plante. Qu´est-ce qui se passe ?

plusieurs possibilités : une première piste rapide avant que je ne repasse plus tard en détail :
sizeof(source) => sizeof(char *) => 4 ( en win32)
ce que tu veux c´est strlen(source), c-a-d le nb de caractères ; le sizeof, c´est la taille du type de données, donc la taille d´un pointeur ( d´où le 4 ^^^^)

à plus tard pour plus d´infos...

petit complément :

MyClass XXX = " texte";

tout bon compilo effectuera:

MyClass XXX("texte");

1 seul ctor à la place de 2 ctors ( un par défaut, un avec param, et un opérateur d´assignation)

dans tous les cas, écrire la forme canonique est conseillée.

les ctor avec un seul param n´ont pas que des fans : meme si ça permet d´automatiser, on préfère en général les mettre explicit pour eviter de masquer du code qui peut parfois etre couteux

dans ton cas, rajouter un operateur de conversion MyClass => char * peut etre interessant

voilà voilà, de plus je pense que le strcpy copie également le \0 terminal, il ne sert donc à rien de le mettre à la main ( à vérifier)

avec le sizeof corrigé en strlen ça devrait marcher

Je viens de faire le test avec strlen, ça ne fonctionne pas.

Bonjour à tout les forumeurs d´ici j´ai une question j´ai quelques bases en programmation disons que mon niveau est de 2/10 en programmation pourriez vous me citer un site simple et efficace pour me permettre de comprendre un peu mieux la programmation de manière simplifiée ( pas un site de nOOb quand même )

Merci d´avance

si tu as déjà 2/10 en programmation, je te conseille plutôt de t´orienter vers un bouquin

> arnaud-le-vrai

Est-ce que ta question est en rapport avec le C++ ( je veux dire, est-ce que tu cherches à comprendre ce langage en particulier) ? Si c´est le cas, je pense que le site de lapintade donne suffisement d´information pour savoir où aller pour commencer ( ça couvre un peu de tout en ce qui concerne faire des jeux en fait):
http://perso.wanadoo.fr/ck/Langages.htm

Si tu cherches à comprendre la programmation au sens général, tu aurais probablement dû partir un nouveau topic... Sinon je suppose que tu devrais te trouver un bouquin et faire des recherches sur le web. Voici un site quand même:
http://fr.wikipedia.org/wiki/Programmation

En ce qui concerne mon problème j´ai fais quelques petits tests ici et là.

strlen ne change rien à la problématique. Il est vrai que j´étais dans le faux avec mon sizeof sauf que j´assignais le mot " test" ( 4 lettres) à mon char ce qui, à coup de coïncidence, a fait que l´assignation ne plantait pas. Et, d´ailleurs, merci LGV, j´avais pas vu ça venir et ça aurait définitivement planté plus tard.

Hors, présenteent, l´allocation fonctionne, c´est vraiment le delete[] qui plante. Le char dynamique est accessible, utilisable et ne semble pas contenir d´erreur.

En ce qui concerne le = ´\0´, strlen retourne le nombre de caractère en incluant celui de terminaison. Alors je suppose que l´ajouter manuellement est superflu si l´on considère que je fais un strcpy dont la source est un const char * qui contient le caractère de terminaison. Je laisse quand même l´assignation manuelle dans mon code, question d´être bien sûr.

Whew j´ai mal lu MSDN, strlen EXCLU le caractère de terminaison. Bonne chose que j´ai laissé l´assignation manuelle du ´\0´.

Dernier message que je poste ici à ce sujet ( à moins que quelqu´un me réponde auquel cas je vais dire merci ou que je trouve la réponse au problème ) .

J´ai écris un programme qui illustre le problème:

1. include < iostream>

using namespace std;

class MyClass
{
char *txt;

public:
MyClass(void);
MyClass(const char *);
~MyClass(void);
};

MyClass::MyClass(void)
{
return;
}

MyClass::MyClass(const char *source)
{
char *txt = new char[strlen(source) + 1];
strcpy(txt , source);
txt[strlen(source)] = ´\0´;

printf("Nombre de lettres: %d\nContenu: %s\n" , strlen(txt) , txt);

return;
}

MyClass::~MyClass(void)
{
delete[] txt;
return;
}

int main(int argc , char *argv[])
{
MyClass XXX("Bonjour bonjour");
system("pause");
return EXIT_SUCCESS;
}

La compilation passe, le programme roule et ça plante à lorsque le destructeur est appellé. C´est du win32 seulement à cause de system("pause"); ( trop paresseux pour trouver quelque chose de plus propre et portable).

tu pourrais mettre tout ça dans un . cpp et le paster sur www.pastebin.com ? ça nous permettrait de tester rapidement chez nous ; c´est plus facile de voir où ça foire en expérimentant

au passage, la convention C++ veut qu´on ne mette pas les void dans le proto d´une fonction/methode qui n´a pas d´argument, de meme pas de return " vide" . Bon, ça ne change rien, mais ça aide à l´uniformité lorsqu´on mixe son code avec d´autres.

ah ben cool LOOL

voyons voir ça...

Va pour la convention... Casteyde du cours en ligne met des void et des return; vide partout alors j´ai suivi cet exemple...

Bon je suis supposé poster moins mais bhah, voilà le même code que tantôt en version plus claire:

http://webmouton.pingouin.ca/TestOvPOO.cpp

trouvé ! !

le char * que tu alloue est LOCAL ! ce n´est pas le membre de ta classe, mais une var locale du constructeur

En effet !

this->txt = new char[strlen(source) + 1];
strcpy(txt , source);
txt[strlen(source)] = ´\0´;

printf("Nombre de lettres: %d\nContenu: %s\n" , strlen(txt) , txt);

return;

Fait en sorte que delete[] txt ne plante pas ! !

Excellent, merci beaucoup !

Est-ce c´est propre comme façon de faire avec le this ?