Anthony Jaguenaud a écrit 1956 commentaires

Tu parles des prises vampires ? Que de souvenir…

qqu'un ici a trouvé un job grâce à LinkedIn ?

Oui. À chaque fois sans vraiment chercher… un coup de mou, une offre qui passe qui à l’air sympas. Un coup de CV, pas de lettre de motivation, c’est eux qui cherche.

Je dirais entretient sur 50% des cas, soit 4 à tous cassé, et deux jobs : 2018 et 2021.

Parfois, il fallait passer par un utilitaire DOS pour modifier le port d’entré/sortie car ça ne se configurait pas sur cette saleté de Win95… alors que déjà à l’époque, on pouvait paramétrer le modprobe ne2k io=0x.... sous un certain OS ;-).

Tu peux ajouter le score de Zemmour à l'extrême droite. ce qui la fait monter autour de 30%, sauf si tu considères que Zemmour est autre chose que de l’extrême droite.

Oui, mais… sans Zemmour, Marine ne serait pas allée chercher les électeurs de Pécresse qui aurait de fait fait un meilleur score…
On peut refaire le match, mais c’est fini pour cinq ans.

Pour avoir un truc portable qui change rien entre Windows/Linux/BSD/etc. je pense qu’emacs est un bon candidat. En prime, vous pourrez gérer vos fichiers de la même manière sur tous les OS.
Il a également des tas de plugin.

La signification des codes de 1 à 254 est déterminée par le programme.

En fait, pas tout à fait. Il vaut mieux rester de 0 à 127. Sous Linux, généralement, si un processus est tué par un signal, tu retrouves le code de retour : 128 + numéro du signal.

capello:~$ cat >toto.c
int main()
{
while(1);
return 0;
}
capello:~$ gcc toto.c
capello:~$ ./a.out
^C
capello:~$ echo $?
130
capello:~$ kill -l
 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL       5) SIGTRAP
 6) SIGABRT      7) SIGBUS       8) SIGFPE       9) SIGKILL     10) SIGUSR1
11) SIGSEGV     12) SIGUSR2     13) SIGPIPE     14) SIGALRM     15) SIGTERM
16) SIGSTKFLT   17) SIGCHLD     18) SIGCONT     19) SIGSTOP     20) SIGTSTP
21) SIGTTIN     22) SIGTTOU     23) SIGURG      24) SIGXCPU     25) SIGXFSZ
26) SIGVTALRM   27) SIGPROF     28) SIGWINCH    29) SIGIO       30) SIGPWR
31) SIGSYS      34) SIGRTMIN    35) SIGRTMIN+1  36) SIGRTMIN+2  37) SIGRTMIN+3
38) SIGRTMIN+4  39) SIGRTMIN+5  40) SIGRTMIN+6  41) SIGRTMIN+7  42) SIGRTMIN+8
43) SIGRTMIN+9  44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13
48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12
53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9  56) SIGRTMAX-8  57) SIGRTMAX-7
58) SIGRTMAX-6  59) SIGRTMAX-5  60) SIGRTMAX-4  61) SIGRTMAX-3  62) SIGRTMAX-2
63) SIGRTMAX-1  64) SIGRTMAX
capello:~$

Ici, 130 == 128 + 2 => SIGINT qui correspond bien au <Ctrl>+c.

Édit: Arg, grillé !

Si tu ne mets pas les dépôts non-free sur debian, tu as aussi un système 100% libre, non ?

Je pense que le bug est dans ton cerveau ! Mais que faisais-tu sur le site de « closer » ?

Moi aussi, j’ai un CPU RGB… mais c’est juste parce que c’était le meilleur rapport qualité/prix… je l’ai découvert en l’allumant avant de fermer ma tour. C’est les araignées qui doivent être contentes.

Les exceptions constituent les erreurs non prévisibles, comme un problème réseau, disque plein, et d'autres aspects, comme la sécurité. Je comprends mal l'intérêt de ne pas utiliser les exceptions..

Je ne suis pas d’accord. Si les interfaces que tu utilises sont correctement définies, tu dois pouvoir connaître la liste des exceptions. Donc, des erreurs. Récupérer une exception networkUnreachable ou une erreur NetworkUnreachable, je ne vois pas trop la différence.

Le principal intérêt des exceptions, àmha, dans les langages impératifs, c’est de pouvoir balancer l’erreur et la récupérer à l’endroit le plus propice, sans faire de cascade d’erreur, de cas particulier juste dans l’optique de la rebalancer à l’appelant. Le pendant de ça, c’est que rien ne garantit que quelqu’un récupère l’erreur.

Avec les types permettant le Railway programming, dans les langages fonctionnels, si tu ajoutes un cas d’erreur, tous les case, match où le type est utilisé doit être complet. Donc le compilateur te le dira si tu oublies de gérer un cas d’erreur.

Programmer en langage c++ de Claude Delannoy.

Je ne sais pas si la dernière édition est bien, mais j’ai l’édition avec le C++ pré-c++2003 et je la trouve très bien, didactique, progressive.

La nouvelle édition traite jusqu’au c++17. Comme je suis un peu vieux, j’aime bien un livre… ça permet entre autres de lire un chapitre le soir avant de s’endormir. De s’en servir de référence sans avoir à switcher de fenêtre sur l’écran. De caler un écran ou un pied de table.

Le principe en F# de railway programming.

Le langage n’était pas vraiment interprété. Un programme était constitué d’une liste d’objets. Un objet pouvez être un nombre, une instruction, un programme.
Les 5 premiers quartets (2,5 octets) de l’objet étaient un pointeur vers le code assembleur gérant l’objet. Par exemple pour un nombre, c’était d’ajouter le nombre dans la pile. Pour un +, le code prend les deux nombres dans la pile, les ajoutes et recrée un objet de nombre dans la pile.
La fin du code assembleur d’un objet termine toujours par une instruction JUMP vers le pointeur de l’objet suivant.

Dans les objets faits par HP, il y en avait deux un peu spéciaux : begin et end qui permettait d’agréger des objets pour faire un truc de plus haut niveau. J’ai trouvé cette façon de faire vraiment très élégante.

Si la fonction est pure, soit sans effet de bord, recopier son code ou une référence revient au même.

Sur ma HP48, on pouvait manipuler le code directement dans la pile, manipuler l’ordre des éléments, les dupliquer, les évaluer, les concaténer, etc.

Dans tous les cas, il va rester le problème des variables globales et des effets de bord, qu’il y ait copie ou non.

En fait ta première ligne :((1-5) + 7 ) × 8 <=> ((7 - 5) + 1)×8. Solution que mon programme trouve. Il trouve également : (7-(5-1))×8.

Voilà la solution, j’ai changé les Int en Ratio Int, enlevé les vérifications de la division et de la soustraction (mais là, je n’en vois pas l’intérêt ;-) )

À chaque modification, j’ai laissé l’ancienne ligne en commentaire pour voir les différences.

import Data.List
-- new line
import Data.Ratio

-- A value is an Int or an operation with two arguments and a result.
--data Value = V Int | Op Operation Value Value Int
data Value = V (Ratio Int) | Op Operation Value Value (Ratio Int)
data Operation = Plus | Min | Mult | Div | Error

-- Instance of Show class to be able to display Operation type
instance Show Operation where
  show Plus = "+"
  show Min  = "-"
  show Mult = "×"
  show Div  = "÷"
  show _    = "Error"

-- Instance of Show class for Value.
instance Show Value where
--  show (V a) = show a
  show (V a) = show $ numerator a  -- The value is a % 1
  show (Op o a b _) = " (" ++ (show a) ++ (show o) ++ (show b) ++ ") "

-- Take an Operation and a list of 2 minimal Values. Generate a new value with the first two terms.
doOp :: Operation -> [Value] -> [Value]
doOp Plus (a:b:xs) = (Op Plus a b (va+vb):xs)
                      where va = getV a
                            vb = getV b
-- We don't want to have negative values, so check if a >= b
-- We work in ℚ
doOp Min (a:b:xs) = (Op Min a b ((getV a)-(getV b)):xs)
--                   | otherwise = (Op Error a b (-1)):xs
doOp Mult (a:b:xs) = (Op Mult a b (va*vb)):xs
                      where va = getV a
                            vb = getV b
-- First check that divisor is not 0, then check if b can divide a without rest.
doOp Div (a:b:xs) | vb == 0 = (Op Error a b (-1)):xs
--                  | va `mod` vb == 0 = (Op Div a b (va `div` vb)):xs
--                  | otherwise = (Op Error a b (-1)):xs
                  | otherwise = (Op Div a b (va / vb)):xs
                   where va = getV a
                         vb = getV b

-- Create a Ratio
--setV a = V a
setV a = V (a % 1)
getV (V a) = a
getV (Op _ _ _ a) = a


-- Do operations, take a list of Values and do all operations, drop error if a computation is not possible
doOps :: [Value] -> [[Value]]
doOps a = filter (dropError.head) $ map (\x -> doOp x a) [Plus, Min, Mult, Div] 

-- Check for error filter, return True if it's valid.
dropError :: Value -> Bool
dropError (Op Error _ _ _) = False
dropError _ = True

-- En entrée une liste de values, en sortie une liste d'opérations filtrée.
-- Check we have 4 numbers.
-- From right to left
--    - map setV x  => generate a Value list with only V values.
--    - compute all permutations
--    - For each list of values apply all operations on first two values, we get list of list of list so concat to obtain list of list Values
--    - We have 3 elements
--    - For each element, we perform permutations and concat to get a list of list of Values.
--    - loop twice to get list of list of Value with length == 1.
--    - Then filter to check if result is 24.
get24 :: [Int] -> [[Value]]
get24 x | length x == 4 = filter (\x -> (getV (head x))==24) $ concat.map doOps $ concat.map permutations $ concat.map doOps $ concat.map permutations $ concat.map doOps $ permutations $ map setV x
        | otherwise = []

Et le résultat :

*Main Data.Ratio> get24 [7,7,2,1]
[[ ( ( (7×7) -1) ÷2) ],[ ( ( (7×7) -1) ÷2) ],[ ( ( (7×7) -1) ÷2) ],[ ( ( (7×7) -1) ÷2) ]]
*Main Data.Ratio> get24 [ 1,4,5,6]
[[ (6÷ ( (5÷4) -1) ) ],[ (4÷ (1- (5÷6) ) ) ],[ (6÷ ( (5÷4) -1) ) ],[ (4÷ (1- (5÷6) ) ) ]]
*Main Data.Ratio> get24 [7,7,2,1]
[[ ( ( (7×7) -1) ÷2) ],[ ( ( (7×7) -1) ÷2) ],[ ( ( (7×7) -1) ÷2) ],[ ( ( (7×7) -1) ÷2) ]]
*Main Data.Ratio> get24 [ 1,4,5,6]
[[ (6÷ ( (5÷4) -1) ) ],[ (4÷ (1- (5÷6) ) ) ],[ (6÷ ( (5÷4) -1) ) ],[ (4÷ (1- (5÷6) ) ) ]]

Oui, remplacer div par % et adapter les tests dans doOp Div (a:b:xs) :-)

Non, ça ne marchera pas.

:t (/)
(/) :: Fractional a => a -> a -> a
:t div
div :: Integral a => a -> a -> a
Prelude Data.Ratio> 1% 4
1 % 4
Prelude Data.Ratio> (1%4) `div` (4%5)

<interactive>:28:1: error:
    • Non type-variable argument in the constraint: Integral (Ratio a)
      (Use FlexibleContexts to permit this)
    • When checking the inferred type
        it :: forall a. (Integral a, Integral (Ratio a)) => Ratio a

La division entière à besoin d’un type integral ce que n'est pas Ratio. On ne peut pas mélanger les types dans les divisions.

Oui, mais j'ai volontairement omis les nombres à virgules…

I’ll be back with Rational soon ;-)

Non, je n'avait pas testé…

*Main> get24 [ 1,4,5,6] 
[]
*Main> 

Il retourne une liste vide, donc sans solution du point de vue de mon programme… c'est le résultat attendu ?

J’y ai pensé aussi, je l’ai fait. Je ne suis pas un pro du haskell, soyez bienveillant avec vos remarques ;-)

import Data.List

-- A value is an Int or an operation with two arguments and a result.
data Value = V Int | Op Operation Value Value Int
data Operation = Plus | Min | Mult | Div | Error

-- Instance of Show class to be able to display Operation type
instance Show Operation where
  show Plus = "+"
  show Min  = "-"
  show Mult = "×"
  show Div  = "÷"
  show _    = "Error"

-- Instance of Show class for Value.
instance Show Value where
  show (V a) = show a
  show (Op o a b _) = " (" ++ (show a) ++ (show o) ++ (show b) ++ ") "

-- Take an Operation and a list of 2 minimal Values. Generate a new value with the first two terms.
doOp :: Operation -> [Value] -> [Value]
doOp Plus (a:b:xs) = (Op Plus a b (va+vb):xs)
                      where va = getV a
                            vb = getV b
-- We don't want to have negative values, so check if a >= b
doOp Min (a:b:xs) | (getV a) >= (getV b) = (Op Min a b ((getV a)-(getV b)):xs)
                   | otherwise = (Op Error a b (-1)):xs
doOp Mult (a:b:xs) = (Op Mult a b (va*vb)):xs
                      where va = getV a
                            vb = getV b
-- First check that divisor is not 0, then check if b can divide a without rest.
doOp Div (a:b:xs) | vb == 0 = (Op Error a b (-1)):xs
                  | va `mod` vb == 0 = (Op Div a b (va `div` vb)):xs
                  | otherwise = (Op Error a b (-1)):xs
                   where va = getV a
                         vb = getV b

setV a = V a
getV (V a) = a
getV (Op _ _ _ a) = a


-- Do operations, take a list of Values and do all operations, drop error if a computation is not possible
doOps :: [Value] -> [[Value]]
doOps a = filter (dropError.head) $ map (\x -> doOp x a) [Plus, Min, Mult, Div] 

-- Check for error filter, return True if it's valid.
dropError :: Value -> Bool
dropError (Op Error _ _ _) = False
dropError _ = True

-- En entrée une liste de values, en sortie une liste d'opérations filtrée.
-- Check we have 4 numbers.
-- From right to left
--    - map setV x  => generate a Value list with only V values.
--    - compute all permutations
--    - For each list of values apply all operations on first two values, we get list of list of list so concat to obtain list of list Values
--    - We have 3 elements
--    - For each element, we perform permutations and concat to get a list of list of Values.
--    - loop twice to get list of list of Value with length == 1.
--    - Then filter to check if result is 24.
get24 :: [Int] -> [[Value]]
get24 x | length x == 4 = filter (\x -> (getV (head x))==24) $ concat.map doOps $ concat.map permutations $ concat.map doOps $ concat.map permutations $ concat.map doOps $ permutations $ map setV x
        | otherwise = []

Et les résultats :

*Main Data.List> :l try24.hs
[1 of 1] Compiling Main             ( try24.hs, interpreted )
Ok, one module loaded.
*Main Data.List> get24 [ 7,7,1,2]
[[ ( ( (7×7) -1) ÷2) ],[ ( ( (7×7) -1) ÷2) ],[ ( ( (7×7) -1) ÷2) ],[ ( ( (7×7) -1) ÷2) ]]
*Main Data.List> get24 [ 1,2,3,8]
[[ ( ( (2-1) ×3) ×8) ],[ (8× ( (2-1) ×3) ) ],[ ( (3× (2-1) ) ×8) ],[ (8× (3× (2-1) ) ) ],[ ( (3÷ (2-1) ) ×8) ],[ (8× (3÷ (2-1) ) ) ],[ ( (8×3) × (2-1) ) ],[ ( (8×3) ÷ (2-1) ) ],[ ( (2-1) × (8×3) ) ],[ ( (3×8) × (2-1) ) ],[ ( (3×8) ÷ (2-1) ) ],[ ( (2-1) × (3×8) ) ],[ ( (8× (2-1) ) ×3) ],[ (3× (8× (2-1) ) ) ],[ ( (8÷ (2-1) ) ×3) ],[ (3× (8÷ (2-1) ) ) ],[ ( ( (2-1) ×8) ×3) ],[ (3× ( (2-1) ×8) ) ],[ ( (8-2) × (3+1) ) ],[ ( (3+1) × (8-2) ) ],[ ( (8+ (3+1) ) ×2) ],[ (2× (8+ (3+1) ) ) ],[ ( ( (3+1) +8) ×2) ],[ (2× ( (3+1) +8) ) ],[ ( (8-2) × (1+3) ) ],[ ( (1+3) × (8-2) ) ],[ ( (8+ (1+3) ) ×2) ],[ (2× (8+ (1+3) ) ) ],[ ( ( (1+3) +8) ×2) ],[ (2× ( (1+3) +8) ) ],[ ( (1+ (8+3) ) ×2) ],[ (2× (1+ (8+3) ) ) ],[ ( ( (8+3) +1) ×2) ],[ (2× ( (8+3) +1) ) ],[ ( (2-1) × (8×3) ) ],[ ( (8×3) × (2-1) ) ],[ ( (8×3) ÷ (2-1) ) ],[ ( (1+ (3+8) ) ×2) ],[ (2× (1+ (3+8) ) ) ],[ ( ( (3+8) +1) ×2) ],[ (2× ( (3+8) +1) ) ],[ ( (2-1) × (3×8) ) ],[ ( (3×8) × (2-1) ) ],[ ( (3×8) ÷ (2-1) ) ],[ ( (1+3) × (8-2) ) ],[ ( (8-2) × (1+3) ) ],[ ( (3+1) × (8-2) ) ],[ ( (8-2) × (3+1) ) ],[ ( (3+ (8+1) ) ×2) ],[ (2× (3+ (8+1) ) ) ],[ ( ( (8+1) +3) ×2) ],[ (2× ( (8+1) +3) ) ],[ ( (3+ (1+8) ) ×2) ],[ (2× (3+ (1+8) ) ) ],[ ( ( (1+8) +3) ×2) ],[ (2× ( (1+8) +3) ) ],[ ( (3+1) × (8-2) ) ],[ ( (8-2) × (3+1) ) ],[ ( (1+3) × (8-2) ) ],[ ( (8-2) × (1+3) ) ],[ ( ( (2-1) ×8) ×3) ],[ (3× ( (2-1) ×8) ) ],[ ( (8× (2-1) ) ×3) ],[ (3× (8× (2-1) ) ) ],[ ( (8÷ (2-1) ) ×3) ],[ (3× (8÷ (2-1) ) ) ],[ ( (3×8) × (2-1) ) ],[ ( (3×8) ÷ (2-1) ) ],[ ( (2-1) × (3×8) ) ],[ ( (8×3) × (2-1) ) ],[ ( (8×3) ÷ (2-1) ) ],[ ( (2-1) × (8×3) ) ],[ ( (3× (2-1) ) ×8) ],[ (8× (3× (2-1) ) ) ],[ ( (3÷ (2-1) ) ×8) ],[ (8× (3÷ (2-1) ) ) ],[ ( ( (2-1) ×3) ×8) ],[ (8× ( (2-1) ×3) ) ],[ ( ( (8+1) +3) ×2) ],[ (2× ( (8+1) +3) ) ],[ ( (3+ (8+1) ) ×2) ],[ (2× (3+ (8+1) ) ) ],[ ( ( (1+8) +3) ×2) ],[ (2× ( (1+8) +3) ) ],[ ( (3+ (1+8) ) ×2) ],[ (2× (3+ (1+8) ) ) ],[ ( ( (1+3) +8) ×2) ],[ (2× ( (1+3) +8) ) ],[ ( (8+ (1+3) ) ×2) ],[ (2× (8+ (1+3) ) ) ],[ ( (8-2) × (1+3) ) ],[ ( (1+3) × (8-2) ) ],[ ( ( (8+3) +1) ×2) ],[ (2× ( (8+3) +1) ) ],[ ( (1+ (8+3) ) ×2) ],[ (2× (1+ (8+3) ) ) ],[ ( (2-1) × (8×3) ) ],[ ( (8×3) × (2-1) ) ],[ ( (8×3) ÷ (2-1) ) ],[ ( ( (3+8) +1) ×2) ],[ (2× ( (3+8) +1) ) ],[ ( (1+ (3+8) ) ×2) ],[ (2× (1+ (3+8) ) ) ],[ ( (2-1) × (3×8) ) ],[ ( (3×8) × (2-1) ) ],[ ( (3×8) ÷ (2-1) ) ],[ ( ( (3+1) +8) ×2) ],[ (2× ( (3+1) +8) ) ],[ ( (8+ (3+1) ) ×2) ],[ (2× (8+ (3+1) ) ) ],[ ( (8-2) × (3+1) ) ],[ ( (3+1) × (8-2) ) ]]

Évidemment, on prend toute les permutations d’une même solution.

En vérifiant le retour de snprintf, tu peux savoir s’il y avait assez de place… Obligatoire, dès que tu as en entrée des données que tu ne maitrises pas.

(6×4)÷(5-1) et il n’y a que des divisions entières.

Ce qui est dommage avec le C c'est juste la gestion de la mémoire très difficile et sa propension a permettre les buffer overflow par exemple.

Il faut juste apprendre à programmer…
J’ai appris à mes enfants, quand ils prennent le jouet d’un copain, à le rendre. Il faut juste faire pareil ;-)

--->[]

Tu as oublié de traiter le cas :

int ret = iconv(conv, &pin, &ol, &pout, &dl);

$ man 3 iconv
ICONV(3)                                                                                                                       Linux Programmer's Manual                                                                                                                      ICONV(3)

NAME
       iconv - perform character set conversion

SYNOPSIS
       #include <iconv.h>

       size_t iconv(iconv_t cd,
                    char **inbuf, size_t *inbytesleft,
                    char **outbuf, size_t *outbytesleft);

DESCRIPTION
       The  iconv()  function converts a sequence of characters in one character encoding to a sequence of characters in another character encoding.  The cd argument is a conversion descriptor, previously created by a call to iconv_open(3); the conversion descriptor defines the
       character encodings that iconv() uses for the conversion.  The inbuf argument is the address of a variable that points to the first character of the input sequence; inbytesleft indicates the number of bytes in that buffer.  The outbuf argument is the address of  a  vari‐
       able that points to the first byte available in the output buffer; outbytesleft indicates the number of bytes available in the output buffer.

       The  main  case  is  when inbuf is not NULL and *inbuf is not NULL.  In this case, the iconv() function converts the multibyte sequence starting at *inbuf to a multibyte sequence starting at *outbuf.  At most *inbytesleft bytes, starting at *inbuf, will be read.  At most
       *outbytesleft bytes, starting at *outbuf, will be written.

       The iconv() function converts one multibyte character at a time, and for each character conversion it increments *inbuf and decrements *inbytesleft by the number of converted input bytes, it increments *outbuf and decrements *outbytesleft by the number of converted  out‐
       put  bytes,  and  it  updates the conversion state contained in cd.  If the character encoding of the input is stateful, the iconv() function can also convert a sequence of input bytes to an update to the conversion state without producing any output bytes; such input is
       called a shift sequence.  The conversion can stop for four reasons:

       1. An invalid multibyte sequence is encountered in the input.  In this case, it sets errno to EILSEQ and returns (size_t) -1.  *inbuf is left pointing to the beginning of the invalid multibyte sequence.

       2. The input byte sequence has been entirely converted, that is, *inbytesleft has gone down to 0.  In this case, iconv() returns the number of nonreversible conversions performed during this call.

       3. An incomplete multibyte sequence is encountered in the input, and the input byte sequence terminates after it.  In this case, it sets errno to EINVAL and returns (size_t) -1.  *inbuf is left pointing to the beginning of the incomplete multibyte sequence.

       4. The output buffer has no more room for the next converted character.  In this case, it sets errno to E2BIG and returns (size_t) -1.

       A different case is when inbuf is NULL or *inbuf is NULL, but outbuf is not NULL and *outbuf is not NULL.  In this case, the iconv() function attempts to set cd's conversion state to the initial state and store a corresponding shift sequence at *outbuf.   At  most  *out‐
       bytesleft bytes, starting at *outbuf, will be written.  If the output buffer has no more room for this reset sequence, it sets errno to E2BIG and returns (size_t) -1.  Otherwise, it increments *outbuf and decrements *outbytesleft by the number of bytes written.

       A third case is when inbuf is NULL or *inbuf is NULL, and outbuf is NULL or *outbuf is NULL.  In this case, the iconv() function sets cd's conversion state to the initial state.

RETURN VALUE
       The iconv() function returns the number of characters converted in a nonreversible way during this call; reversible conversions are not counted.  In case of error, it sets errno and returns (size_t) -1.

ERRORS
       The following errors can occur, among others:

       E2BIG  There is not sufficient room at *outbuf.

       EILSEQ An invalid multibyte sequence has been encountered in the input.

       EINVAL An incomplete multibyte sequence has been encountered in the input.

VERSIONS
       This function is available in glibc since version 2.1.

ATTRIBUTES
       For an explanation of the terms used in this section, see attributes(7).

       ┌──────────┬───────────────┬─────────────────┐
       │Interface │ Attribute     │ Value           │
       ├──────────┼───────────────┼─────────────────┤
       │iconv()   │ Thread safety │ MT-Safe race:cd │
       └──────────┴───────────────┴─────────────────┘
       The iconv() function is MT-Safe, as long as callers arrange for mutual exclusion on the cd argument.

CONFORMING TO
       POSIX.1-2001, POSIX.1-2008.

NOTES
       In each series of calls to iconv(), the last should be one with inbuf or *inbuf equal to NULL, in order to flush out any partially converted input.

       Although  inbuf  and  outbuf are typed as char **, this does not mean that the objects they point can be interpreted as C strings or as arrays of characters: the interpretation of character byte sequences is handled internally by the conversion functions.  In some encod‐
       ings, a zero byte may be a valid part of a multibyte character.

       The caller of iconv() must ensure that the pointers passed to the function are suitable for accessing characters in the appropriate character set.  This includes ensuring correct alignment on platforms that have tight restrictions on alignment.

SEE ALSO
       iconv_close(3), iconv_open(3), iconvconfig(8)

COLOPHON
       This page is part of release 5.10 of the Linux man-pages project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at https://www.kernel.org/doc/man-pages/.

Il y a vingt ans, je ne me souviens plus trop…
RedHat -> Mandrake -> Suze -> debian (stable -> sid)(2003) -> gentoo (±14 ans) -> debian stable.

Maintenant, debian stable est suffisant pour moi, sauf peut-être pour avoir des versions récentes de blender… Mais pour ça, j’utilise la version dans steam :-p