Anthony Jaguenaud a écrit 1967 commentaires

WINEPREFIX=~/jailHADOPI winecfg
Ne laisser que le c:\ aucun acces au reste du disque.
WINEPREFIX=~/jailHADOPI wine ~/jailHADOPI/drive_c/HADOPI/setup.exe

Je me demande si ça peut suffire ?
Bien pensé à le lancer le logiciel espion à chaque fois qu'on télécharge.

Il y a aussi
msys: www.mingw.org/wiki/msys qui permet de recompiler la plupart des applications, l'avantage par rapport à cygwin, c'est qu'il n'y a pas de dépendance vers la dll cygwin. Par contre, je ne suis pas certain qu'on puisse tout recompiler. En tout KDE4.2 l'est avec.
colinux: http://www.colinux.org/ ici, c'est une virtualisation du noyau. Je sais pas comment ça marche, ni si c'est vraiment utilisable.

Renouveler l'expérience Blender, ce serait plutôt bien.

En plus, il suffirait de le sortir que pour GNU/Linux, NA ! comme ça, on montrerait que notre OS il est bien ;-)

Ouah, là il faut connaitre. en gros il faut taper rmdelete \\?\toto.. ?

Pas très user frendly, mais peut-être marqué dans l'aide ?

Par contre, dans l'explorateur, ne pas pourvoir le virer me semble plus gênant. Maintenant, comme il n'était pas indiquer de quelle manière il essayé d'effacer le fichier...

Juste merci.
Pfff, on est obligé de mettre un commentaire. Donc encore merci.

Mais si je ne m'abuse sizeof(d_name) vaut 4 sur une machine 32 bits et est calculé à la compilation. Ce n'est pas la longueur de la chaine, mais la "taille" du pointeur.
Non, il ne faut pas confondre : int *toto; et int toto[255].
Même si toto renvoie bien un pointeur sur les données. Qui devront être préalablement allouée dans le premier cas, et le second ne peut-être une lvalue.

Comment stockes-tu 255 caractères dans un octet, exactement ? (même question avec 256)
Relie le post auquel tu réponds, l'auteur à écrit (la mise en gras est de moi) :
Je sais pas comment c'est foutu en interne, mais il y a peut-être un octet qui est utilisé pour stocker la taille du nom...

Wouah, KDE 4.4.2 ! En avance sur son temps cette ubuntu, 1an d'avance sur les version de KDE. C'est la 4.2.2 je pense.

2. J'essuie l'intérieur de la casserole que je viens de laver, pour la remplir d'eau pour cuire des pâtes.
A, moi j'aurais plutôt essuyé l'extérieur, puisque pour faire des pâtes il faut mettre l'eau dedans. Et que si tu n'essuie pas l'extérieure, tu risques d'avoir du bruit (l'eau qui crépite)

Je m'excuse de te demander pardon, mais quand j'ai vu le titre je me suis dit : "Chouette, un mec qui partage son expérience, je suis curieux de voir comment il a fait." J'ouvre le lien, et là, déception.

Pour ce qui est des journaux, forum, ce pourrait être intéressant de remonter certains message du forum en page d'accueil. Mais personnellement, je n'ai pas envi de trier, ni le temps. Donc si le contenu devient pénible à lire, je ne viendrais plus. Se ne sera pour le bénéfice de personne.

LGPL:
- Le programme peut avoir la licence qu'il veut.
- Une modification de la bibliothèque implique une distribution du code en même temps que le binaire ainsi que de garder l'historique : auteur, licence ?Oui et non (implique seulement de pouvoir fournir le code source et les modifs)
Heu, j'ai pas bien compris, où tu as mal compris ma question en tous cas, je demande un éclaircissement pour la modification de la bibliothèque.

Si je comprends bien, l'auteur qui a modifié la bibliothèque, doit redistribuer aux personnes à qui il distribue la nouvelle version de la bibliothèque mes sources, et ces patch.
Je reste dans le cas du lien dynamique.

Pour la voiture, au bout d'une heure, tu sais accélérer, freiner. Pour s'insérer dans la circulation, ne pas se croire un dieu de la conduite, ne pas s'énerver parce que les autres ne savent pas conduire, etc. C'est pas gagné, mais là, les vingt heures ne suffisent pas.
Ce matin, sur une portion à trois voies qui passe à deux, un mec, en voiture, doubler à droite, puis ce préparer à redoubler à droite deux voitures qui était sur la file du milieu et de gauche. Logiquement, la voiture sur la voie du milieu se rabat (pour laisser la place à la voiture de gauche de se rabattre) puisqu'il n'y a plus que deux voie. Là, le mec, il tente de profiter du fait que la route est encore large pour passer entre les deux voitures. Finalement il se dégonfle, ouf. J'avais déjà les doigts près pour un freinage d'urgence.
Je suis certain que ce mec est persuadé qu'il conduit bien, mais que ces abrutis ont fait n'importe quoi est l'ont empêcher de rouler. Toujours est-il que j'ai doublé ce gars, quelque kilomètre plus loin à la régulière, au moment où il allait sortir de la rocade. Il n'a jamais eu plus de trois ou quatre voitures d'avance. Et je ne suis pas passé entre les files.

La voiture, c'est comme l'informatique, pour savoir faire, il faut prendre de la bouteille, et pas la bouteille, et pas s'énerver, c'est comme ça qu'on progresse le mieux.

Maintenant, faites-vous parti des 75% des français qui dise conduires mieux que la moyenne ?

La GPL...
J'aimerai poser des questions simples.
Je fais une bibliothèque quelle licence choisir ?
GPL :
Si quelqu'un lie un programme à ma bibliothèque, son programme doit-il être GPL ?
Si quelqu'un modifie ma bibliothèque, la nouvelle bibliothèque doit être en GPL.

BSD:
- Dans les deux cas il fait ce qu'il veux de son programme.

LGPL:
- Le programme peut avoir la licence qu'il veut.
- Une modification de la bibliothèque implique une distribution du code en même temps que le binaire ainsi que de garder l'historique : auteur, licence ?

Autre ?

...on m'a ri au nez quand j'ai réclamé un client X sur la machine ...
Juste pour ressituer ? Tu parlais de quel client X ? firefox, thunderbird, gvim, xpilot ?
Juste pour rappel, dans un environnement client-serveur : le serveur fourni le service et le client l'utilise. Pour X, c'est la même chose, le service est un service d'affichage, de gestion des entrées(clavier/souris). Le fournisseur (serveur est bien X11) le client l'application.
En fait, tu voulais certainement parler de serveur d'application faisant tourner des clients pour ton serveur X en local ;-)

===>[] Quoique, cette confusion générale m'indispose régulièrement.

J'irais jusqu'à dire qu'on se fait mal aux doigts jusqu'à ce qu'on ait appris à se servir du dit marteau.

Après j'ai du mal à voir l'intérêt d'implémenter une liste chaînée dans un tableau ...
Le seul intérêt, c'est de trouver un élément libre en O(1) et d'y accéder en O(1).

Tu ordonnes tes éléments ?
Non.

C'est pour parcourir l'ensemble de tes éléments en une seule passe comme avec une liste chaînée sans tester si une case est vide ?
Non plus. Je chaine juste les élément de façon a facilité l'usage de champ généraux : first_free_index, first_use_index et last_use_index.
J'obtiens un truc du genre :
struct
{
int first_free_index;
int first_use_index;
int last_use_index;
struct {
...
int prev_index;
int next_index;
}
};

Pour ajouter un élément, je prends le first free, et je le chaine avec le first use, je déchaine avec le next du first free.
Pour enlevé un élément, je rechaine ensemble le prev et le next, je le note en first free, je le rechaine avec l'ancien first free.

C'est pour éviter les allocations / désallocations mémoires ?
Oui. Contrainte produit :-(

Au boulot, c'est C. Et j'ai besoin de tableau pour accéder vite aux données, mais je veux aussi pouvoir insérer, effacer rapidement un élément à partir de son index.
J'ai donc fait une sorte de liste chaînée par index et pas par pointeur. Le problème c'est que l'appliquer à des nouveau type et un cauchemar en macro, faire du copier coller c'est bien, sauf pour une évolution, correction de bug, quand il y a dix type utilisé. Là où un jeu de fonction, structure "patron" serait très utile. Même pas besoin d'aller à la classe, le C++ c'est bien plus que la réduction habituelle à la classe.

Juste, c'est quoi tomboy ? Un jeu avec Tom écrit en C# ?*

Si je prend un avocat et que le juge ne statue pas en ma faveur -> c'est pour ma pomme (et c'est cher). Et visiblement y'a un certain nombre d'avocat qui défendent mal lorsqu'on regarde sur le net /o\.
C'est pour ça que au USA, les avocat prennent un pourcentage de ce qu'il te font gagner... d'où les sommes excessives demandées.

Histoire d'engraisser le troll jusqu'à ce qu'il prenne ? ;-)

Effectivement, le paragraphe 6.3.1.8 semble explicite. (j'utilise un des derniers draft de la norme C99) :
Many operators that expect operands of arithmetic type cause conversions and yield result types in a similar way. The purpose is to determine a common real type for the operands and result. For the specified operands, each operand is converted, without change of type domain, to a type whose corresponding real type is the common real type. Unless explicitly stated otherwise, the common real type is also the corresponding real type of the result, whose type domain is the type domain of the operands if they are the same, and complex otherwise.

Je vois pourtant régulièrement des erreurs du type que j'ai décrite. Donc, je ne comprends pas. Soit le comportement dans la norme c89 est différent, soit les compilateurs sont mal écris.

Comme en plus il n'y a pas de garantie sur l'ordre des opérations (sauf si on met des parenthèses), ...
L'ordre des opération est parfaitement défini dans le cas d'une expression, il est indéfini uniquement dans le cas des paramètres d'une fonction.
ex:
if ((monPointeur != NULL) && (*monPointeur != 42)) est parfaitement valide, car la norme garanti que si la première partie est fausse, la seconde n'est pas évalué.

Ok, sur quoi tu te bases pour l'affirmer ?

Ne me dis pas essaye, car tu prouves le comportement de tel compilateur.

Il y a des tas de cas ou la norme est floue :

a = 2 * b++ - --b + c --;

maFct(fonctAApellerEnPremier(b),fonctAApellerEnDeuxieme(a));

etc.

Dans le premier cas, je connais plusieurs comportement, pour la deuxième sur une station SUN, la "fonctAApellerEnDeuxieme" sera en fait appeller la première.

Dans le cas de la formule, si on met b = 2 et c = 10 alors gcc applique :
2 * 2 - 1 + 9 = 13.
Mais qui dis que le -- pre doit s'appliquer que à ce membre ? Et pas a toute l'expression ?
2 * 1 - 1 + 9 = 11 ?

Je vais encore m'auto-répondre.

Pour tester j'ai écris ce programme.

#include <stdio.h>

int main(void)
{
int _a;
double _r, _val, d_a;

_a = 3;
d_a = 3.0;
_val = 1.5;

_r = _a / _val;
printf("_r = %2.5f (int) / (double)\n",_r);

_r = d_a / _val;
printf("_r = %2.5f (double) / (double)\n",_r);

return 0;
}

D'après mon explication ci-dessus, dans le premier cas _r devrait valoir 3.0, car _a / _val est (int) / (double) donc je m'attendais à (int) / (int) or le cast de 1.5 en int donne 1, donc 3 / 1 = 3 puis cast vers double 3.0.
Avec le gcc ici 3.3.1 il me donne 2.0 aussi.

J'ai cherché dans la norme C, et rien trouvé d'intéressant. Il semble y avoir un flou dans le cas des opérateurs utilisés avec deux types différents. Cela dépend-il du compilateur ? Est-ce un cas indéterminé ? gcc semble utiliser le type le plus précis. Quelqu'un a t'il la possibilité de tester avec un gcc 2.95 ?

Si quelqu'un a une réponse, je suis preneur.

Dans ton terminal, tu lances :
$ wio leNomDeFichierQueTuVeux.avecUneExtensionSiTuVeux

Sinon, faire des accès aléatoires de se type met à genoux n'importe quel disque. Le même test avec les fonction fread, etc. du C qui bufferise les accès donne de meilleurs résultat.

Généralement, dans une application classique, on utilise pas le disque de cette manière, donc, c'est un bench, il n'est représentatif d'aucune application, ou d'usage normal connue d'un disque.

Encore une autre :-D,
Tu ne réinitialises que la moyenne entre deux essais, ce qui signifie que ton min et ton max sont sur l'ensemble du test, et pas que sur le test en cours. Est-ce voulu ?