striiiiiiiiiiiiiiing - Page 4

./90>

surtout des différences entre les implémenteurs.

quand on fait un gros produit qui se veut cross platform, on commence en général par faire un framework qui abstrait la plateforme

Peut etre simplement que la lib "standard" ne leur convient pas et/ou leur imposerait trop de contraintes ?

En effet il y a des différences très sensibles, notamment sur l'API de collection (avec laquelle je galère), mais c'est a mon avis bien dommage.

Bon alors je t'encourage à essayer de trouver un environnement qui te convient. Qt est très bien mais il faut faire abstraction d'énormément de choses, jusqu'au langage même (Qt bidouille énormément avec plein de classes ou #defines dont le comportement n'a souvent rien à avoir avec ce qu'on est habitué en C++. Mais ce n'est pas forcément un mal puisque le C++ n'est pas objectivement un bon langage). Je t'avertis juste hein, pas que tu dises "l'objet c'est de la merde" après basé sur une expérience. Mais sinon je pense que c'est pas un mauvais choix si tu es sous Linux.
Il y a aussi wxWidgets, qui est plus barbare mais plus proche du C++ (c'est d'ailleurs pour ça qu'il est barbare ), peut être que tu préféreras si tu trouves que Qt est trop une "usine à gaz".

Sinon même si ça ne fait pas tout, c'est vrai que certains concepts académiques sont vraiment utiles. Perso je code vraiment plus pareil, avant rien que la récursivité j'avais de la peine. L'objet même si tu peux apprendre assez facilement par toi même il faut de la pratique. Certains aspects liés à la concurrence par exemple (en vogue avec les multi-coeurs) sont déjà plus difficiles à maitriser, mais t'en auras pas forcément besoin. Les mathématiques aident aussi pour certains problèmes (prouver plus ou moins informellement que ta solution est bonne t'évite de passer du temps à chercher des bugs ou à douter de toi même). On devient aussi plus habitué à trouver immédiatement les cas limites qui pourraient faire foirer un code, parfaitement invisibles à d'autres personnes.

Ensuite concernant le boulot les projets personnels ne sont pas forcément inutiles pour l'employeur. En fait ça n'a l'air de rien comme ça mais ça montre que tu sais te débrouiller, ce dont beaucoup d'étudiants sont difficilement capables car ils ont toujours été encadrés (et j'en ai connu plus qu'un des étudiants vraiment mauvais, pourtant sortant d'écoles prestigieuses). Perso j'ai foutu mon site dans mon CV. Ca ne se fait pas trop en principe, mais c'est original et ça peut faire jouer la balance s'ils hésitent (et en l'occurrence ça a été le cas).

En fait y a assez de cons qui obtiennent des postes et c'est vraiment super dur de les virer. Donc d'ici que ça arrive (dans le cas hypothétique où tu nagerais *vraiment* dans la semoule) tu as le temps de voir venir et surtout de travailler pour t'améliorer. Et ce n'est pas un problème si tu es motivé, non?

Après tu as peut être meilleur temps de t'orienter vers une PME pour commencer, c'est plus dynamique, et tu ne souffriras pas de l'effet "nouvelle star" au recrutement. Autre solution: la candidature spontanée. S'ils daignent entrer en matière, tu es sûr que ton profil sera analysé et que tu auras donc une chance de les convaincre

Zerosquare (./79) :
Sinon, renseignes-toi bien sur TOUS les aspects du métier si tu envisages une réorientation professionnelle... la partie technique n'est qu'un bout d'un ensemble, même si elle te plaît ça ne suffira pas forcément à ce que le métier te convienne.

Je plussoie quand même 0² là dessus. L'embarqué c'est pas forcément une partie de plaisir tous les jours. Actuellement je suis sur un PIC et je prie pour que ça continue, mais j'ai vu de ces trucs à se tirer des balles (datasheet autant utiles que... rien, compilos bugués, etc.). T'as intérêt à avoir un boss compréhensif qui t'accuse pas de glander quand tu t'en sors pas
Mais bon c'est fun quand même (et varié, surtout) et je continue avec plaisir.
Java en comparaison c'est le paradis sur terre. Google tout entier est ton datasheet. Tu cherches une spec, tu tombes sur le site de Sun directement à la bonne page. Et sinon sur un forum où quelqu'un a déjà eu le problème

Brunni (./94) :
Après tu as peut être meilleur temps de t'orienter vers une PME pour commencer, c'est plus dynamique, et tu ne souffriras pas de l'effet "nouvelle star" au recrutement.

Hm, étonnamment j’aurais tendance à penser que c’est plus facile de se faire embaucher dans une grosse boîte que dans une PME.

Bon, je viens de faire un tour de netbeans (6.8) "pour voir", et du coup ça fait bizare : NetBeans en Java est magnifique au niveau interface. C::B sous Linux et son wxWidgets fait super moche

Mais bon tant pis, on s'en passera, ça fera du bien si dans un an je me mets au Java.

Tu peux faire du C++ avec Netbeans (ou Eclipse), hein .
L'intégration est rarement aussi bonne qu'avec Java, mais ça permet déjà de prendre connaissance d'un IDE puissant (ce qui est pratique si tu as à en utiliser un plus tard, au moins tu en connaitras les subtilités).

Ya un truc que je comprends pas avec new

Sur le site du zero, je vois ça :

On souhaite donc allouer dynamiquement une variable (de type int par exemple).
En C++, on va d'abord devoir créer le pointeur et l'initialiser à NULL, ça on n'y coupe pas :

Et ça donne ça :

int *variable = NULL;
variable = new int; // Allocation dynamique

Ah bon ?
Sur un autre tuto, j'ai ça :

int * p;
p= new (nothrow) int[i];

Ce qui revient à affecter le résultat de new à un int* tout bête, sans qu'il ait fallu l'initialiser à NULL. Visiblement, on peut y couper alors ? Est-ce dû au (nothrow) ?

(cross) Nil, oui, j'ai vu, j'ai juste pas trouvé le bon (Q)make pour compiler. Par contre, j'ai retrouvé les compilateurs de MinGW, pas de souci. Ca a l'air vraiment bien ce NetBeans

Les 2 n'ont rien à voir.
int *var = new int;
Crée un entier dynamiquement et te retourne un pointeur vers l'entier alloué. C'est équivalent à faire en C:
int *var = malloc(sizeof(int));
Il faut ensuite le libérer ainsi:
delete var;
L'autre alloue un tableau:
int *tab = new int[taille];
Te crée dynamiquement un tableau de taille éléments. C'est équivalent à:
int *tab = malloc(taille * sizeof(int));
En C. Pour la destruction, c'est:
delete[] tab;
Ensuite l'initialisation NULL c'est à toi de voir. C'est une très bonne habitude. Ca évite d'avoir des soucis bizarres car si tu par malheur tu venais à utiliser la variable non initialisée tu accèderais à l'adresse 0, ce qui est sûr de planter ton prog. Sinon comme la variable vaudra n'importe quoi il se peut que l'accès n'échoue pas mais plante le prog par la suite, du coup impossible de déboguer l'erreur.
En fait NULL veut dire qu'un objet n'a pas encore été alloué, si tu comptes créer un objet (variable, ton int dans ce cas) plus tard tu peux le mettre à NULL et faire un test plus tard pour savoir si tu l'as déjà créé et éviter de le faire deux fois.

Brunni (./99) :
Les 2 n'ont rien à voir.

Ca, j'avais bien compris, mais c'était par rapport au '= NULL' qui avait l'air obligatoire pour une raison qui m'échappait.

Brunni (./99) :
Ensuite l'initialisation NULL c'est à toi de voir. C'est une très bonne habitude.

Là ok, très bien. C'est sûr, c'est pas idiot.

PS: Si tu as un environnement de développement (débogueur + compilateur) pas trop pipeauté, genre Visual C++, ça t'initialise par défaut toutes les variables à une valeur à la con (genre 0xcc[…]cc) pour faire strictement planter ton programme, et ça détecte assez bien les accès aux variables non initialisées. (-> en mode Débug évidemment ^^)
D'ailleurs initialiser à zéro peut malgré tout causer des bugs, vu que c'est une valeur neutre, donc neutre dans les calculs, et d'autre part c'est une perte de performance [de degré variable selon le programme] car cela ne peut pas toujours être optimisé(=supprimé) par le compilateur même quand c'est réellement inutile.

Oué ben je viens justement de passer 1h à déboguer un calcul de crypto qui donnait parfois un résultat faux en mode Release mais ok en mode Debug... bien sûr, sinon ça aurait été trop facile de trouver pourquoi ça merde
(oué enfin il est 2h49, je ne *viens pas* de le faire, mais on se comprend )

GoldenCrystal (./101) :
D'ailleurs initialiser à zéro peut malgré tout causer des bugs, vu que c'est une valeur neutre, donc neutre dans les calculs, et d'autre part c'est une perte de performance [de degré variable selon le programme] car cela ne peut pas toujours être optimisé(=supprimé) par le compilateur même quand c'est réellement inutile.

Bah si ton programme fonctionne avec les valeurs par défaut que tu as définies, ce n'est pas vraiment une erreur de logique (i.e. tu as codé juste, même si tu l'as pas fait exprès ). Là où c'est problématique c'est quand ça fonctionne parce que le contenu aléatoire de la RAM fait que ça joue chez toi au moment de l'écriture, mais pas plus tard.

Ca existe pas mes adress error pour cause d'adressage impair façon 68k ? Sinon, suffit d'initialiser les pointeurs à 1, pas à 0.


ps : étant donné qu'on tourne sur un OS utilisant une mmu, l'adresse 0 définie dans le programme par NULL est-elle l'adresse 0 réelle de la machine ? Ou est-ce une adresse remappée quelque part en mémoire, sans qu'on puisse trop savoir où ?
Ok en soi, je m'en fous complètement, mais c'est juste pour savoir, pour le fun. Je connais évidemment très mal les PCs.

Sur PC les programmes adressent une mémoire virtuelle. Quand tu écris quelque chose à l’adresse 0, ça n’écrit pas à l’adresse 0 de la RAM. Il y a un mécanisme de décodage d’adresse virtuelle en adresse physique (réalisé par une MMU) qui te fera écrire quelque part, en RAM.
Le but est de s’abstraire des caractéristiques physiques de la machine sur laquelle s’exécute ton code.

Bon, voici l'exemple d'un tuto que je ne comprends pas très bien.
On a la définition d'une classe :

// pointer to classes example
#include <iostream>
using namespace std;
class CRectangle
{
  int width, height;

  public:

  void set_values (int, int);
  {
    width = a;
    height = b;
  }

  int area (void)
  {
    return (width * height);
  }
}

Il y a donc pas de constructeur, deux méthodes et deux attributs.

Voici maintenant la fonction main (la déclaration de la classe étant faite dans le même fichier) :

int main ()
{
  CRectangle a, *b, *c;
  CRectangle * d = new CRectangle[2];
  b = new CRectangle;
  c = &a;
  a.set_values (1,2);
  b->set_values (3,4);
  d->set_values (5,6);
  d[1].set_values (7,8);

  cout << "a area: " << a.area() << endl;
  cout << "*b area: " << b->area() << endl;
  cout << "*c area: " << c->area() << endl;
  cout << "d[0] area: " << d[0].area() << endl;
  cout << "d[1] area: " << d[1].area() << endl;

  delete[] d;
  delete b;
  return 0;
}

Ce que je ne comprends pas très bien, c'est le "CRectangle * d = new CRectangle[ 2 ];"
Ca veut dire qu'on crée un pointeur sur un tableau de deux obets CRectangle, c'est ça ?

Donc après, les d[ 0 ] et d[ 1 ] sont deux objets CRectangle qui n'ont pas de nom particulier, mais qu'on connait juste par le pointeur du tableau et leur index ? d[ 0 ] et d[ 1 ] sont donc des objets ?

Merci.

Folco (./105) :
Ce que je ne comprends pas très bien, c'est le "CRectangle * d = new CRectangle[ 2 ];"Ca veut dire qu'on crée un pointeur sur un tableau de deux obets CRectangle, c'est ça ?

Tout à fait.
(J’avais oublié à quel point le C++ est laid. En java les choses sont quand même plus jolies.)

Donc après, les d[ 0 ] et d[ 1 ] sont deux objets CRectangle qui n'ont pas de nom particulier, mais qu'on connait juste par le pointeur du tableau et leur index ? d[ 0 ] et d[ 1 ] sont donc des objets ?

Oui

Yes ! Merci

Oui je trouve ça moche aussi cette façon de faire, syntaxiquement je trouve ça très chargé et pas clair.

Folco (./103) :
Ca existe pas mes adress error pour cause d'adressage impair façon 68k ?

Si. Y'a un flag du processeur à activer pour ça, mais il ne l'est pas par défaut. J'ai jamais essayé pour voir si ça marchait sous Windows/Linux ou si ça faisait des étincelles ^^
(quoi qu'il est possible que seul l'OS puisse changer ce flag, je ne me souviens plus)

Comment ça, faut dire au proc "bon, je veux absolument que tu crashes" ?

Ben en quelque sorte

Les accès non-alignés ont toujours été autorisés sur x86 (mais plus lents que les accès alignés). Le flag pour générer une exception en cas de non-alignement a été rajouté par la suite, probablement pour ceux qui veulent optimiser à fond.

les accès non alignés sont possibles mais je suppose que ça pète les performances.

sinon NULL est un null local au processus qui exécute le programme, mmu oblige, mais en général les adresses inférieures à une certaine valeur sont interdites d'accès car par exemple dans le kernel linux on a réussi à faire des exploits avec des "null pointer defererence".

Sasume (./106) :

Folco (./105) :
Ce que je ne comprends pas très bien, c'est le "CRectangle * d = new CRectangle[ 2 ];" Ca veut dire qu'on crée un pointeur sur un tableau de deux obets CRectangle, c'est ça ?

Tout à fait. (J’avais oublié à quel point le C++ est laid. En java les choses sont quand même plus jolies.)

ha dans ce cas il appelle le constructeur sur chaque objet à la création du tableau??

squalyl (./111) :
les accès non alignés sont possibles mais je suppose que ça pète les performances.

Ça ralentit oui, mais j'avais testé à une époque, y'a des cas où ça reste intéressant et plus rapide que de changer le code pour n'avoir que des accès alignés.

Ben j'espère bien que c'est à chaque création d'objet, sinon je vais être perdu moi. Ca doit se faire au moment du "new CRectangle[]" j'imagine ?

Et au fait, comment devrais-je m'y prendre si je voulais que les deux objets du tableau soient initialisés par un constructeur surchargé ?

aucune idée, avec des paramètres après les []?

je pose la question parce qu'en java

SuperMachin x = new SuperMachin[5];

alloue un objet de type tableau pour stocker 5 références vers des objets de type SuperMachin, mais n'alloue pas les objets, ce qui doit être fait avec

for(int i=0;i<5;i++) { x[i]=new SuperMachin(param,param,param); }

ca nous paraissait plus clair.

(oui, en java, tous les objets sont des pointeurs, enfin des références, donc on peut pas allouer d'objet sur la pile comme en c++, ie sans utiliser new)

Il faut savoir que:
int *i=new int;
est équivalent à:
int *i=new int();

Bref:

int *i=new int[ 5 ];
est équivalent à
int *i=new int[ 5 ]();

Je trouve que la 2e notation est meilleure, ça montre l'appel au constructeur.

squalyl -> Ce que tu dis semble logique, ie on crée un tableau que le compilo dimensionne komilveu pour les deux objets, puis après on les crée.

Suivant l'exemple du tuto (j'ai pas testé l'exemple), c'est pas la peine :

  CRectangle * d = new CRectangle[2]; 
  b = new CRectangle; 
  c = &a; 
  a.set_values (1,2); 
  b->set_values (3,4); 
  d->set_values (5,6); 
  d[1].set_values (7,8);

Il n'y a pas d'initialisation de d[x] avant usage... (et je trouve le 'd->' particulièrement crade mais bon ). Ce qui voudrait dire que les objets sont créés en même temps que le tableau. On fait comment alors, pour faire un tableau sans instancier d'objets ?

Quelqu'un confirme que ça se passe bien comme ça ?


Jyaif -> codes couleur ^^

Folco (./116) :
(et je trouve le 'd->' particulièrement crade mais bon )

c'est crade. Ça n'a rien à faire dans un tuto, visiblement le gars avait envie de s'amuser et de montrer qu'il comprends les pointeurs.

Ce qui voudrait dire que les objets sont créés en même temps que le tableau.

oui.

On fait comment alors, pour faire un tableau sans instancier d'objets ?

tu crée un tableau de pointeurs.

Un tableau de pointeurs vers QUOI ? Si je le crée avec des pointeurs Maclasse*, les objets sont instanciés pour chaque élément du tableau apparemment !

./116 Je confirme. Pour être sûr tu peux supprimer le constructeur sans paramètre (tu le déclares en private), la compilation devrait être impossible.

Le post ./114 illustre comme c’est plus agréable en Java (même s’il faut faire deux allocation — une pour le tableau et une pour ses éléments).

./118 Non non, si tu fais un tableau de pointeurs vers quoi que ce soit, quand tu instancieras le tableau ses éléments ne seront pas instanciés :

Maclasse *montableau[10]; // montableau contient 10 pointeurs (vers des objets Maclasse) non initialisés
Maclasse **montableau = new Maclasse *[50]; // montableau contient 50 pointeurs non initialisés (qu’est-ce que c’est laid)

Folco: vala le truc, si tu fais comme ./119 ça marche comme java.

alloué dynamiquement, pas moyen de faire desvoid truc () { MaClasse plop(42,53); plop.methode(); }en fait le truc agréable du java c'est que TOUT est objet

ode(); }

le java:void truc () {
  MaClasse plop = new MaClasse(42,53);
  plop.meth

op = new MaClasse(42,53); plop->methode(); }

est équivalent à utiliser des pointeurs en c++void truc () {
  MaClasse* pl

(faut savoir qu'apparemment, en C++ "struct" et "class" sont synonymes)