Discussion :

[kimjoa]

géniale le coup du "Initalisation d'un objet en détournant les bloc d'initialisation:"
Ça évite de se trimbaler x variables qui peuvent rende le code illisible... Mais bien sur à utiliser avec parcimonie !!!
Je me vois déjà faire mes vue swing avec cette méthode, ca ressemblerai presque à une syntaxe JSON , javafx, voire jquery

Sinon pour le nommage des boucles ca fait longtemps que je l'utilise, et c'est super pratique.

Quand au exemple php, a pars la fonction autoload, je vois pas trop a quoi il peuvent servir, même si c'est toujours cool de les connaitre

petite contribution minimaliste en java.
Faire presque de l'héritage multiple via les classes interne.

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
class Outher1{
    public Outher1() {
        System.out.println("Outher1");
    }

    public class Inner1{
        public Inner1() {
            System.out.println("Inner1");
        }
    }
}

class Outher2 extends Outher1{

    public Outher2() {
        System.out.println("Outher2");
    }

    public class Inner2 extends Outher1.Inner1{
        public Inner2() {
            System.out.println("Inner2");
        }
    }
}

....

new Outher2().new Inner2();

Même si il faudra toujours que la classe interne soit castable dans sa classe externe ....

PS: pour en langage orienté objet, ne pas permettre l'héritage multiple ou du moins les traits ou mixins, c'est abusé

[boulet_sensei]

Du vu et revu je suppose pour les personnes travaillants avec le framework struts en java (et plus généralement les jsp/servlets).
Pour accéder à la valeure d'un attribut d'un objet( ou autre bean) dans un tag HTML :

Code :

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

<html:hidden property="myonElement" value="${monbean.monattribut}" >

Ca semble bête mais certains de mes collègues ne connaissaient pas alors qu'ils utilisent struts depuis de nombreuses années.

[Atatorus]

En java, chaîner les setters. Avec des setters de le forme :

Code :

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

1
2
3
4
5
public A setString1(String s) {
    string1 = s;
    return this;
}

on peut écrire :

Code :

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

1
2
objet.setString1("truc").setString2("machin").setString3("chose");

Quand on a plein d'attributs à initialiser, ça allège un peu le code.

[pseudocode]

Une petite classe Java que je me suis fabriquée pour retourner un couple de valeurs.

Code java :

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

1
2
3
4
5
6
public class Pair<T,U> {
	public final T first;
	public final U second;
	protected Pair(T first, U second) { this.first=first; this.second=second; }
	static public <T,U> Pair<T,U> pair(T first, U second) { return new Pair<T,U>(first,second); }
}

Ce qui me permet de retourner un couple de valeurs simplement.

Code java :

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

1
2
3
4
5
6
7
8
9
10
import static Pair.pair;
 
public Pair<String,Double> test() {
	return pair( "PI" , 3.14 );
}
 
/* ... */
 
Pair<String,Double> pair = test();
System.out.println(pair.first+"="+pair.second);

[Invité]

http://www.developpez.net/forums/d99...e-va-plus-php/

[polkduran]

l'autre jour je me suis trouvé face à quelque chose qui m'a choqué :

à votre avis, le code ci-dessous affiche quoi ?

Code php :

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

1
2
3
4
5
6
7
8
 
$a = 'php'; //ou n'importe quel string
$b = 0;
 
if($a == $b)
    echo 'true';
else
    echo 'false';

moi j'aurais dit 'false', et non les potes ! il retourne true, il faut donc dire que 'php' = 0, javascript par exemple retourne bien false.

ma déduction est que, comme les deux variables sont de type différent php essaie d'abord de les "convertir" dans un même type afin de les comparer, à l'occurrence je pense que php convertit tout en int car

Code php :

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

1
2
3
4
5
 
$a = 'php';
echo (int)$a; //0
$a = '1php';
echo (int)$a; //1

donc dans le premier morceau de code en réalité la condition est vraie si on compare n'importe quel string à 0 sauf si le string commence par un chiffre autre que 0

par contre si $b ='0', on a bien $b == 'php' => false

c'est un truc tout bête qui m'a laissé perplexe, j'espère ne pas avoir des conditions comme celles-là un peu caché dans mes projets si non ça va être rigolo

tout ça pour dire que le faible typage de php est pratique mais trompeur des fois

[polkduran]

afin de faire plus facile la relecture de code quand on a plusieurs instructions imbriquées (while, if , for, ...) c'est bien utile de mettre un petit commentaire à la fin de chaque bloc

Code php :

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
 
protected function methodeCool($monTab){
    foreach($monTab as $k=>$v){
 
        if($k == 'qqchose'){
            while($v>0){
                echo $v--;
            }//while $v>0
 
        }//if $k=='qqchose'
        else{
            echo $v;
        }//else, $k!='qqchose'
 
    }//foreach
 
}//methodeCool

le code c'est n'importe quoi mais c'est le principe qui compte, c'est bien utile quand on a des gros blocs ou pour voir la fin des méthodes

[FaridM]

l'autre jour je me suis trouvé face à quelque chose qui m'a choqué :

à votre avis, le code ci-dessous affiche quoi ?

Code php :

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

1
2
3
4
5
6
7
8
 
$a = 'php'; //ou n'importe quel string
$b = 0;
 
if($a == $b)
    echo 'true';
else
    echo 'false';

moi j'aurais dit 'false', et non les potes ! il retourne true, il faut donc dire que 'php' = 0, javascript par exemple retourne bien false.

ma déduction est que, comme les deux variables sont de type différent php essaie d'abord de les "convertir" dans un même type afin de les comparer, à l'occurrence je pense que php convertit tout en int car

Code php :

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

1
2
3
4
5
 
$a = 'php';
echo (int)$a; //0
$a = '1php';
echo (int)$a; //1

donc dans le premier morceau de code en réalité la condition est vraie si on compare n'importe quel string à 0 sauf si le string commence par un chiffre autre que 0

par contre si $b ='0', on a bien $b == 'php' => false

c'est un truc tout bête qui m'a laissé perplexe, j'espère ne pas avoir des conditions comme celles-là un peu caché dans mes projets si non ça va être rigolo

tout ça pour dire que le faible typage de php est pratique mais trompeur des fois

Pour que la comparaison ce fasse correctement il faut utiliser "===" au lieu de "==". Ça compare aussi le type, donc plus de conversion de chaîne de caractère en nombre entier.

[polkduran]

Pour que la comparaison ce fasse correctement il faut utiliser "===" au lieu de "==". Ça compare aussi le type, donc plus de conversion de chaîne de caractère en nombre entier.

oui je sais ça, mais des fois il faut faire une comparaison simple (==) sachant qu'une comparaison stricte (===) donnerait un résultat non désirable, mais bon, je fessais référence à l'étrangeté du résultat.

[B.AF]

Moi je fais des devs qui fonctionnent, sont robustes et avec pleins de tests unitaires et d'acceptance.
Généralement, surprise garantie !

[galyathee]

Pour ma part j'offrirais simplement une référence de livre ... certes,
il faut lire l'Allemand et je me doute que l'équivalent existe en langue francaise: Java 6 Core Techniken de Friedrich Esser.

C'est un livre sur la qualité de programmation Java et qui traite très
justement de l'utilisation de certaines "excellentes" pratiques et d'autres
plus dénoncables et donc condamnables (une peine ajustée serait sans
doute la migration d'un bloc de Cobol en Erlang ... quoi qu'on puisse en
retirer de grandes choses m'est avis )

Ok, un exemple de mauvaise pratique sur le thème de la surcharge
de signatures:

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
static void overloaded(int i){
  System.out.println("int i");
}

static void overloaded(Integer i){
  System.out.println("Integer i");
}

static <N extends Number> void overloaded(N n){
  System.out.println(n.getClass());
}

// Le compilateur choisit la version générique uniquement lorsque le type concret ne passe pas
overloaded((byte)1); => int i
overloaded(1);  => int i
overloaded(new Integer(1));  => Integer i
overloaded(1L); => class java.lang.Long
overloaded(1.); => class java.lang.Double

Comme les compilateurs reconnaissent les méthodes à leur signature de paramètres et non à leur type de retour, les deux fonctions suivantes ne peuvent cohabiter dans la même hiérarchie de classe:

public String overloaded(){ return "bonjour"; }
public Integer overloaded(){ return Integer.valueOf(1); }

Cependant, en passant par l'approche générique citée plus haut on peut arriver à forcer le passage:

public class Test{
  public static <S extends String> S overloadedRet() {
    // Le Cast est certain car la classe String est déclarée final
    return (S)"bonjour";
  }

  public static <I extends Integer> I overloadedRet() {
    // Le Cast est certain car la classe Integer est également déclarée final
    return (I)Integer.valueOf(1);
  }

  public static void main (String... args){
    // Maintenant il faut passer explicitement la méthode
    System.out.println(Test.<String>overloadedRet()); // bonjour
    System.out.println(Test.<Integer>overloadedRet()); // 1
  }

  // Nota compile: le compilo lancera des warning à gogo 
  // contre ce genre de choses. Pour ne pas s'en emcombrer, utiliser
  // @SuppressWarnings("unchecked")
}

[hefeust]

Bonjour à tous

Je ne peux pas résister à l'envie de vous communiquer deux petits trucs en PHP.

1. Le premier doit venir du Zend Framework (je n'ai rien inventé là, mais c'est une bonne source d'inspiration...) il s'agit de combiner foreach() sur un tabmeau associatif et la possibilité de switch() de tester des chaînes de caractères. Ainsi en est l'exemple :

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

// préparation des paramètres d'une fonction
$options = array('display' => true, 'required' => true, 'output' => 'XML', ...., 'toto' => 'abcdefgh'); 

// dans le corps de la fonction
foreach($options as $opname => $opvalue)
{
    switch($opname)
    {
        case 'display' :
            // do something with 'display' opvalue
        break;
    
        case 'required' :
            // do something with 'required' opvalue
        break;
        
        case 'output' :
            // do something with 'output' opvalue
        break;    
    }
}

L'avantage est que ça permet de renseigner les options dans n'importe quel ordre et d'agir sur ces options. En terme de complexité ce n'est pas top puisqu'il y a N² tests pour N options dans le tableau. Mais bon les tableaux d'options ce n'est pas fait pour en contenir 100000 non plus... ^^


2. Le second truc, qui me vient de javascript, est le fait d'applanir (de linéariser) les tableaux multidimmensionnels en concaténant leurs clefs dans des chaînes de caractères (encore merci les tableaux associatifs)

Exemple : si on a un tableau de couleurs nommées (genre une palette) avec les composantes R, G et B :

$couleurs[0][0][255] = 'bleu';
$couleurs[255][0][0] = 'rouge';
$couleurs[0][255][0] = 'vert';

On a beaucoup de chances de se retrouver avec un tableau plein de chaînes vides car on n'aura pas forcément de nom à mettre sur toutes les quelques 16M combinaisons possibles. Rappelons au passage que la 'X-Named-Colors' de ColorZilla en compte environ 800...

L'idée est donc de créer un tableau linéaire, en concaténant les composantes avec un séparateur (Exemple '-'), l'exemple précédent :

$couleurs['0-0-255'] = 'bleu';
$couleurs['255-0-0'] = 'rouge';
$couleurs['0-255-0'] = 'vert';

A partir de là il est très facile de lister les noms de couleurs, obtenir leurs composantes R, G et B en explosant la clef suivant le séparateur, et même écrire un système de filtre par chaînes (des pseudo-requêtes) avec un système de jokers pour pouvoir écrire :

$pas_de_rouge = filter($couleurs, '0-*-*');

Ce qui peut être très commode ! On appelle en maths ce type de tableau presque vide des "matrices creuses" et leur représentation en machine se fait souvent par des listes à chaînage multiple (à deux ou trois dimensions)

Allez bonne journée à tous !

[Benjamin Delespierre]

Pour rester sur PHP, vous connaissez probablement déjà la syntaxe nowdoc et heredoc. Cette dernière est très pratique lors que vous voulez créer de longues chaines avec des \n sans vous casser la tête avec les opérateurs de concaténation :

Code :

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

1
2
3
4
5
6
7
8
9
10
<?php
$buffer = <<<HTML
<html>
<head>
<title>{$opt['page_title']}</title>
<head>
<body>{$opt['content']}</body>
</html>
HTML;

Mais malheureusement, il n'est pas possible, à priori de mettre autre chose que des variables dans cette syntaxe. Par exemple on ne peut pas mettre des fonctions ou des constantes ce qui serait pourtant bien pratique.
Depuis PHP 5.3 et grâce aux object closures, c'est désormais possible :

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
<?php
function generateHead() { return "<title>Hello</title>"; }
define ("MA_CONSTANTE", "form1");

$_ = function ($v) { return $v; };
echo <<<HTML
<html>
<head>
{$_(generateHead())}
</head>
<body>
<form name="{$_(MA_CONSTANTE)}">
...
</form>
</body>
HTML;

ça ouvre un tas de perspectives pour la création de vues.

Pour rebondir sur le problème soulevé par @Farid63, j'ai eu le cas en production avec un test: $a == "on" // $a = 0;
figurez vous que ça retourne true!
Méfiez vous de true/false en php, un excelent article fais le tour de la question : 11heavens.com/true-or-false-in-php

Qui n'a jamais eu de problèmes avec les formulaires et leurs retours, voici un moyen simple de sécuriser les inputs tout en conservant une grande flexibilité:

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
<?php
// Table des valeurs par défaut du formulaire
$inputs = array(
"nom" => null, // ce paramètre est mandataire
"prenom" => null, // ce paramètre est mandataire
"age" => 0, // ce paramètre est optionnel
"ville" => "", // ce parametre est optionnel
"code_postal" => 0, // ce paramètre est optionnel
);

// On procède en deux temps:
// d'abord on filtre le tableau $_REQUEST pour ne prendre que
// les données qui nous intéresse (les clés de $inputs)
// ensuite on merge les données par défaut avec ces données
// pour n'écraser que les données effectivement retournées par
// le formulaire
$inputs = array_merge($inputs, array_intersect_key($_REQUEST, $inputs));

// On teste si tous les paramètres mandataires sont présents:
if (array_search(null, $inputs, true))
{
    // Il manque des données: le formulaire n'a pas été correctement rempli
}

// Effectuez vos traitements sur le table inputs sans vous soucier
// de la présence ou non des données avec isset ou empty, 
// à ce stade, vous êtes certain d'avoir tout ce qu'il vous faut
var_dump($inputs);

Ainsi, vous vous dispensez l'usage répétitif de "isset" ou "empty" pour valider vos formulaire. En plus, pour ajouter des données, il vous suffit d'ajouter des entrées par défaut dans $inputs.

[Benjamin Delespierre]

array_map en PHP est pas forcément connu mais pourtant parfois bien utile (ça évite trois/quatre lignes de codes mais tout de même... ).

Permet d'appliquer une fonction à chaque valeur d'un tableau:

Code :

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

array_map("fonction_bidule",$tableau);

http://php.net/manual/fr/function.array-map.php

Je rappelle pour info que depuis PHP 5.3, array map, comme tout autre fonction capable d'utiliser les callback peut également utiliser les closures:

Code :

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

1
2
3
4
5
$a = array(1,2,3,4,5);
var_dump(array_map(function ($v) { return $v * $v; }, $a));
// produit :
// array(5) { [0]=> int(1) [1]=> int(4) [2]=> int(9) [3]=> int(16) [4]=> int(25) }

Attention: array_map ne doit pas être confondu avec array_walk (lisez la doc)
Egalement, j'ai fais un benchmark pour être sûr et il s'avère que l'utilisation d'array_map avec une closure reste significativement plus lente que le foreach classique (j'ai plus mes chiffres en tête...). Prudence donc: si vous voulez généraliser votre code avec ça, c'est tout bon, sinon mettez un foreach.

[Ah_Kin]

les secrets/astuces des langages de programmation ne devraient justement pas être révélés aux communs des mortels sinon l' expérience algorithmique acquise sera au final aux normes non standard et donc inexploitable sur d'autres terrains.

+ 1 avec Astroneo. Un autre conflit algorithme / PHP : la réinitialisation de toutes les variables simples php (non objet) lors d'un parsage d'une nouvelle page après le submit d'un formulaire.

[sekaijin]

les design patterns

je les utilises dans de très nombreuses situations.

pour ce qui est des design de conceptions mais aussi les designs codage.
je n'aime pas les break et autre goto
par exemple lors d'une recherche dans une collection on voit souvent une boucle for sur la collection avec un test de chaque élément et un break lorsqu'on l'a trouvé. ce type de recherche fait l'objet d'un design pattern
"tant que non fin et non trouvé faire"
ce design pattern initialise la recherche en positionnant un booléen nonTrouve à false et la boucle passe tous les élément en les testants lorsque l'élément est trouvé le booléen passe à false et la boucle s'arrête.
ainsi la boucle n'a qu'un point d'entré et qu'un point de sortie
ce design Pattern donne un code comme

Code :

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

1
2
3
4
5
6
$nonTrouve=true;
while ($nonTrouve && $item = $collection.getNextItem()) {
   if (test($item)) {
      $nonTrouve = false;
   }
}

il en existe des centaines et je les utilises très souvent. lorsque design pattern que j'utilise n'est pas très courent le signale son non et ses variables dans un commentaire.

A+JYT

[danbo52]

J'ai pratiqué un vieux langage, mais m'en souviens pas, peut-être est-ce possib' encore de nos jours.

Pour gagner du temps de cycle de scrutation d'un programme, j'ai fabriqué un programme de calculs scientifiques (je crois que c'était en VBA, maintenant que je l'écris) qui s'appuyait sur des appels de codes qui effaçaient carrément un grand nombre de lignes du code origine et en réinsérait en fonction des données. Il y avait aussi une auto régénération de tout le code en fin de calculs (appel d'un fichier qui remplaçait tout)
Mais c'était il y a si longtemps, oh la la !
Cette performance avait été demandé pour comparer des vitesses avec des automates.
Bref, c'est du passé, il n'y a peut-être plus intérêt de nos jours avec les OOP et les includes.
Voilà !

[OPi]

il est possible d'appeler « Echo » avec plusieurs paramètres et faire, en quelque sorte de la concaténation avec une virgule

J'ai ouvert une discussion sur cette syntaxe ici :
echo d'une concaténation vs echo à plusieurs paramètres !

Sinon en JavaScript, (mais ca passe aussi pour les autres langages a typage dynamique) j'aime bien le

Code :

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

1
2
var b=false;
var a=b||'lol';//a vaut 'lol'

Je n'y croyais pas et j'ai testé, effectivement ! Mais c'est moche comme truc. Moi je m'attendais à ce que l'opérateur || caste son premier argument en booléen et renvoie true si ce résultat était true, sinon caste le second argument et renvoie true si ce résultat était true, et finalement false sinon.
C'est donc équivalant à :

Code :

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

1
2
var b=false;
var a=(b ? b : lol');  //a vaut 'lol'

Sauf qu'ici si b vaut true alors il est "évalué" deux fois ?

Le second truc, qui me vient de javascript, est le fait d'applanir (de linéariser) les tableaux multidimmensionnels en concaténant leurs clefs dans des chaînes de caractères (encore merci les tableaux associatifs)
[...]
[Sinon] On a beaucoup de chances de se retrouver avec un tableau plein de chaînes vides
[...]
On appelle en maths ce type de tableau presque vide des "matrices creuses"

Les tableaux en PHP ne sont pas des tableaux, ce sont des tables associatives (moi j'appelle ça des dictionnaires, c'est leur nom en Python). Et donc lorsque l'on n'utilise que des indices numériques comme clés, il ne faut pas croire que les indices intermédiaires non définis sont des cases (vides mais qui prendraient de la place) dans un tableau.

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
<?php
$a = array();

$a[] = 'premier';

$a[10000000] = 'autre';

print_r($a);

echo count($a), "\n", $a[10000000], "\n", $a['10000000'], "\n";
# Affiche :
# 2
# autre
# autre

?>

La table associative $a ne contient pas 10000000 de cases.

la syntaxe nowdoc et heredoc. Cette dernière est très pratique lors que vous voulez créer de longues chaines avec des \n

Les quotes simples ' ou doubles " permettent sans problème de faire des string sur plusieurs lignes. Les doubles " permettent en plus d'y inclure des \n (et des variables qui seront évalués, c'est leur rôle).

Code :

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

1
2
3
4
5
6
7
8
9
10
<?php

$s = 'Première ligne
deuxième
blabla
';

echo $s;

?>

voici un moyen simple de sécuriser les inputs tout en conservant une grande flexibilité

Ah merci, ça a l'air très très bien ça.

Les blocs nommés
Pour le coup c'est optimisé, mais ça rappelle immanquablement le goto.

je n'aime pas les break et autre goto

Faut arrêter d'assimiler les break à des goto ! Ça n'a rien à voir. Et ne me dites pas qu'in fine les breaks sont des sauts, parce qu'in fine presque toutes les structures de contrôles exécuteront des sauts au niveau machine.
Un break c'est un instruction qui interrompt une boucle. Quand on imbrique des boucles, c'est utile de pouvoir les nommer et de "breaker" en cascade (d'ailleurs en PHP on ne nomme pas les boucles, on indique de combien de boucles il faut sortir : par ex. break 3 et pas break etiquette_de_ma_boucle_externe).
Et puis une boucle, qu'est-ce c'est sinon un saut conditionnel ! Hors je ne vois jamais personnes écrire que les boucles c'est des goto...

[OPi]

J'ai oublié ça :

Un autre conflit algorithme / PHP : la réinitialisation de toutes les variables simples php (non objet) lors d'un parsage d'une nouvelle page après le submit d'un formulaire.

Cela découle d'une mauvaise compréhension. Chaque fois qu'une page est chargée (notamment après un submit) c'est une nouvelle exécution d'un programme qui a lieu.
Hors dans n'importe quel autre contexte on ne s'étonne pas que d'une exécution à l'autre d'un programme les données ne soient pas conservées si on n'a pas pris soin de les sauver dans un truc persistant.

[sekaijin]

...
Faut arrêter d'assimiler les break à des goto ! Ça n'a rien à voir...

je n'ai pas dit que break est un goto. J'ai dis que je n'aime ni l'un ni l'autre

et oui on peut faire plein de chose avec des break
mais cela n'empêche pas qu'on peut faire la même chose sans.

un bon principe à mon avis est que pour tout block (section de code, fonction boucle etc.) un seul point d'entrée et un seul point de sortie

et mon propos est que des docteurs es science informatique on étudié toute un tas de cas types et on pondus de bonnes pratique pour les réaliser quelque soit le langage.
ce que je fais donc c'est que lorsque j'en utilise un je le dis. ça permets au autres acteur du projet de comprendre ce que je fais.

un autre truc que je fais (si le langage le permet) c'est de toujours mettre un return à mes fonctions. même celle qui ne retourne rien

Code :

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

1
2
3
4
void foo() {
   ...
   return ;
}

A+JYT