Autour de Linux » C++

Compiler xvidcap-1.1.7 sous Lucid

admin — Sun, 23 May 2010 20:27:22 +0000

Dans les forums d’Ubuntu-fr, quelqu’un demandait comment compiler xvidcap-1.1.7 sous Lucid afin de résoudre des problèmes de son qu’il avait avec la version des dépôts et manifestement avait un peu de mal a s’en sortir avec les messages d’erreurs.

Xvidcap est un programme de capture d’écran, dans un fichier vidéo AVI ou mpeg, destinée à la réalisation de screencast.
Pour compiler le programme, il faut le télécharger ici, installer les paquets suivants qui sont nécessaires:

$ sudo aptitude install libxmu-dev
$ sudo aptitude libxmu-headers
$ sudo aptitude libxt-dev

Ensuite, il faut décompresser l’archive puis compiler le programme de manière habituelle:

$ tar  -zxvf xvidcap-1.1.7.tar.gz
$ cd xvidcap-1.1.7
$ ./configure
$ make

Mais durant le make, une erreur apparaît qui peut être incompréhensible pour quelqu’un qui n’a pas l’habitude:

capture.c: In function ‘XGetZPixmapSHM’:
capture.c:668: error: expected ‘=’, ‘,’, ‘;’, ‘asm’ or ‘__attribute__’ before ‘*’ token
capture.c:668: error: ‘req’ undeclared (first use in this function)
capture.c:668: error: (Each undeclared identifier is reported only once
capture.c:668: error: for each function it appears in.)
capture.c:669: error: ‘xShmGetImageReply’ undeclared (first use in this function)
capture.c:669: error: expected ‘;’ before ‘rep’
capture.c:675: error: ‘sz_xShmGetImageReq’ undeclared (first use in this function)
capture.c:675: error: ‘xShmGetImageReq’ undeclared (first use in this function)
capture.c:675: error: expected expression before ‘)’ token
capture.c:675: error: ‘X_ShmGetImage’ undeclared (first use in this function)
capture.c:693: error: ‘rep’ undeclared (first use in this function)

En bref, cela signifie que dans le fichier capture.c, à la ligne 668, dans la fonction XGetZPixmapSHM, il y a un type non-déclaré: xShmGetImageReq.
Après une petite recherche dans les fichiers d’entête (.h), il apparaît que ce type est déclaré dans Lucid dans le fichier X11/extensions/shmproto.h. Or celui-ci n’est pas inclus dans capture.c. A la place, on trouve un fichier X11/extensions/shmstr.h qui lui n’existe plus. Donc il semblerait bien que le premier remplace le second dans les dernières versions. Il suffit donc dans le fichier capture.c de trouver la ligne contenant:

#include

et de la remplacer par:

#include

Relancez la compilation puis l’installation et vous obtiendrez une version compilée de xvidcap fonctionnelle et avec le son en plus:

$ make
$ sudo make install

Parasite

admin — Tue, 29 Sep 2009 15:33:17 +0000

Parasite est un outil qui peut être très utile à toute personne qui développe de petites ou de grosses applications en utilisant GTK pour la partie interface graphique. Ce module qui s’intercale dans votre application de façon très simple, vous permet de débugger votre interface graphique (GUI en anglais ou IHM en français) en vous donnant la hiérarchie des widgets utilisés ainsi que leurs propriétés. Parasite vous permet aussi d’agir sur ces propriétés et de les modifier et ainsi de voir immédiatement l’effet de vos modifications sur votre interface graphique.
Ceux d’entre-vous qui utilisent firebug sous Firefox ne seront pas dépaysés. L’interface y ressemble avec son bouton ‘Inspect’ qui permet de voyager dans les widgets de l’interface graphique.
Voici un screenshot vous montrant à quoi ressemble Parasite. Dans l’exemple, Parasite est utilisé pour inspecter l’interface graphique de la calculatrice Gnome (gcalctool). Je me suis amusé à y changer certains labels de boutons et à en rendre un invisible. Mais ce n’est évidemment pas tout ce que peu faire Parasite; ça ne se limite bien sûr pas à changer le label des boutons!

Pour installer Parasite, downloadez le fichier .tar.gz à cette adresse et décompressez l’archive:
http://github.com/chipx86/gtkparasite/tarball/master

Il va falloir compiler le programme mais rassurez-vous, cela se passe sans problème.
En regardant dans le répertoire où l’archive est décompressée, on remarque qu’il n’y a pas de fichier configure. Heureusement, le script autogen.sh va nous le créer. ensuite, la compilation se fait “as usual” en utilisant configure/make/make install:

$ ./autogen.sh
$ ./configure
$ make
$ sudo make install

Vérifiez que toutes ces étapes se soient bien passées et qu’aucun message d’erreur ne soit affiché dans le terminal.
il reste ensuite à créer un lien symbolique dans /usr/lib pointant vers /usr/local/lib/gtk-2.0/modules/libgtkparasite.so.

$ cd /usr/lib
$ sudo ln -s /usr/local/lib/gtk-2.0/modules/libgtkparasite.so libgtkparasite.so

Pour attacher Parasite à une application, il suffit d’intercaler Parasite de cette manière:

$ GTK_MODULES=gtkparasite gcalctool

Vous devez bien évidemment, dans la ligne ci-dessus, remplacer gcalctoolgcalctool par le nom de l’application dont vous voulez débugger l’interface graphique.

Colorisation syntaxique avec pygments

admin — Tue, 15 Sep 2009 17:28:21 +0000

Elle consiste à donner à chaque élément d’un texte un style particulier. En programmation, cela consiste à donner une couleur et un style (gras, italique…) à chaque élément constituant le code source. La colorisation syntaxique rend le code plus lisible donc plus facilement compréhensible.

La plupart des éditeurs de texte le font automatiquement mais si vous devez formater le texte vous même pour l’afficher dans un wiki, une page web ou un blog, c’est une autre paire de manche.
J’utilise par exemple deux scripts qui me permettent de faire la colorisation syntaxique de code C++ ou python et me donnent un fichier html que je peux inclure dans une page web. Le problème est que si je veux documenter du code PHP, javascript ou des requètes SQL et faire la colorisation syntaxique moi-même, il faudra que je réécrive un nouveau script pour chaque langage. Heureusement pour moi, j’ai découvert une application écrite en python et trouvable sur http://pygments.org.

Pygments permet la colorisation syntaxique d’un très grand nombre de langages dont par exemple bash, C,C++, C#, Lisp, Lua, Delphi, PHP, Perl Python, Ruby, Tcl, Java, Javascript … Et je n’ai mis ici que les langages les plus connus. Il ye en a plein d’autres. Pygments permet aussi la colorisation syntaxique de fichiers de configuration, ini, css, html, sql, xml, latex,… De surcroît, on peut choisir le format de sortie: html, latex, rtf…

Pygments peut être utilisé en ligne de commande ou en tant que librairie dans un projet.

Pour l’installer, downloadez le fichier Pygments-1.1.tar.gz depuis http://pypi.python.org/pypi/Pygments
Ensuite tapez les commandes suivantes dans un terminal pour extraire de l’archive les fichiers et exécuter le fichier d’installation.

$ tar -zxvf Pygments-1.1.tar.gz
$ cd Pygments-1.1
$ sudo python setup.py install

Exemple d’utilisation en ligne de commande pour générer du code html:

Disons que nous voulons coloriser le bout de code python suivant:

# Returns the factorial of a number
def factorial(x):
    if x < 0:
        raise ValueError("Factorial is only defined for x >= 0")
    y = 1
    while x >= 2:
        y *= x
        x -= 1
    return y

Ce bout de code, plaçons-le dans un fichier appelé test.py et tapons la ligne suivante dans notre terminal:

$ pygmentize -f html -l python -o test.html test.py

-l choix du lexer, c’est à dire le module chargé de parser le code donné dans le langage spécifié et le séparer en ses composants (keywords, comments, chaînes de caractères…)

-f choix du formateur, c’est à dire le format sous lequel vous désirez le fichier de sortie (html, latex, rtf…).

Le résultat obtenu est le fichier html test.html ci-dessous:

# Returns the factorial of a number
def factorial(x):
    if x < 0:
        raise ValueError("Factorial is only defined for x >= 0")
    y = 1
    while x >= 2:
        y *= x
        x -= 1
    return y

Vous remarquerez que chaque constituant du code a son propre style avec sa classe propre. A vous de déterminer ce style en donnant au navigateur une feuille de style (css) compatible. Vous pouvez vous aider en utilisant la commande suivante qui liste les différents styles utilisés sous forme de css:

$ pygmentize -f html -S colorful 

.hll { background-color: #ffffcc }
.c { color: #808080 } /* Comment */
.err { color: #F00000; background-color: #F0A0A0 } /* Error */
.k { color: #008000; font-weight: bold } /* Keyword */
.o { color: #303030 } /* Operator */
.cm { color: #808080 } /* Comment.Multiline */
.cp { color: #507090 } /* Comment.Preproc */
.c1 { color: #808080 } /* Comment.Single */
.cs { color: #cc0000; font-weight: bold } /* Comment.Special */
.gd { color: #A00000 } /* Generic.Deleted */
.ge { font-style: italic } /* Generic.Emph */
.gr { color: #FF0000 } /* Generic.Error */
.gh { color: #000080; font-weight: bold } /* Generic.Heading */
.gi { color: #00A000 } /* Generic.Inserted */
.go { color: #808080 } /* Generic.Output */
.gp { color: #c65d09; font-weight: bold } /* Generic.Prompt */
.gs { font-weight: bold } /* Generic.Strong */
.gu { color: #800080; font-weight: bold } /* Generic.Subheading */
.gt { color: #0040D0 } /* Generic.Traceback */
.kc { color: #008000; font-weight: bold } /* Keyword.Constant */
.kd { color: #008000; font-weight: bold } /* Keyword.Declaration */
.kn { color: #008000; font-weight: bold } /* Keyword.Namespace */
.kp { color: #003080; font-weight: bold } /* Keyword.Pseudo */
.kr { color: #008000; font-weight: bold } /* Keyword.Reserved */
.kt { color: #303090; font-weight: bold } /* Keyword.Type */
.m { color: #6000E0; font-weight: bold } /* Literal.Number */
.s { background-color: #fff0f0 } /* Literal.String */
.na { color: #0000C0 } /* Name.Attribute */
.nb { color: #007020 } /* Name.Builtin */
.nc { color: #B00060; font-weight: bold } /* Name.Class */
.no { color: #003060; font-weight: bold } /* Name.Constant */
.nd { color: #505050; font-weight: bold } /* Name.Decorator */
.ni { color: #800000; font-weight: bold } /* Name.Entity */
.ne { color: #F00000; font-weight: bold } /* Name.Exception */
.nf { color: #0060B0; font-weight: bold } /* Name.Function */
.nl { color: #907000; font-weight: bold } /* Name.Label */
.nn { color: #0e84b5; font-weight: bold } /* Name.Namespace */
.nt { color: #007000 } /* Name.Tag */
.nv { color: #906030 } /* Name.Variable */
.ow { color: #000000; font-weight: bold } /* Operator.Word */
.w { color: #bbbbbb } /* Text.Whitespace */
.mf { color: #6000E0; font-weight: bold } /* Literal.Number.Float */
.mh { color: #005080; font-weight: bold } /* Literal.Number.Hex */
.mi { color: #0000D0; font-weight: bold } /* Literal.Number.Integer */
.mo { color: #4000E0; font-weight: bold } /* Literal.Number.Oct */
.sb { background-color: #fff0f0 } /* Literal.String.Backtick */
.sc { color: #0040D0 } /* Literal.String.Char */
.sd { color: #D04020 } /* Literal.String.Doc */
.s2 { background-color: #fff0f0 } $ pygmentize -O full -o test.html test.py/* Literal.String.Double */
.se { color: #606060; font-weight: bold; background-color: #fff0f0 } /* Literal.String.Escape */
.sh { background-color: #fff0f0 } /* Literal.String.Heredoc */
.si { background-color: #e0e0e0 } /* Literal.String.Interpol */
.sx { color: #D02000; background-color: #fff0f0 } /* Literal.String.Other */
.sr { color: #000000; background-color: #fff0ff } /* Literal.String.Regex */
.s1 { background-color: #fff0f0 } /* Literal.String.Single */
.ss { color: #A06000 } /* Literal.String.Symbol */
.bp { color: #007020 } /* Name.Builtin.Pseudo */
.vc { color: #306090 } /* Name.Variable.Class */
.vg { color: #d07000; font-weight: bold } /* Name.Variable.Global */
.vi { color: #3030B0 } /* Name.Variable.Instance */
.il { color: #0000D0; font-weight: bold } /* Literal.Number.Integer.Long */

Il vous est aussi possible d’ajouter des numéros de lignes. Ceci crée en fait un tableau html dont la première colonne est le numéro de la ligne:

$ pygmentize -f html -l python -O style=colorful,linenos=1 -o test.html test.py

Si vous préférez un fichier html complet représentant une page complète avec entête et style utilisable directement avec le navigateur:

$ pygmentize -O full -o test.html test.py

Le résultat est ci-dessous. Notez l’entête, les CSS inclus dans le fichier et finalement votre code source formaté:





  
  
  




# Returns the factorial of a number
def factorial(x):
    if x < 0:
        raise ValueError("Factorial is only defined for x >= 0")
    y = 1
    while x >= 2:
        y *= x
        x -= 1
    return y

Et vous pouvez voir ici le résultat de tous vos efforts.

C++ – le compilateur est-il installé?

admin — Sat, 01 Aug 2009 08:39:13 +0000

J’avais une application que je devais absolument compiler sur une machine. L’application était écrite en C et en C++. Je lance la compilation avec make et gcc me donne tout à coup une erreur:

gcc: error trying to exec 'cc1plus': execvp: Aucun fichier ou dossier de ce type

Il faut savoir que cc1 est le compilateur C et cc1plus, le compilateur C++.
Je me suis gratté la tête pendant un quart d’heure à me demander pourquoi le compilateur C++ ne pouvait être lancé avant de réaliser qu’en fait, ce message d’erreur signale simplement que le compilateur n’est pas installé. Donc, avant de faire comme moi et de fouiller tout votre système à la recherche du compilateur g++, vérifiez si vous n’avez pas tout simplement oublié de l’installer.

$ sudo aptitude install g++

Ceci suffit à l’installer et à faire disparaître l’erreur de compilation.

C++ – Qt Creator un IDE complet

admin — Sat, 07 Mar 2009 14:34:35 +0000

Le 3 mars est sorti Qt 4.5, la nouvelle version du framework Qt ex-Trolltech et maintenant devenu Nokia. Comme chacun sait, KDE est construit sur Qt et si j’en parle ici, c’est parce que cette nouvelle version est accompagnée de tout un SDK (Software Development Kit) qui intégre un IDE (Integrated Development Environment) complet qui est assez extraordinaire et qui fait rêver. A quand un IDE basé sur GTK pour Gnome et qui soit de la qualité de Qt Creator puisque c’est le nom de cet IDE. Un IDE est un environement complet qui permet le design (pour la partie GUI), l’écriture, la gestion, la compilation et le débuggage d’une application. Et ce Qt Creator est de la qualité de Visual C++ de Microsoft ou de C++Builder de CodeGear (ex-Borland) pour citer deux autres IDE. Assez étonnamment, il est assez léger à l’usage même sur mon vieux P4 2.8GHz avec 1Gb de RAM.

Qt Creator est bien sûr utilisable sous Ubuntu même si vous êtes sous Gnome. A l’installation, les librairies nécessaires sont installées automatiquement.
Pour l’installer, rendez-vous sur le site de qtsoftware pour y télécharger la version pour Linux. Le nom du fichier est qt-sdk-linux-x86-opensource-2009.01.bin. Après l’avoir téléchargé, rendez-ce fichier exécutable et lancez-le:

$ chmod +x qt-sdk-linux-x86-opensource-2009.01.bin
$ sudo ./qt-sdk-linux-x86-opensource-2009.01.bin

L’installation est assez rapide et automatique. Il ne vous demandera que d’accepter la licence. Ensuite, une nouvelle entrée dans votre menu Applications/Programmation sera ajoutée. Il ne vous reste plus qu’à lancer l’IDE et à l’utiliser.
Ci-dessous quelques screenshots de Qt Creator, juste pour vous mettre l’eau à la bouche:

Qt Creator – fenêtre principale

Qt Creator – l’éditeur

Qt Creator – le designer

Espérons qu’on ait un jour un IDE de qualité semblable mais sous GTK. Ca me ‘gêne’ toujours un peu d’utiliser des librairies KDE sous Gnome et je n’ai pas envie, pour l’instant du moins, de migrer vers KDE.

C++ – Alignement des structures

admin — Tue, 03 Feb 2009 20:38:59 +0000

Vous devez toujours garder à l’esprit cette notion d’alignement parce que la taille réelle d’une structure ou d’une classe n’est pas toujours celle que vous imaginez.
Prenons l’exemple de cette structure:

struct A
{
  int i;
  char c;
}a;

Le résultat de sizeof(a) donnera 8 octets alors que seulement 5 octets sont utilisés. Le reste, c’est l’alignement (padding en anglais). Le compilateur essaie toujours de garder l’alignement sur un multiple de quad-word (quatre mots, un mot étant égal à deux octets). Ceci est en tout cas valable pour les PC avec un OS 32 bits et dépend de l’implémentation.

struct A
{
  int i;
  char c1;
  char c2;
  char c3;
  char c4;
}a;

Dans ce cas, la réponse de sizeof(a) est aussi 8 octets et nous avons effectivement 8 octets d’utilisés.

Il est possible, lorsque la structure des données doit impérativement être alignée sur sa valeur réelle ou sur une autre valeur que des multiples de quatre mots, de dire au compilateur de changer ce comportement par défaut. Mais il est important de savoir que si le compilateur utilise ce type d’alignement sur des mots de quatre mots (8 octets), c’est parce que le processeur a plus de facilité à traiter cette taille de données. Le processeur dispose de registres et d’instructions rapides pour traiter les données alignées de cette façon. Si vous modifiez l’alignement, ceci aura un impact non-négligeable sur les performances de votre application. Autrement dit celle-ci sera notablement plus lente si vous traitez un grand nombre de structures de données.

struct A
{
    int i;
    char c1;
}__attribute__((packed));

L’attribut packed donné à la structure donne injonction au compilateur d’aligner la structure sur sa taille réelle. Ici, la réponse de sizeof(a) donnerait 5 octets.

struct A
{
    int i;
    char c1;
}__attribute__((aligned(x)));

Remplacez x par la valeur que vous souhaitez et le compilateur alignera la structure sur la valeur que vous avez spécifiée.

C++ – le problème des variables temporaires

admin — Mon, 17 Nov 2008 16:15:00 +0000

Imaginons une fonction retournant un std::string par valeur:

std::string foo()
{
  return std::string();
}

Lors du return, le compilateur crée une variable temporaire et celle-ci existe jusqu’à ce que la fonction se termine. Cela ne pose pas de problème si vous utilisez cette variable temporaire de cette manière:

std::string str = foo();

Une copie de la variable temporaire est assignée à str et lorsque la fonction se termine, la variable temporaire est détruite. Sa valeur a été transmise par copie à str. Tout va bien.

Un problème peut se présenter si vous assignez cette variable temporaire à une référence non constante:

const std::string& str = foo();

Le type de retour de foo() spécifie qu’un string est retourné par valeur. C’est à dire qu’une copie de la variable temporaire est créée et liée à votre référence et sa durée de vie est égale à celle de la référence. Il faut bien comprendre que la variable temporaire créée lors du return n’est pas la même que celle créée par copie et liée à la référence.

Par contre, lier une variable temporaire à une référence non constante n’est pas permis par la norme:

std::string& str = foo();   //illégal

La norme précise qu’une variable temporaire liée à une référence est une rvalue (expression à droite du signe =) et donc on ne peut pas lui assigner une valeur ni la modifier. En conséquence lier une variable temporaire à une référence non constante viole cette règle. Et ce n’est donc pas permis.

Le code de bonne pratique veut donc que vos références soient constantes par défaut. Ne les rendez non constantes que si c’est absolument nécessaire. Et si vraiment vous devez modifier une référence, pourquoi ne pas utiliser un pointeur?

C++ – Comprendre les structures

admin — Fri, 19 Sep 2008 10:21:11 +0000

Bien souvent, on me demande d’expiquer la notation des structures telles que celle utilisées dans l’API Windows. Je sais, cela n’a rien à voir avec Linux sauf que Microsoft ayant tendance a rendre son code illisible parfois (ou disons plus compliqué pour le débutant), je vais tenter d’expliquer cette construction même si on d’éloigne un peu du C++ (les structures en C n’ayant que peu à voir avec celles du C++). Voici un exemple typique d’une structure en C:

typedef struct type1
{
  int i;
  char *c;
}var1, *var2;

Commençons par simplifier cette structure afin d’y voir plus clair:

struct type1
{
  int i;
  char *c;
};

Ceci définit une structure de type type1 contenant un entier i et un pointeur vers un caractère c. Ok, jusque là, c’est assez simple.

struct type1
{
  int i;
  char *c;
}var1;

Cette fois-ci nous avons défini une structure de type type1 et une variable var1 de type type1.

Si vous mettez le mot-clé typedef devant une variable, vous changez la déclaration de la variable en une déclaration de type. Le nom de ce qui devrait être le nom de la variable devient, à cause du typedef, un nom de type.

typedef int i;

i devient un type équivalent à un int.
Revenons-en à notre problème et voyons en quoi le typedef en modifie le sens.

typedef struct type1
{
  int i;
  char *c;
}var1;

Ceci déclare un type type1 et var1 qui est aussi un type mais équivalent à type1.

struct type1
{
  int i;
  char *c;
}var1, *var2;

Ici, on définit une structure de type type1, une variable de type type1 corespondant à la structure et une variable de type pointeur vers un type type1.
Ajoutons le typedef:

typedef struct type1
{
  int i;
  char *c;
}var1, *var2;

Avec le typedef, on en arrive finalement à notre structure telle que rencontrée fréquemment dans l’API Windows.
Cette structure, précédée de typedef, définit trois types. D’abord un type type1 et un type var1 qui sont équivalents. Ensuite on définit le type var2 comme étant un pointeur vers le type type1. Remarquez qu’on ne définit donc pas de variables mais bien trois types.

Utiliser ses propres journaux d’événements

admin — Sat, 13 Sep 2008 10:24:28 +0000

Sous Linux, les journaux d’événements (log en anglais) sont centralisés. il y a un daemon syslogd qui implémente le protocole syslog et gère les différents fichiers de log du système.
Ces fichiers sont très important pour résoudre des problèmes de fonctionnement ou de plantage.
Ma question du jour est: est-il possible d’utiliser cette facilité pour ses propres scripts ou programmes? Ce que je veux c’est un fichier .log qui ne soit utilisé que par mes programmes et qui soit situé, comme tous les autres fichiers de log du système, dans le répertoire /var/log.

Sans entrer dans les détails du fichier /etc/syslog.conf, il existe un certain nombre de fichiers standards comme par exemple (extrait du fichier /etc/syslog.conf):

kern.*				-/var/log/kern.log
mail.info			-/var/log/mail.info
news.crit			/var/log/news/news.crit

On peut voir par exemple que les événements concernant le mail sont écrits dans le fichier /var/log/mail.log. Le protocole syslog définit un certain nombres de facilités (facility). vous en voyez des exemples ici: mail, kern, lpr, user,news,… et huit priorités (priority) différentes:

Emerg (emergency)
Alert
Crit (critical)
Err (error)
Warning
Notice
Info
Debug

l’astérisque dans le couple facility.priority signifie que le fichier utilisé doit être celui qui est spécifié peu importe le niveau de priorité.

Ce qui nous intéresse, c’est qu’il existe huit facilités définissables par l’utilisateur ou par tout programme pour lequel il n’existerait pas de facilité par défaut dans syslog. Il s’agit des facilités local0 à local7. Autrement dit, il nous suffit d’ajouter dans le fichier /etc/syslog.conf une ligne du genre:

local0.*			-/var/log/michel.log

Je ne spécifie pas de priorité et le fichier dans lequel les événements sont écrits doit être /var/log/michel.log. le - devant signifie que les messages ne doivent pas nécessairement être écrits directement dans le fichier mais que leur écriture peut être différée. Ceci n’a d’importance que pour des messages vraiment critiques qui en cas de plantage pourraient ne pas être écrits dans le fichier de log.

Ok, il reste une petite chose à faire: relancer le daemon syslogd pour que nos changements dans le fichier /etc/syslog.conf soit pris en compte:

$ sudo /etc/init.d/sysklogd restart

Maintenant nous sommes prêts à écrire nos messages dans le fichier de log /var/log/michel.log comme nous le voulions. Mais comment faire?

Dans un script shell, c’est facile, il existe une commande qui permet d’écrire dans un fichier de log:

$ logger -p local0.notice -t TEST Test de log

le switch -p spécifie le couple facilité.priorité. La priorité n’a pas d’importance pour nous.
le -t spécifie un tag que l’on peut afficher au début du message, le nom du programme qui a généré le message par exemple.
Le résultat de la commande se trouve donc dans le fichier /var/log/michel.log comme voulu:

$ more /var/log/michel.log
Sep 13 09:48:26 LinuxPC TEST: Test de log

Faire la même chose dans un programme écrit en python est à peine plus compliqué:

#!/usr/bin/env python

import syslog

syslog.openlog('TEST', 0, syslog.LOG_LOCAL0)
syslog.syslog(syslog.LOG_INFO,'Test de log en python')
syslog.closelog()

Je vous invite à jeter un oeil à la documentation du module syslog pour connaître les différentes constantes utilisables.

Voici la même chose en C++:

# include 
# include 

int main()
{
  std::string message = "TEST";
  openlog(message.c_str(), 0, LOG_LOCAL0);
  syslog(LOG_INFO,"Test de log en C++");
  closelog();
  return EXIT_SUCCESS;
}

Un conseil, abusez des fichiers de log dans vos scripts et vos programmes. Je vous assure que cela rend de grand services en cas de problème. C’est d’autant plus vrai si vous distribuez vos programmes parce que c’est toujours sur une autre machine que la vôtre que les plantages arrivent et vous serez content que votre client puisse vous envoyer le fichier de log de votre programme.

C++ – Classes et fonctions amies

admin — Tue, 12 Aug 2008 19:07:06 +0000

On utilise la notion d’ami lorsque l’on a deux classes dont l’une doit avoir accès aux données membres privées de l’autre.
Cette façon de faire permet de limiter à une seule classe l’accès à des données privées et de ne pas devoir rendre celles-ci publiques ce qui les rendrait disponibles pour tout objet ou classe.

class A
{
  public:
    void f();
};

class B
{
  private:
    friend class A;
    int g(){return x;}
    int x;
};

Il est important de remarquer que c’est la classe qui veut partager ses données privées avec une autre qui donne l’accès à celles-ci en spécifiant que l’autre classe est une amie.
Cela se fait avec le mot-clé friend suivi de la classe qui reçoit l’accès aux données privées.
Les bonnes pratiques de la programmation veulent que même si dans ce cas-ci, A a accès à x dans B, A n’y fasse appel que via une fonction privée g(), qui sert d’interface, et non directement. Rien ne l’empêche néanmoins si ce n’est le code de bonne pratique.

En réalité, cette notion de classe amie est une généralisation des fonctions amies. On peut très bien avoir une fonction membre d’une classe ou une fonction globale à laquelle une classe accorderait l’accès à ses données privées. Le principe est le même que pour une classe.

class A
{
  public:
    int f();

class B
{
  private:
    friend int global_func();
    friend void A::f();
    int x;
};

int A::f()
{
  B b;
  return b.x;
}

int global_func()
{
  B b;
  return b.x;
}

Notez également que les déclarations d’amis peuvent être faites tant dans la partie privée que publique de la classe. Il n’y a aucune différence entre les deux.