int main(int argc, char ** argv) { QgsApplication…" /> int main(int argc, char ** argv) { QgsApplication…" />
Suite

Exemple de plantage de QGIS C++ Hello World


J'ai écrit une application C++/Qt très simple à l'aide de QGIS composée d'un seul fichier "main.cpp" comme ci-dessous :

#comprendre  int main(int argc, char ** argv) { QgsApplication app(argc, argv, true); renvoie 0 ; }

et mon fichier de projet Qt Creator est défini comme :

QT += core gui GreaterThan(QT_MAJOR_VERSION, 4) : QT += widgets TARGET = qgis_test TEMPLATE = app CONFIG += c++11 SOURCES += main.cpp HEADERS += LIBS += -L/usr/local/lib - lqgis_core QGIS_DIR = /home/rouhollah/Programs/qgis-2.8.1 INCLUDEPATH += $$QGIS_DIR INCLUDEPATH += $$QGIS_DIR/src/core DEFINES += CORE_EXPORT= GUI_EXPORT=

Le programme est compilé et lié, mais se ferme de manière inattendue lorsqu'il est exécuté avec le message d'erreur suivant :

realloc() : pointeur invalide : 0x00007fc3d802e0e0

Même en exécutant le programme en mode Débogage, le débogueur s'arrête avant d'atteindre le point d'arrêt à la première ligne duprincipaleune fonction.

Notez que j'ai installé les bibliothèques QGIS en compilant les codes sources obtenus à partir de GitHub.


Après des heures à essayer tout ce à quoi je pouvais penser, j'ai finalement découvert que QGIS n'était pas compatible avec Qt 5.4. Par conséquent, j'ai réussi à exécuter un exemple de programme compilé et lié à Qt 4.8.6.


Pour tous Questions et observations concernant Cygwin, veuillez consulter les ressources disponibles sur ce site, telles que la FAQ, le Guide de l'utilisateur et les archives de la liste de diffusion. Si vous avez épuisé ces ressources, veuillez envoyer un e-mail à un liste de diffusion appropriée. Cela inclut des observations sur les pages Web, des questions de configuration, des questions sur l'endroit où trouver des choses, des questions sur les raisons pour lesquelles les choses sont faites d'une certaine manière, des questions sur les préférences de couleur des développeurs Cygwin, des questions sur la signification du nombre 42, etc.

Veuillez envoyer une notification de problèmes techniques (mauvais code HTML, liens brisés) concernant ces pages Web à la liste de diffusion Cygwin.

S'il te plaît ne pas envoyer un e-mail personnel avec des "questions rapides" aux contributeurs individuels de Cygwin. Les listes de diffusion Cygwin sont les endroits pour toutes les questions. Vraiment. Je suis sérieux.

Cygwin 32 bits

L'espace d'adressage est un facteur très limitatif pour Cygwin. De nos jours, une distribution Cygwin 32 bits complète n'est plus réalisable et échouera vraisemblablement à des endroits aléatoires en raison d'un problème avec l'appel système fork(2).

Par conséquent, nous vous recommandons d'utiliser Cygwin 32 bits uniquement dans des scénarios limités, avec seulement un minimum de packages nécessaires installés, et uniquement s'il n'y a aucun moyen d'exécuter Cygwin 64 bits à la place.

Tu étais prévenu. Si vous êtes toujours sûr d'avoir vraiment besoin d'un Cygwin 32 bits, et qu'il n'y a absolument aucun moyen de le contourner, vous pouvez exécuter le programme d'installation setup-x86.exe.

La DLL et les utilitaires Cygwin sont Copyright © auteurs Cygwin. D'autres packages ont d'autres droits d'auteur.
UNIX ® est une marque déposée d'Open Group aux États-Unis et dans d'autres pays.


Je ne connais pas grand-chose aux sockets, mais voici quelques commentaires généraux sur la programmation C :

  • Vous ne libérez jamais () la mémoire malloc'd de la ressource . Et si vous le faisiez, ce que vous devriez faire, alors resource="/" planterait le programme lorsque vous tenteriez de libérer () cette mémoire.

Bogues possibles

char ipstr[INET6_ADDRSTRLEN] Déclarer un tableau avec la taille d'une "longueur de chaîne" est louche. Êtes-vous sûr que cela alloue suffisamment de place pour un caractère de fin de chaîne nul ?

(char*)malloc Il n'y a jamais de raison de convertir le résultat de malloc en C. Il est même potentiellement dangereux en C90. Vous pouvez trouver d'innombrables sujets à ce sujet sur Stack Overflow.

Détails pointilleux et style de codage

Il est toujours préférable de déclarer chaque variable sur une ligne seule, pour rendre le code plus lisible et pour éviter les bogues comme int* ptr1, ptr2 // ptr2 n'est pas un pointeur comme prévu .


Il a été commenté que lorsque vous travaillez en C++, vous devez utiliser std::string . En supposant que vous souhaitiez rester avec des chaînes de style C (ou au moins comprendre comment vous devriez travailler avec elles, au cas où vous en auriez besoin), j'ai les suggestions suivantes :

tit peut être plus grand que le titre du tampon ne le permet.[1] Dans ce cas, votre programme plantera ou pire, continuera à s'exécuter tout en corrompant une autre partie de la mémoire. Pour éviter cela, vous devez toujours utiliser des fonctions qui vous permettent de suivre la taille du tampon de destination et de détecter les débordements. Par exemple:

Cela a des caractéristiques indésirables en ce sens qu'il tronquera silencieusement la chaîne si l'entrée est plus grande que la destination. Si vous travaillez sur un système qui a le strlcpy non standard , cela a des conditions d'erreur plus claires :

En vous déplaçant le long du spectre (du code qui plante avec une entrée importante, au code qui tronque l'entrée, au code qui génère des erreurs lorsque le tampon est insuffisant. ), vous souhaiterez peut-être également allouer dynamiquement de la mémoire pour cela.

Cela crée des complications si un objet Book est copié, vous devez donc gérer cela :

Et il doit être libéré lorsque votre objet est détruit :

Si cela semble trop compliqué, c'est parce que c'est probablement le cas pour le code C++ de niveau supérieur. std::string s'occupera de tout cela pour vous. Notez cependant que la disposition de la mémoire de votre objet sera sensiblement différente avec ces approches de mémoire dynamique.[2]

En règle générale, devoir faire des lancers comme celui-ci est souvent un indicateur que vous faites quelque chose de mal. :-) Lorsque j'écris du code et que je révise le travail des autres, j'ai tendance à essayer d'éviter autant de moulages inutiles que possible. Souvent, ces bogues de masque, par exemple la conversion d'une fonction en un type de pointeur de fonction incorrect, peuvent produire des plantages, ou la suppression de const peut planter lorsque quelqu'un essaie de modifier un tampon en lecture seule. Pour des raisons comme celle-ci, c'est une bonne habitude de surveiller les distributions inappropriées lors de la lecture du code, et assurez-vous de ne pas les présenter vous-même. offenser votre sensibilité. :-) [3]

Dans votre cas, le problème est que les littéraux de chaîne ont le type const char* , donc le compilateur se plaint que vous passez cela à quelque chose qui n'a pas const . Donc ce que vous devez faire ici est :

Notes de bas de page et commentaires tangentiels :
[1] S'il y a des anglophones qui pourraient lire votre code, je vous suggère de trouver un meilleur nom que tit pour cette variable.
[2] Dans l'exemple précédent, les caractères du titre existent aux côtés de tous les autres membres de la classe. Lors de l'utilisation de la mémoire dynamique, il y a maintenant un déréférencement de pointeur supplémentaire pour accéder aux caractères. Dans la plupart des cas, cela ne fera pas de différence, mais vous pouvez penser à des cas théoriques où le premier est préféré au second.
[3] Note latérale : D'après mon expérience, une façon de dire que quelqu'un ne sait pas ce qu'il fait en C/C++ est d'utiliser des transtypages. Un programmeur bâclé écrira du code que le compilateur rejette, puis pour le faire "fonctionner" rapidement, il introduira des transtypages pour faire taire les avertissements du compilateur au lieu de résoudre le problème réel. Si vous travaillez dans une équipe où les gens font cela, je trouve que c'est parfois une bonne indication d'être sceptique quant au travail de cette personne pour d'autres raisons.


17 réponses 17

Je pense que vous devriez commencer par les types de données que le langage a intégrés, comme les tableaux et les pointeurs, et lorsque vos étudiants les comprennent, passez aux classes et à OO, puis à la STL.

La raison en est que vous pouvez apprendre aux gens à comprendre les tableaux sans comprendre grand-chose d'autre que les variables et l'architecture informatique sous-jacente, mais vous ne pouvez pas leur apprendre à comprendre le vecteur sans leur enseigner d'abord des cours. Si vous utilisez la STL dès le départ, vos étudiants devront simplement vivre sans avoir la moindre idée du fonctionnement exact du vecteur. Et puis quand vous arriverez à ce point, ils n'auront pas une assez bonne compréhension des pointeurs et des tableaux et des choses que vous obtenez en faisant des choses comme écrire votre propre classe vectorielle, écrire votre propre classe de liste chaînée, etc. qui seront nécessaires d'apprécier et d'exploiter ses caractéristiques. Cela m'agace quand les élèves disent "qu'est-ce que c'est que ça ?" et les enseignants disent « ignorez-le, vous l'apprendrez plus tard ».

Et comme Demian souligné dans les commentaires, déchiffrer les messages relativement cryptiques que vous obtenez à partir d'erreurs de modèle est beaucoup plus difficile que de comprendre les erreurs que vous pouvez obtenir à partir de tableaux / constructions sans modèle.

Je ne ressens pas la même chose à propos de cout et printf . Ni l'un ni l'autre n'est de niveau inférieur à l'autre, sauf que cout utilise la surcharge d'opérateur.

Cela peut sembler stupide, mais je suis absolument fanatique faire comprendre aux gens les éléments de base très tout avant de passer aux abstractions. Vous ne devriez pas utiliser de pointeurs intelligents tant que vous ne maîtrisez pas les pointeurs bruts, pas de vecteurs avant les tableaux, ce genre de choses.

Je le dis souvent, mais je le répète : il vaut mieux enseigner aux élèves la division longue d'abord et ensuite les laisser utiliser une calculatrice que de les laisser utiliser une calculatrice puis leur apprendre la division longue ensuite.

En ce qui concerne les livres pour enseigner aux débutants, consultez la liste principale des bons livres C++.

C'est ma propre expérience. Prenez-le pour ce qu'il vaut.

En repensant à l'époque où j'ai commencé à programmer, j'aurais vraiment aimé avoir appris la mémoire première. Non, ce n'est pas excitant. Cela vous fera glacer. Mais c'est un concept ridiculement facile à enseigner. Montrez simplement un tableau 1D et faites-leur faire quelques exercices mentaux :

Leçon 1:
Il s'agit de 10 octets de mémoire. Il s'agit de la lettre "a" insérée dans la cellule numéro 3. "a" est la valeur et 3 est l'adresse. D'ACCORD? C'est le numéro 3 qui est mis dans la cellule 5. Sa valeur est 3 et son adresse est 5. Maintenant que peut signifier le numéro 3 ? Eh bien, cela pourrait être juste un numéro 3 -ou- cela pourrait être une référence à adresse 3. Tout comme 1 peut être un nombre ou un code de pays. Ce n'est qu'un nombre, tout dépend de la façon dont nous le traitons.

Leçon 2:
Apprenons à compter en binaire. Comptons jusqu'à 10 en utilisant le comptage binaire des doigts. Intéressant non ? Vous voyez comment cela n'avait besoin que de 4 doigts ? On dit donc que seuls 4 bits sont nécessaires (1/2 cellule). Quelle est la valeur la plus élevée sur laquelle vous pouvez compter d'une part (la réponse est 31). Que diriez-vous de 2 mains (la réponse est 1023). Expliquez comment plus de bits signifie des plages de nombres plus élevées. Rappelez-leur qu'une cellule mémoire est de 8 bits. Demandez ce qui se passe lorsqu'un nombre a besoin de plus de 8 bits. Comment mettraient-ils un nombre multi-octets en mémoire (de manière logique) ? Présentez-leur les caractères, les courts, les entiers et les longs.

Lecon 3:
Voici un programme que j'ai écrit en C++. Il utilise des entiers 32 bits. Et c'est ici également un numéro. Mais c'est un nombre utilisé pour pointer. En utilisant ce petit astérisque, nous promettons que le numéro sera utilisé pour le pointage. Et voici comment nous le pointons sur le premier numéro. La petite esperluette remplit la valeur pour nous. Bien, hein ?

etc. Une fois que vous avez réduit la mémoire de base, tout le reste est du gâteau. Ce sont les pauvres étudiants qui supposent que le compilateur fait quelque chose de magique (ou qu'ils n'ont jamais à penser à la gestion de la mémoire) qui ont tendance à avoir le plus de difficultés. Et C++ brouille les cartes parce que certaines choses sont automatiquement nettoyées (c'est-à-dire un vecteur normal) tandis que d'autres ne le sont pas (c'est-à-dire un vecteur alloué en utilisant "new"). Et ne me lancez même pas sur les chaînes (char* contre std::string -- essayez d'expliquer cela sans connaissance du pointeur).

Je ne sais pas quelle plate-forme votre compétition de robots ciblera, mais s'il s'agit d'un environnement à mémoire limitée, les compétences en gestion de la mémoire sont cruciales.

Une fois que vous leur avez appris les bases, alors oui, je vous dis d'aller jusqu'au bout du C++. Techniquement, ce ne sont que des bibliothèques différentes, mais oui, il ne sert à rien de les confondre avec plus d'un paradigme. Donnez-leur des outils C++ (qui incluent des pointeurs et des tableaux).

Dois-je commencer à utiliser STL dès le premier jour, en particulier. vecteur ou simplement s'en tenir aux tableaux standard ? Les tableaux sont plus faciles à introduire, mais les erreurs de pointeur peuvent être plus difficiles à détecter.

allez certainement directement dans l'utilisation des types de bibliothèque standard. un std::string ou std::vector est ce qu'ils devraient souvent utiliser et (la grande majorité des implémentations de) ces types offrent une certaine forme de détection et de gestion des erreurs, tout en faisant abstraction de la plupart des complexités des étudiants.

vous pouvez passer une bonne partie du temps à enseigner aux étudiants comment la mémoire est structurée et comment gérer la mémoire (style C), ou vous pouvez vous mettre directement au travail en utilisant les types idiomatiques du langage, puis expliquer les détails de la mise en œuvre si nécessaire (et quand ils ont un meilleure compréhension de ce qu'est un tableau et où ils sont utilisés).

la syntaxe de std::vector (création/lecture/écriture) n'est pas beaucoup plus compliquée que celle d'un tableau C. en comparaison, la gestion manuelle de la mémoire et toutes les erreurs courantes que les nouveaux apprenants commettent avec les tableaux C sont beaucoup plus difficiles à apprendre, à enseigner et à utiliser.

Pour les E/S, devrais-je m'en tenir à cout, etc. ou pensez-vous que printf serait plus facile à apprendre ?

cout. personnellement, je pense que le cout est plus facile à apprendre. peut-être plus important encore, vous devriez choisir cout car il est plus sûr, polyvalent et vous permet de définir comment un objet s'imprime, ce qui signifie que vous avez déjà des fonctionnalités intégrées et une sécurité de type en utilisant certains types de bibliothèque standard. enfin, vous vous retrouverez avec des programmes mixtes lorsque vous réaliserez qu'ils peuvent également avoir besoin d'apprendre cout en plus de printf .

en fait, je pense que vous devriez lire Accelerated C++, par Koenig et Moo et éventuellement l'utiliser pour l'instruction (répondant indirectement à la question 3). dans le livre, ils introduisent std::cout juste avant return (page 3), et enregistrent les pointeurs et les tableaux jusqu'au chapitre 10. Si je pouvais copier et coller la préface de ce livre comme réponse à votre question, je le ferais. (note : je vous recommande de le lire dans la perspective d'enseigner le c++).

Existe-t-il des ressources en ligne pour le C++ adaptées à ces jeunes apprenants ?

si vous ne voulez pas utiliser le C++ accéléré (ce qui suppose une certaine connaissance de la programmation en général), alors vous aimeriez peut-être Eckel's Thinking in C++. Je ne l'ai pas lu, mais c'est un texte d'introduction C++ librement distribué.

Une chose à considérer est que dans le code FIRST typique, les structures de données de toute forme (structs, classes, tableaux, vecteurs, listes) jouent un très petit rôle. Vous traitez généralement une très petite quantité de données de capteur et vous l'utilisez pour décider d'une très petite quantité de mouvements de l'actionneur.

Mais quoi Est-ce que jouent un rôle énorme et peuvent être très difficiles à comprendre sont toutes les différentes formes de contrôler ça continue.

Je mettrais donc beaucoup d'emphase sur le contrôle. Commencez par les bases : if , for , while . Demandez-leur de les pratiquer beaucoup. Faites-leur bien les connaître.

. mais ensuite ça devient plus dur. Tout code de robot de taille modérée finit par aboutir à des modèles de contrôle plus délicats :

Grosse boucle "principale", qui appelle tout

Machines à états (celles-ci apparaissent beaucoup)

Sauvegarde des valeurs précédentes / compteur courant (comme pour PID)

Ceux-ci sont difficiles à comprendre pour les débutants. Penser à la façon dont un programme se déplace dans un code comme celui-ci est déroutant, vous ne le réalisez peut-être pas maintenant, mais c'est le cas. Cela va poser beaucoup plus de problèmes à vos élèves que la langue elle-même.

Aussi, bonne chance! J'espère que la saison se passe bien.

  • Dois-je commencer à utiliser STL dès le premier jour, en particulier. vecteur ou simplement s'en tenir aux tableaux standard ? Les tableaux sont plus faciles à introduire, mais les erreurs de pointeur peuvent être plus difficiles à détecter.

Le problème avec les tableaux est que tout, à l'exception des exemples de manuels simples, nécessitera des tableaux de taille dynamique, et au moment où vous avez besoin de tableaux de taille dynamique, std::vector est tellement plus facile. De plus, la seule façon de gérer en toute sécurité des tableaux de taille dynamique est de les envelopper dans votre propre classe, ce qui serait une mauvaise arnaque std::vector.
Contrairement à une croyance inexplicablement populaire, les étudiants peuvent utilisation fonctionnalités qui nécessitent la mise en œuvre de mécaniques complexes sans savoir comment mettre en œuvre ces bêtes elles-mêmes. Comme je l'ai dit dans un commentaire : vous ne penseriez même pas à envisager de ne pas enseigner les chaînes dans d'autres langues, simplement parce que leur implémentation est complexe, n'est-ce pas ?

Pourquoi un ensemble de conventions de chaîne de format archaïques qui font exploser votre programme au moment où vous obtenez quelque chose de mal (ce qui se produit au moment où vous modifiez un typedef dans un en-tête apparemment sans rapport) serait préférable à la sécurité de type de std::cout ?

La plupart des ressources C++, en ligne ou non, sont mauvaises. Et je ne parle pas d'utiliser des polices ou un langage difficiles à lire. Je parle d'erreurs factuelles flagrantes. Il y a très peu de bonnes ressources C++, principalement une ou deux douzaines de livres. Le seul que je connaisse en ligne est celui de Bruce Eckel Penser en C++.

Depuis une dizaine d'années, j'enseigne le C++ à des étudiants aux parcours très différents en utilisant Koenig/Moo's C++ accéléré comme socle. Mon cours a beaucoup changé au cours de cette décennie, il est maintenant loin du livre, à l'exception du principe sous-jacent : Utilisez les idiomes modernes, corrects et sûrs dès le début. N'apprenez pas à vos élèves à manipuler manuellement la mémoire, juste pour qu'ils le désapprennent plus tard au profit d'idiomes plus sûrs. Comme vous pouvez le voir dans certaines des réponses fournies ici, cela ne fonctionne pas : ceux qui ont appris les méthodes manuelles en premier comprendront rarement l'avantage d'utiliser des idiomes modernes et sûrs.

Si vous voulez enseigner le C++, je commencerais directement avec les constructions C++ en tant que vecteur et cout, au lieu du sous-ensemble C comme printf.

Dois-je commencer à utiliser STL dès le premier jour.

Oui. L'utilisation de tableaux natifs en C++ est sujette aux erreurs et simplement à une mauvaise pratique 99% du temps.

Pour les E/S, dois-je m'en tenir à cout, etc. ?

Existe-t-il des ressources en ligne pour le C++ adaptées à ces jeunes apprenants ?

Ils ne sont pas si jeunes. Apprendre à programmer ne nécessite pas de sagesse, juste de la motivation et un esprit ouvert. Je ne peux pas penser à quoi que ce soit enseigné au cours des deux dernières années du secondaire qui préparerait mieux un élève à apprendre à programmer. Avez-vous regardé Bruce Eckel's Penser en C++? Il est disponible en téléchargement gratuit et très bien évalué. S'il vous plaît éviter le populaire mais horrible C++ : comment programmer et tous les Apprends-toi C++ de Sam. livres.

J'ai appris le C++ au lycée comme premier langage de programmation, bien qu'il a été plus comme "C+", maintenant que vous le mentionnez, nous avons utilisé cout pour écrire du texte dans la console et les fichiers, mais aussi pas mal de fonctions C ( getch() était ma préférée).

Je pense que la façon la plus efficace (et peut-être amusante) d'enseigner les bases est d'utiliser un programme axé sur les objectifs : commencez par montrer comment sortir des choses, puis saisissez des entrées au clavier, puis des E/S de fichiers simples, etc. Passez à un texte simple. basé sur un jeu (ou l'équivalent robotique). Ensuite, lorsqu'ils demandent : "Comment puis-je faire X ?", vous pouvez décomposer X en termes d'exemples qu'ils ont déjà vus, par ex. "Vous aurez d'abord besoin d'obtenir l'entrée de l'utilisateur comme nous l'avons fait dans Z, alors." graphiques 3D", mais vous pouvez toujours expliquer comment il voudrais travailler à un niveau élevé).

Les exemples que vous leur montrez commenceront par la magie du copier-coller de la boîte noire, dont les mystères se percoivent au fur et à mesure que les pièces du puzzle de programmation sont découvertes. Par exemple, vos élèves apprendront les bases de if s assez rapidement, mais ils ne se rendront probablement pas compte qu'une expression booléenne n'est pas exclusivement limitée à l'utilisation dans une condition if (conduisant au classique if (blah) return true else return faux code).

Les subtilités du choix d'un tableau ou d'un vecteur comme conteneur sembleront sans importance aux étudiants au début. Un vecteur/tableau sera simplement un moyen d'avoir beaucoup de variables en une seule variable, accessible via un index. Tenez-vous en à celui où vous le pouvez. Les pointeurs ne seront compris que plus tard non plus. Cela ne veut pas dire que vous ne devriez pas expliquer des choses simplement que vous ne pouvez pas tout expliquer à la fois, et ce que vous expliquez ne sera pas complètement absorbé. Les humains apprennent de manière organique et non linéaire. J'utilisais cout pour un couple ans avant de bien comprendre ce qu'était la surcharge d'opérateur !

Oh, et n'ayez pas peur de la répétition. « C'est comme le programme Hello World que nous avons fait – vous vous souvenez de la façon dont nous avons écrit du texte sur la console ? » (Non. ) « Revoyons-le juste pour être sûr. » . Et posez des questions ! Gardez les élèves engagés avec des exemples amusants et beaucoup d'interactions.

C++ est un langage complexe, et quoi que vous fassiez, une partie importante de cette complexité (et celle de l'art de la programmation en général) sera perdue pour vos étudiants. Tout ce que vous leur montrerez sera nouveau pour eux, la plupart ne s'intégreront pas à un niveau de compréhension profond (du moins, pas tout de suite). Comment fonctionne la mémoire, comment les composants d'un PC interagissent, ce que sont la pile et le tas, les pointeurs, les classes, même les boucles et les chaînes if-else ne sera pas bien compris par la majorité. C'est acceptable! Ils n'ont pas besoin d'être compris pour être utilisés - une quantité incroyable de programmes sympas peuvent être écrits avec des fonctions super laides de 1000 lignes avec une quintuple redondance imbriquée si s et 43 variables nommées des choses comme x_2r . L'important est que les élèves soient apprendre et s'améliorer constamment. Les boîtes noires sont bonnes tant qu'elles deviennent transparentes (ou au moins grises translucides) à long terme. À la fin du cours, ils ne savent peut-être pas ce que sont les modèles de conception, mais ils devraient être en mesure de revoir les programmes qu'ils ont écrits au cours des premières semaines et grimacer à leur code. Ils doivent comprendre à un niveau de détail significatif comment fonctionne réellement le premier programme qu'ils ont écrit (alors qu'ils n'en avaient aucune idée lorsqu'ils l'ont écrit). Mais ils ne sauront pas tout -- encore.


Obtenir un environnement de développement plus élaboré

Apportons quelques modifications au programme Hello.c mais faisons-les dans un environnement de développement plus décent – nous voulons un soi-disant IDE (signifie Environnement de développement intégré) – de nombreux développeurs purs et durs diront maintenant que c'est un non-sens mais bon, je sais que vous pouvez faire cuire votre steak sur le feu mais quand vous aurez un bon barbecue, vous utiliserez le barbecue…

Pour notre propos, un IDE appelé Geany fera l'affaire, mais il doit être installé sur le Raspberry.

et c'est parti. L'installation démarrera mais une confirmation sera requise. L'installation réussira mais lorsque vous essayez d'exécuter le programme à partir de la ligne de commande, vous recevrez une erreur : l'IDE est écrit pour le XServer Desktop qui en retour nous oblige à passer de notre ligne de commande PuTTY à une connexion RDP. Vous trouverez Geany au menu. J'ai déjà chargé notre Bonjour c programme…

Tout d'abord, nous veillerons à placer le curseur dans une nouvelle ligne lorsque le programme est exécuté cette fois – ceci est simplement réalisé en ajoutant un à la sortie, un caractère de contrôle qui ajoutera la nouvelle ligne. Nous avons également besoin que le programme fournisse un code de retour (sinon le compilateur se plaindra…) donc une autre ligne est ajoutée : retourner 0

Vous pouvez maintenant appuyer sur la touche F9 pour lancer la compilation…

Nous pouvons maintenant revenir à notre session PuTTY et passer en revue le répertoire des sources à l'aide de la commande ls. Encore une fois, nous trouverons le code source et le fichier compilé – l'exécuter à nouveau rendra maintenant la sortie différente.


Voir la vidéo: QGIS: Heat Maps (Octobre 2021).