OpenLLM-France/wikimedia huggingface dataset:
# Programmation C-C++/Arithmétique des pointeurs

Ce livre est en cours de copie depuis le site http://casteyde.christian.free.fr/online/cours_cpp/ qui le fournit sous licence GFDL.
Cours de C/C++ :
| Pointeurs et références ||
| | Notion d'adresse |
| | Notion de pointeur |
| | Référencement, indirection |
| | Notion de référence |
| | Lien entre les pointeurs et les références |
| | Passage de paramètres par variable ou par valeur |
| | Références et pointeurs constants et volatiles |
| | Arithmétique des pointeurs |
| | Utilisation des pointeurs avec les tableaux |
| | Les chaînes de caractères : pointeurs et tableaux à la fois ! |
| | Allocation dynamique de mémoire |
| | Pointeurs et références de fonctions |
| | Paramètres de la fonction main - ligne de commande |
| | DANGER |
| Livre original de C. Casteyde ||
Il est possible d'effectuer des opérations arithmétiques sur les pointeurs.
Les seules opérations valides sont les opérations externes (addition et soustraction des entiers) et la soustraction de pointeurs. Elles sont définies comme suit (la soustraction d'un entier est considérée comme l'addition d'un entier négatif) :
et :
Si p est un pointeur d'entier, p+1 est donc le pointeur sur l'entier qui suit immédiatement celui pointé par p. On retiendra surtout que l'entier qu'on additionne au pointeur est multiplié par la taille de l'élément pointé pour obtenir la nouvelle adresse.
Le type du résultat de la soustraction de deux pointeurs est très dépendant de la machine cible et du modèle mémoire du programme. En général, on ne pourra jamais supposer que la soustraction de deux pointeurs est un entier (que les chevronnés du C me pardonnent, mais c'est une erreur très grave). En effet, ce type peut être insuffisant pour stocker des adresses (une machine peut avoir des adresses sur 64 bits et des données sur 32 bits). Pour résoudre ce problème, le fichier d'en-tête stdlib.h contient la définition du type à utiliser pour la différence de deux pointeurs. Ce type est nommé ptrdiff_t.

### Exemple 4-10. Arithmétique des pointeurs

Il est possible de connaître la taille d'un élément en caractères en utilisant l'opérateur sizeof. Il a la syntaxe d'une fonction :
Il attend soit un type, soit une expression. La valeur retournée est soit la taille du type en caractères, soit celle du type de l'expression. Dans le cas des tableaux, il renvoie la taille totale du tableau. Si son argument est une expression, celle-ci n'est pas évaluée (donc si il contient un appel à une fonction, celle-ci n'est pas appelée). Par exemple :
renvoie la taille d'un entier en caractères, et :
renvoie la même taille, car 2+3 est de type entier. 2+3 n'est pas calculé.
# Programmation C++/Opérateurs

* Avant-propos
* Introduction
* Compilation
* Un premier programme
* Les commentaires
* Le préprocesseur
* Les types de base et les déclarations
** Exercices
* Les opérations de base
* Les entrées-sorties
* Les pointeurs
** Exercices
* Les références
* Les tableaux
** Exercices
** Exercices sur les tableaux statiques
** Exercice : Tris des tableaux à une dimension
** Solution : Tris des tableaux à une dimension
* Les structures de contrôle
** Exercices
** Exercices if...else et switch
* Les fonctions
** Exercices
* Les structures
** Exercices
* Les classes
** Exercices
** Exercices de développement
* Les espaces de noms
* Les exceptions
* Les templates
** Exercices
* Conventions d'appel
* Les fichiers
* La librairie standard
* Expressions rationnelles
* Interfaces graphiques
* Bibliographie et liens

## Anciennes pages

* Opérateurs
* Héritage
* Polymorphisme
* Avant-propos
* Introduction
* Compilation
* Un premier programme
* Les commentaires
* Le préprocesseur
* Les types de base et les déclarations
** Exercices
* Les opérations de base
* Les entrées-sorties
* Les pointeurs
** Exercices
* Les références
* Les tableaux
** Exercices
** Exercices sur les tableaux statiques
** Exercice : Tris des tableaux à une dimension
** Solution : Tris des tableaux à une dimension
* Les structures de contrôle
** Exercices
** Exercices if...else et switch
* Les fonctions
** Exercices
* Les structures
** Exercices
* Les classes
** Exercices
** Exercices de développement
* Les espaces de noms
* Les exceptions
* Les templates
** Exercices
* Conventions d'appel
* Les fichiers
* La librairie standard
* Expressions rationnelles
* Interfaces graphiques
* Bibliographie et liens

## Anciennes pages

* Opérateurs
* Héritage
* Polymorphisme
[ Modifier le sommaire ]
On peut facilement utiliser des opérateurs sur une ou des classes. Prenons un exemple très simple: La classe Q (nombre rationnel)!
Voilà ! Il est en effet bien pratique d'avoir une classe Q qui permet de stocker des nombres rationnels, mais elle n'est pas très utile, si l'on ne peut pas faire d'opération avec ces objets. L'exemple ci-dessus montre comment il est possible d'utiliser l'opérateur + entre deux objets de la classe Q (nombre rationnel).
# Programmation C++/Polymorphisme

* Avant-propos
* Introduction
* Compilation
* Un premier programme
* Les commentaires
* Le préprocesseur
* Les types de base et les déclarations
** Exercices
* Les opérations de base
* Les entrées-sorties
* Les pointeurs
** Exercices
* Les références
* Les tableaux
** Exercices
** Exercices sur les tableaux statiques
** Exercice : Tris des tableaux à une dimension
** Solution : Tris des tableaux à une dimension
* Les structures de contrôle
** Exercices
** Exercices if...else et switch
* Les fonctions
** Exercices
* Les structures
** Exercices
* Les classes
** Exercices
** Exercices de développement
* Les espaces de noms
* Les exceptions
* Les templates
** Exercices
* Conventions d'appel
* Les fichiers
* La librairie standard
* Expressions rationnelles
* Interfaces graphiques
* Bibliographie et liens

## Anciennes pages

* Opérateurs
* Héritage
* Polymorphisme
* Avant-propos
* Introduction
* Compilation
* Un premier programme
* Les commentaires
* Le préprocesseur
* Les types de base et les déclarations
** Exercices
* Les opérations de base
* Les entrées-sorties
* Les pointeurs
** Exercices
* Les références
* Les tableaux
** Exercices
** Exercices sur les tableaux statiques
** Exercice : Tris des tableaux à une dimension
** Solution : Tris des tableaux à une dimension
* Les structures de contrôle
** Exercices
** Exercices if...else et switch
* Les fonctions
** Exercices
* Les structures
** Exercices
* Les classes
** Exercices
** Exercices de développement
* Les espaces de noms
* Les exceptions
* Les templates
** Exercices
* Conventions d'appel
* Les fichiers
* La librairie standard
* Expressions rationnelles
* Interfaces graphiques
* Bibliographie et liens

## Anciennes pages

* Opérateurs
* Héritage
* Polymorphisme
[ Modifier le sommaire ]

## Polymorphisme

Le polymorphisme est une fonctionnalité de l'héritage : la capacité d'appeler une méthode en fonction du type réel d'un objet (sa classe).

## Exemple

Soit une classe A implémentée de la manière suivante :
La méthode statique sort effectue le tri du tableau en appelant la méthode compare.
Soit une classe B héritant de A, ayant un critère supplémentaire de comparaison. Il faut donc une nouvelle version de la méthode de comparaison :

## Problème

Si on a un tableau de pointeur sur des objets B, la méthode compare appelée par la fonction de tri est celle de la classe A, car la fonction a pour paramètre un tableau de pointeur sur des objets A. Ce comportement n'est pas polymorphique.

## Solution

Pour que la méthode appelée soit celle de la classe B, il faut qu'elle soit déclarée virtuelle (virtual) dans la classe de base :
La fonction de tri appellera alors la méthode selon le type réel des objets, même en utilisant un pointeur sur des objets A.
En fait, le compilateur construit une table des fonctions virtuelles pour les classes A et B et les autres sous-classes, et chaque objet créé possède un pointeur vers cette table.
# Programmation C++/Sommaire

* Avant-propos
* Introduction
* Compilation
* Un premier programme
* Les commentaires
* Le préprocesseur
* Les types de base et les déclarations
** Exercices
* Les opérations de base
* Les entrées-sorties
* Les pointeurs
** Exercices
* Les références
* Les tableaux
** Exercices
** Exercices sur les tableaux statiques
** Exercice : Tris des tableaux à une dimension
** Solution : Tris des tableaux à une dimension
* Les structures de contrôle
** Exercices
** Exercices if...else et switch
* Les fonctions
** Exercices
* Les structures
** Exercices
* Les classes
** Exercices
** Exercices de développement
* Les espaces de noms
* Les exceptions
* Les templates
** Exercices
* Conventions d'appel
* Les fichiers
* La librairie standard
* Expressions rationnelles
* Interfaces graphiques
* Bibliographie et liens

## Anciennes pages

* Opérateurs
* Héritage
* Polymorphisme
# Physique et mathématiques visuelles/La chaleur

Un barreau initialement froid est chauffé à l'une de ses extrémités. On suppose que ses parois latérales sont thermiquement isolées. La chaleur diffuse sur la longueur du barreau :
La ligne noire représente la température.
# Physique et mathématiques visuelles/Comment contribuer

Sur cette page chacun peut écrire comment il invite les autres à participer.
Les images et les films peuvent être accompagnés, ou non, de commentaires qui les précèdent ou qui les suivent. S'il y a un conflit entre éditeurs, l'auteur de l'image ou du film décide librement s'il accepte ou non les commentaires.
La couverture du livre sera décidée par voie d'élection.
Pour faire un film, il suffit d'écrire le scénario. La machine s'occupe du tournage.
Si votre machine n'est pas assez puissante pour tourner vos scénarios. Vous pouvez demander de l'aide :

## 3D

Pour la 3D, Blender est au top. Il suffit de savoir écrire le scénario en Python.

## 2D

Avec la 2D, le scénariste est maître de la couleur et de la luminosité (en général trois nombres entre 0 et 255) de chaque pixel de chaque image.
# Physique et mathématiques visuelles/L'attracteur de Chua

Le système de Chua est un système de trois équations différentielles ordinaires (Differential equations, dynamical systems and an introduction to chaos, Hirsch, Morris William., Smale, Stephen, Devaney, Robert Luke, 2004):
* dx/dt = a(y - x$^3$/16 + x/6)
* dy/dt = x - y + z
* dz/dt = -by
Par exemple b=28 et a =15.4
C'est un flot déterministe à trois dimensions :
Toutes les trajectoires convergent vers un attracteur :
C'est un attracteur étrange parce qu'il est chaotique. Un point mobile circule sur le 8 d'une façon qui semble désordonnée : quelques tours sur la partie gauche du 8 puis quelques tours sur la partie droite et ainsi de suite, mais le nombre de tours sur chaque partie est imprédictible.
Un zoom sur l'attracteur de Chua:
L'attracteur varie en fonction du paramètre a :
# Physique et mathématiques visuelles

Pythagore et l'origine de l'harmonie
La lumière
Gravitation
Relativité
Dynamique des fluides
Les structures cristallines
Physique quantique
La chaleur
L'attracteur de Chua
La percolation
Les vibrations
Les ondes de choc

## Voir aussi

* First lesson in mathematical painting
* Électricité et magnétisme
* Théorie quantique de l'observation
* Les principes de la science
# Programmation GTK/Sommaire

* Introduction
* Bien débuter
** « Bonjour tout le monde » en GTK
** Compilation de « Bonjour tout le monde »
** Théorie des signaux et des rappels
** « Bonjour tout le monde » pas à pas
** Types de données
** Compléments sur les gestionnaires de signaux
** Un « Bonjour tout le monde » amélioré
* Placement des widgets
** Théorie des boîtes de placement
** Détails sur les boîtes
** Programme de démonstration des placements
** Placement avec les tables
** Exemple de placement avec table
* Vue d'ensemble des widgets
** Conversions de types
** La hiérarchie des widgets
** Widgets sans fenêtre
* Widgets boutons
** Boutons normaux
** Boutons commutateurs
** Cases à cocher
** Boutons radio
* Widgets divers
** Labels
** Le widget bulle d'aide
** Barres de progression
** Boîtes de dialogue
** Pixmaps
* Widgets containers
** Bloc-notes
** Fenêtres avec barres de défilement
* Widgets listes
** Signaux
** Fonctions
** Exemple
** Widget item de liste
* Widgets de sélections de fichiers
* Widgets Menu
** Création manuelle de menus
** Exemple de menu manuel
** Utilisation de GtkMenuFactory
** Exemple d'usine à menu
* Widgets non documentes
** Entrées de texte
** Sélections de couleurs
** Contrôle d'intervalle
** Règles
** Boîtes de texte
** Prévisualisation
** Courbes
* Widget EventBox
* Configuration des attributs de widget
* Temporisations, fonctions d'E/S et d'attente
** Temporisations
** Surveillance des E/S
** Fonctions d'attente
* Gestion des sélections
** Introduction
** Récupération de la sélection
** Fournir la sélection
* glib
** Définitions
** Listes doublement chaînées
** Listes simplement chaînées
** Gestion de la mémoire
** Timers
** Gestion des chaînes
** Utilitaires et fonctions d'erreurs
* Fichiers rc de GTK
** Fonctions pour les fichiers rc
** Format des fichiers rc de GTK
** Exemple de fichier rc
* Écriture de vos propres widgets
** Vue d'ensemble
** Anatomie d'un widget
** Création d'un widget composé
** Création d'un widget à partir de zéro
** En savoir plus
* Scribble, un programme simple de dessin
** Présentation
** Gestion d'événement
** Le widget DrawingArea et le dessin
** Ajouter le support XInput
* Conseils pour l'écriture d'applications GTK
* Contributions
* Remerciements
* Copyright
# PyQt/QTextEdit
## Description

QTextEdit est un widget très puissant mettant à disposition une zone d'édition de texte d'une page supportant du contenu mis en forme. Il a été créé dans le but d'être le plus efficace possible, même avec beaucoup de contenu, et répondre le plus rapidement possible aux actions de l'utilisateur. Il fonctionne principalement selon 4 modes :
* éditeur de texte standard : texte standard sans mise en forme ; même si le texte contient des balises de mise en forme, lors de la lecture du contenu du widget les balises sont supprimées ;
* éditeur de texte avec mise en forme : texte supportant la mise en forme ;
* afficheur de texte : dans ce mode il n'est pas possible de modifier le texte, seulement de le consulter ;
* afficheur de fichiers logs : ce mode est identique à l'affichage de texte, seule la mise en forme du texte est désactivée.
Vu la quantité assez importante de méthodes et de fonctionnements nous ne pouvons que vous conseiller de consulter la documentation de référence disponible à l'adresse http://doc.trolltech.com/3.3/qtextedit.html.

## Exemple

* PyQt3.*
* #!/usr/bin/python
* # -*- coding : utf-8 -*-
* # qtextedit.py
* # Programme exemple pour la classe QTextEdit
* from qt import *
* import sys
* class Demo(QApplication) :
* def init (self, args) :
* QApplication. init (self,args)
* # zone d'édition de texte comme widget principal
* self.textedit = QTextEdit
* self.textedit.resize(640,480)
* # dialogue d'ouverture de fichier
* s = QFileDialog.getOpenFileName("", "", None,
* "Boite d'ouverture de fichier", "Choisissez un fichier")
* self.file = QFile (s)
* # essaie d'ouvrir le fichier et de le charger
* if self.file.open(IO ReadOnly) :
* self.stream = QTextStream(self.file)
* self.textedit.setText(self.stream.read)
* else :
* print "Impossible d'ouvrir le fichier " + self.file
* b = QMessageDialog.warning(None, "Erreur",
* "Impossible d'ouvrir le fichier sélectionné", QMessageBox.Ok)
* exit(-1)
* self.textedit.show
* self.connect(self,SIGNAL("lastWindowClosed"),self,SLOT("quit"))
* self.exec loop
* if name == "__main__" :
* app=Demo(sys.argv)
* PyQt4.*
* #!/usr/bin/python
* # -*- coding : utf-8 -*-
* # qtextedit.py
* # Programme exemple pour la classe QTextEdit
* import os, sys
* from PyQt4.QtCore import *
* from PyQt4.QtGui import *
* class MyWindow(QWidget):
* def __init__(self, *args):
* QWidget.__init__(self, *args)
* label = QLabel(self.tr(u'Entrer une commande Shell et presser Entrée'))
* self.LineEdit = QLineEdit
* self.TextEdit = QTextEdit
* vbox = QVBoxLayout(self)
* vbox.addWidget(label)
* vbox.addWidget(self.LineEdit)
* vbox.addWidget(self.TextEdit)
* self.setLayout(vbox)
* # create connection
* self.connect(self.LineEdit, SIGNAL("returnPressed(void)"),self.run_command)
* def run_command(self):
* cmd = str(self.LineEdit.text)
* stdouterr = os.popen4(cmd)[1].read
* self.TextEdit.setText(stdouterr)
* if __name__ == "__main__":
* app = QApplication(sys.argv)
* w = MyWindow
* w.show
* sys.exit(app.exec_)

## Références

* http://www.saltycrane.com/blog/2007/12/pyqt-example-how-to-run-command-and/
# PyQt/Quelques explications

Ce premier exemple permet d'introduire quelques concepts de base.

## Importation des librairies

En premier lieu, il faut indiquer à Python d'importer les librairies PyQt et sys. Ceci est fait avec les lignes suivantes :

## La méthode main

Nous définissons ensuite une méthode main qui s'occupera de gérer l'ensemble du programme. Cette méthode crée en premier lieu une instance de QApplication. Cette instance représente l'ensemble de notre application, par conséquent elle est essentielle et doit rester unique pour assurer un fonctionnement correct. Toute application PyQt est constituée d'un objet de type QApplication. Par conséquent, une application débute toujours par la création d'un objet de la classe QApplication :
Veuillez noter toutefois que si vous développez une classe dans laquelle la référence vers QApplication n'est pas disponible (typiquement lors de la création de votre propre widget), Qt met à disposition la variable qApp fournissant une référence vers l'application Qt. Vous pouvez donc sans autre utiliser cette variable dans votre code.

## Création d'un bouton

Un bouton est un objet de la classe QPushButton créé comme tout autre objet par l'appel de son constructeur :
Les widgets ne sont pas visibles lors de leur création, c'est pourquoi la méthode show de la classe QWidget est appliquée à l'objet button afin de le rendre visible. Néanmoins, si vous déclarez un widget comme enfant d'un autre, un appel à show sur le parent affichera automatiquement tous ses enfants.

## Gestion des évènements

L'exemple utilise deux événements : l'application quitte lorsque l'utilisateur clique sur le bouton précédemment défini ou lorsqu'il ferme la fenêtre. La méthode statique connect de la classe QObject établit une communication unidirectionnelle entre deux objets. À chaque objet de la classe QObject ou de ses classes dérivées, peuvent être associés des signaux permettant d'envoyer des messages et des slots permettant de recevoir des messages. De manière plus rigoureuse, un slot correspond à tout élément pouvant être appelé tandis qu'un signal est le message qui est passé entre objets. Le fonctionnement est le suivant : les objets héritant de QObject émettent des signaux quand ils reçoivent des événements. Ces signaux peuvent être connectés à des slots, qui sont donc appelés automatiquement quand l'objet reçoit un événement donné. L'objet émetteur du signal ne se soucie pas de l'existence d'un objet susceptible de recevoir son signal. Cela assure une bonne encapsulation ainsi qu'un mécanisme modulaire. Un même signal peut être connecté à plusieurs slots, tout comme plusieurs signaux peuvent viser le même slot. Dans le cas de notre exemple, deux signaux sont connectés au même slot :
Les signaux « lastWindowClosed » de l'objet app et « clicked » de l'objet button sont tous deux connectés au slot « quit » par l'appel à la méthode connect. Lorsque les widgets sont définis, la méthode exec_ de la classe QApplication met en place la boucle d'événements. C'est grâce à cette boucle (infinie) que l'application va fonctionner et que les divers événements auront le comportement voulu.
# PyQt/Quelques widgets

Ce chapitre nous permet d'introduire quelques widgets que nous considérons comme important de connaître.
L'ensemble des classes disponibles dans Qt peut être divisé en trois grands groupes :
* Les classes permettant d'obtenir des widgets graphiques.
* Les classes abstraites telles que les actions utilisateurs, les minuteries, etc.
* Les classes d'utilitaires permettant par exemple la connexion à une base de données, le traitement de documents XML, etc.
Nous allons commencer cette documentation par trois widgets relativement important, QApplication, QDialog et QMainWindow. Ces widgets représentent respectivement une application Qt complète, une boîte de dialogue et une fenêtre principale. Dans la plupart des guides existants on ne vous parle pas de ces widgets malgré leur importance dans la conception d'une application Qt. C'est pourquoi nous avons décidé de les documenter ici avec des widgets plus graphiques.

## Références

* ↑ (anglais) http://web.archive.org/web/20040306175723/http://doc.trolltech.com/3.3/
* ↑ (anglais) http://www.riverbankcomputing.co.uk/software/pyqt/intro
* ↑ (anglais) http://web.archive.org/web/20031226134522/http://doc.trolltech.com/3.3/classchart.html

## Voir aussi

* Liste des classes
# PyQt/Signaux et slots

Les signaux et les slots sont utilisés pour la communication entre les objets. Le mécanisme de signaux/slots est l’une des caractéristiques principales de Qt et PyQt qui les différencie des autres outils de développement.
Dans Qt comme dans PyQt, un signal est émis par un widget lorsqu’un événement se produit. Ces événements sont généralement le fait d’un utilisateur qui cliquerait par exemple sur un bouton ou qui remplirait un champ. Les slots sont des fonctions appelées en réponse à un signal particulier.
Ainsi en résumé, un objet héritant de QObject peut émettre des signaux quand il reçoit des événements comme un clic sur un bouton. Les signaux peuvent être connectés à des slots. Un slot est une fonction membre (« méthode ») appelée automatiquement.
Pour plus d’informations, la page de référence fournit de plus amples détails : http://doc.trolltech.com/3.3/signalsandslots.html.
# PyQt/Sommaire
## Introduction

* Avant-propos
* Problématique
* Présentation de la librairie

## Installation

* Installation
** Linux
** MacosX
** Windows

## Concepts de base

* Premier exemple : Hello World !
* Quelques explications
* Approche orientée objet
* Signaux et slots
* Positionnement des éléments graphiques
* Gestion du focus

## Quelques widgets

* Quelques widgets
* QApplication
* QDialog
* QMainWindow
* QAction & QActionGroup
* QLabel
* QCheckBox
* QRadioButton
* QComboBox
* QPushButton
* QPopupMenu
* QLineEdit
* QTextEdit

## Utilisation de Qt Designer

* Utilisation de Qt Designer
* Création d'une liste de commission

## Guide de traduction de Qt à PyQt

* Traduction de Qt à PyQt

## Annexes

* Bibliographie
* PyQt versus wxPython
# PyQt/Utilisation de Qt Designer

La librairie Qt vient aussi avec une application graphique permettant de définir rapidement et simplement son interface. La plupart des propriétés des éléments sont directement modifiables avec cette application, ainsi que la définition des signaux et des slots. Il est ensuite très simple de générer du code C++ pour l’interface. Comme nous le verrons ci-dessous, il est aussi tout à fait possible de générer du code Python.
Nous ne pouvons que vous conseiller d’utiliser cet outil. En effet, non seulement il offre une vue d’ensemble de tous les widgets disponibles, mais il permet en plus de modifier facilement leurs propriétés et leur mise en page. Comme nous l’avons vu précédemment, effectuer le placement des éléments à la main est quelque peu laborieux.
# Wikipédia:AutoWikiBrowser

w:Aide:AutoWikiBrowser Cette page est une redirection douce.
# Wikipédia/Utiliser Wikipédia

De nombreux visiteurs font une utilisation instantanée de Wikipédia : ils sont dirigés sur l’encyclopédie par un moteur de recherche, copient une information et ne vont pas plus loin. La nature ouverte de Wikipédia nécessite pourtant de comprendre son fonctionnement afin d’être conscient de ses limites et d’adopter une attitude critique face à l’information. Cette partie est destinée au lecteur occasionnel ou assidu de Wikipédia, qui souhaite optimiser l’utilisation de cet outil.