Je dois passer de Python à C / C ++. de
Connaissez-vous un "tutoriel de référence" rapide ou quelque chose comme ça pour avoir une référence à la façon de commencer? Par exemple, quelque chose comme les tutoriels numpés et scipés.
J'ai lu beaucoup de "documentation", par exemple
Mais il n'est toujours pas clair pour moi même comment faire de commencer à porter à C / C ++ quelque chose comme: p> in c ou c ++. Dans cet exemple, je n'ai même pas pu comprendre comment transmettre un tableau 3D à une fonction qui trouve les dimensions, quelque chose comme p> avec tableau étant p> int array[3][3][3] = ...
3 Réponses :
D'accord, il suffit de commencer avec c pour l'instant. Tant que vous vous souviendrez que votre tableau est 3x3x3, vous ne devez pas avoir de problèmes qui dépassent les limites de votre méthode "WriteH5Data".
Je voudrais simplement noter que Richard appelle calloc () trois fois séparé: échantillon est une matrice de pointeurs (externe calloc ), chacun desquels Points à un tableau de pointeurs (Moyen CalloC ), chacun desquels indique une matrice de int S (interface calloc ). Quand j'ai commencé avec C, j'avais du papier partout où j'ai esquissé des blocs de mémoire pour déterminer ce qui a été signalé à quoi. De plus, si vous avez vraiment besoin de la taille d'un tableau, vous devrez dans la plupart des cas de le suivre vous-même lorsque vous créez le tableau. C ne sait pas où les tableaux "finissent" en général, donc tailleof () ne fonctionne pas.
Merci pour la réponse, je vais l'étudier, mais je cherchais une "référence", quelque chose comme cfa.harvard.edu/~jbattat/computer/python/science/idl-numpy.h tml . Ok, pas vraiment une "table de conversion" mais quelque chose comme "en C / C ++ est une bonne pratique pour gérer des tableaux de cette manière, de les transmettre de cette manière et si vous avez besoin de faire
Pour être plus clair, je recherche une "référence numérique" (mais pas "recettes numériques"). Après avoir lu beaucoup de théorie, je ne sais toujours pas comment commencer à être productif, je n'ai aucune référence sur la manière de faire des choses simples, "standard" et quotidiennes, comme manipuler des tableaux multidimensionnels et les transmettre à des fonctions. Après tant d'années de programmation C / C ++ au monde, je pense qu'il y aurait une connaissance partagée «standard» qui suggère »de faire
OK, pour cet exemple particulier:
En utilisant C ++, vous risquez de manquer quelques fonctionnalités de python, mais la plupart d'entre eux sont effectivement fournis par le boost bibliothèques. Par exemple revenir plusieurs valeurs d'une fonction est très facile avec boost.tuple bibliothèque comme dans . Vous pouvez utiliser boost :: shared_ptr si vous ne « t voulez vous embêter avec la gestion de la mémoire. Ou si vous voulez continuer à utiliser python pour jouer avec vos classes C ++, vous pouvez utiliser Boost.Python . Boost.parameter vous aide à définir fonctions avec des arguments nommés. Il y a aussi Boost.lambda pour les fonctions lambda, mais si vos supports de l'environnement, vous pouvez également utiliser C ++ 11 pour avoir prise en charge linguistique pour les fonctions lambda. Boost est une mine d'or, jamais creuser arrêt. Il suffit de supposer que cela fait partie de la bibliothèque standard. Je développe C ++ dans de nombreuses plates-formes différentes, et ni Eigen, ni coup de pouce m'a laissé tomber encore.
ici 'est une bonne FAQ pour les meilleures pratiques C. Cette est un principe très important que vous devez garder à l'esprit en tout temps, tout en travaillant dans C ++. Je tiens un peu, dans mon esprit et de penser; Si vous allez faire quelque chose de dangereux tels que: Allouer mémoire avec un Enfin, mon préféré !!! Voulez-vous continuer à utiliser des générateurs en C ++? est un peu de magie noire. raw nouveau , ou de l'indice d'un tableau de style brut C, passer des pointeurs autour premières, ou faire static_cast ( encore pire reinterpret_cast ), etc. ils doivent généralement se produire dans une classe en quelque sorte qui leur est dédié, et le code pour vous assurer qu'ils ne causent pas de vie trouble très proche d'eux, de sorte que vous pouvez voir à coup d'oeil que tout est sous contrôle.
Mais cette magie sombre n'est pas valide C ++.
Je l'utilise régulièrement sur un compilateur C ++ régulier (GCC). Considérez cela, je l'ai même utilisé sur un projet basé sur un bras! (Android NDK)
Je seconde cela. Utilisez C ++ (ou encore mieux, C ++ 11) au lieu de C, car il est plus proche de Python. Utilisez Boost pour faire tout ce que vous êtes habitué à Python, comme des fonctions Lambda. N'utilisez JAMAIS DES POINTRES RAW - Utilisez STD :: String, STD :: Vecteur et Shared_Ptr.
De droite, les fonctions Lambda sont bonnes à mentionner.
Chaque nom contenant un double soulignement _ _ _ _ _ ou commence par un soulignement suivi d'une lettre majuscule (2.12) est réservé à la mise en œuvre de toute utilisation. [Global.Mames] et [lex.chaset] n'inclut pas «$» dans le cadre du jeu de sources de base de base. En dehors de ceux-ci: cette chose a quelques problèmes de cadrage: je ferais mieux d'utiliser des déclarations de commutation dans le corps du générateur, sinon je reçois rapidement un comportement difficile à déboguer, encore plus difficile, car le code cache derrière les macros. Toute cette chose consiste à sauter directement dans des boucles, exploitant pas les caractéristiques non connues. Tous les codeurs écrivent du code de buggy,
Mais de bons codeurs tentent d'éviter le code qui est difficile à déboguer. Le code lui-même nous demande si l'auteur est un bon programmeur du tout: les membres du public doivent stocker l'état privé? Dérivation explicitement publique où il est déjà public par défaut?
Vous êtes libre de remplacer le caractère «$» avec ce qui vous plaît. Juste le changer dans le générateur.h. En ce qui concerne le problème de fixation, l'article mentionne que vous ne pouvez pas utiliser l'instruction de commutation dans le corps du générateur, et je pense que l'on peut vivre avec cela. Par rapport aux générateurs d'élégance apportent parfois à votre solution, ce sont des non-problèmes.
Je sais que ça a l'air très effrayant, j'ai également été sceptique au début, mais c'est vraiment très robuste, et il aboutit également à un code très efficace. Ne tenez pas compte du générateur comme une classe normale et de l'évaluer sur cette base dans votre esprit. Ce qui est vraiment difficile à déboguer, c'est le code que vous écrivez afin de contourner le manque de générateurs en C ++. Je finis par écrire 5-10 lignes de code de générateur en utilisant cette méthode, qui remplace les dizaines de lignes. Lequel pensez-vous est plus susceptible d'inclure des bugs?
@enobayram: Merci pour la FAQ de Parashift: J'étais sur le site il y a quelque temps mais je n'ai pas assez lu!
Élégance? Si j'ai des objets lourds créés chaque fois que j'appelle Gen (), cela ne ressemble pas à l'élégance, le cas échéant, cela passe sous "code soigné". Pourquoi pas seulement les foncteurs normaux tels qu'ils sont communs dans C ++, avec un const-correct Boost :: facultatif
Rien n'est créé pendant gen () , il modifie int n à l'exemple de l'article. En ce qui concerne les foncteurs, si vous essayez de créer un ameublement comme un générateur, vous devez gérer manuellement l'état interne pour vous rappeler où vous avez laissé la dernière fois. et c'est suone bug.
Des dizaines de lignes vs quelques-uns? Vous devez être Kidding: Modèle pour (Gen <0,10> Gen; const auto & x = gen ();) . Il a la même complexité de l'état et n'est pas plus suone de bugs que cette macro-hickhack. De plus, vous ne vous limitez pas à un sous-ensemble de C ++ et s'il existe un bogue, même les programmeurs intermédiaires peuvent déboguer.
Ceci est un exemple de jouet, ici, votre X se souvient de vous rappeler où vous vous êtes arrêté, vous n'avez donc pas à gérer cela. Parfois, vous n'avez pas besoin de ne pas faire des opérations régulières chaque fois que votre générateur est appelé, et avec un foncteur, vous devez gérer le code pour reprendre l'endroit où vous vous êtes arrêté.
Je pense que cette chose génératrice est un code de jouet qui n'ajoute pas beaucoup. Il est intéressant, de même que le périphérique de Duff. Et, en utilisant des fonctions d'héritage et std :: Fonction et / ou Lambda, il est possible d'écrire une classe de générateur propre sans aucune gestion manuelle et sans mauvaises macros diaboliques qui polluent mon espace d'identifiant et nuire à mon état d'identifiant ou le code futur. Et si vous parlez de code non jouet, quelle est votre approche typique débogage d'une fonction de générateur? Est-ce facile? Ou est-ce par suppositions? Je parie que vous êtes pas en utilisant votre débogueur, êtes-vous?
Vous devriez le voir pour croire à quel point il joue avec le débogueur. Le débogueur se comporte exactement comme si tous ces mots-clés pseudo étaient des caractéristiques de la langue. En ce qui concerne le code générateur étant jouet, je l'ai utilisé pour de nombreux algorithmes sophistiqués. Je ne pense pas que nous devons faire valoir comment les générateurs utiles sont en général. Il vous suffit de les utiliser pour savoir combien vous en avez besoin. Tout comme n'importe quoi d'autre dans la programmation.
Il y a un point de bogue-orienté, et je pense que le seul. Si vous déclarez des variables locales dans le corps générateur, vous aurez des résultats surprenants. Mais je pense que vous pouvez garder cela à l'esprit tout en écrivant 10-20-30 lignes de code. Ce n'est pas nouveau à C ++.
Autres taches de bug de cette incarnation: j'ai besoin d'un symbole plus important que la boucle que j'en ai besoin, car le résultat n'est pas retourné mais écrit à titre de référence; Cela augmente la complexité cyclomatique. Cela implique un autre point de bogue: cela me force à écrire du code incorrect de la constance; augmente à nouveau la complexité. En outre, comment puis-je utiliser des valeurs qui ne sont pas constructibles par défaut? Et si j'ai un autre bogue dans ces 30 lignes qui sont difficiles à repérer? E.g., quand je jette , je reçois # 6 0x00000000000040074a in descente :: opérateur () (int &) () . Bon, sauf que je dois maintenant interpréter les macros, non trivial.
- Je ne comprends pas votre point concernant la constance, pourquoi avez-vous besoin de ce que vous cédez pour être constitué? Même dans ce cas, juste au début de l'organisme de boucle, vous pouvez définir une référence constante à la valeur donnée et utiliser cela dans le corps de la boucle. Ou si vous ne rentrez pas de choses syntaxiquement, cédez-les avec des pointeurs const t * .
- réutiliser non par défaut Valeurs constructibles: Si vous voulez avoir des variables de telles variables dans le code, vous pouvez définir un constructeur pour votre générateur (car c'est en réalité c'est une classe) avant $ émettre et initialiser quoi que ce soit dans un Liste d'initialisation. Si vous parlez de donner non des types constructibles par défaut, que dans l'en-tête de la boucle, Initialisez-le («N» dans l'exemple), mais vous voulez.
- Re ce que vous obtenez quand vous lancez. Allez, il dit Descent dans le message ...
0) La valeur "retournée" doit être Const, non "EMIT" Itérateur, comme const int x = foo () . Vous pouvez seulement dire foo (x) , qui interdit de faire x const. Voir aussi Ce . Ne pas être capable de dire que l'état mutable au site de l'appelant augmente inutilement. 1) Non, je veux dire en utilisant des classes de constructions non par défaut comme la valeur "retournée", par ex. Const Fichier x = Find_All ("*. CPP") . Si fichier n'est pas constructible par défaut, je ne peux pas l'utiliser avec le générateur. 2) sauf qu'il ne dit pas rendement , mais opérateur () . Macros diaboliques maléfiques
Et BTW, je sais que dans la réalité c'est une classe. J'ai inspecté et compris le code pour pouvoir le juger;)
0,1) Je vois, il peut y avoir des inconvénients. Mais, il existe des moyens de les entourer, par exemple en utilisant des pointeurs bruts ou unique_ptr s etc. (vous n'avez pas à continuer à utiliser le pointeur dans le corps de la boucle, vous pouvez définir immédiatement un fichier const int & au début du corps de la boucle). Plus important encore, les cas où il y a des inconvénients ne vous empêchent pas d'utiliser ces générateurs dans des cas où il n'y en a pas. 2) Allez ... :)
0), 1) Cela ajoute de la complexité, avec ou sans cesse. Vous n'êtes pas dans la constance et la complexité de code, êtes-vous? Avez-vous déjà tenu de conserver un code hérité qui a utilisé trop d'état? L'état moins mutable, plus il y a de capacité dans votre cerveau. Avec C ++, je préfère utiliser les idiomes communs, comme indiqué par le nombre de lignes non plus grand que les générateurs soignés (BTW: Lisez "Exceptionnel C ++", où Sutters d'herbe recommande d'écrire droit, pas soigné) et qui sont soignés) et qui sont compris par tous les programmeurs C ++. 2) Non, je ne vois pas. Si je dois trouver un bogue dans votre code, sous pression, ...
... Je ne veux pas lutter mon cerveau avec des bouffées supplémentaires de ces macros, juste pour comprendre ce qui se passe. Et vous aussi, parce que ce n'est qu'une question de temps que vous oubliez ce qui se passe (peut-être 1 an, peut-être 10). Je me demanderais déjà assez que je ne puisse pas déclarer une seule variable à l'intérieur du générateur-boucle. Cette chose ajoute de sorte que rien, et je voudrais lui interdire de l'utiliser dans ma société car il n'y a pas de raison sain d'utiliser les idiomes communs; Au moins, vous n'en avez pas présenté un seul.
Et au cas où vous n'êtes pas suffisamment inspiré pour donner un véritable avantage, voici encore un autre contre-argument: je ne peux utiliser aucune structure de contrôle locale sans code non rare ni même pirater. Non seulement changez des relevés, mais également des boucles locales, tandis que les boucles-appels, les appels de fonction, etc., etc. Je pourrais penser toute la nuit dessus et toutes les 10 minutes, une autre mise en garde deviendrait évidente. Je doute quelque chose d'avoir réellement eu 30 fonctions de générateur de longues lignes qui ont réellement travaillé local.
1) J'ai été accusé d'être un freak de const-correction, mais comme je l'ai dit, dans les cas où cela crée un frottement avec const-correction, vous n'avez pas à l'utiliser. 2) Je pense que vous ne voulez pas dire la complexité dans le sens du Big-o. Si vous voulez dire de complexité pour comprendre, cela n'ajoute rien si vous êtes déjà habitué aux générateurs et à réfléchir à ces termes. C'est la même chose avec l'argument de 10 ans, si vous utilisez régulièrement des générateurs, ce qui se passe sera toujours aussi clair que toute autre fonctionnalité syntaxique. 3) Je voudrais interdire l'utiliser dans ma compagnie, pour personne mais moi :).
@Gurgeh: C ++ a ses propres fonctions Lambda maintenant;)
Tout autre que des travaux de commutation
La raison pour laquelle vous êtes tellement dérangé par l'État supplémentaire et tout est que vous essayez de penser aux générateurs comme un autre foncteur avec des états méchants à l'intérieur. Vous devriez penser à un générateur en tant que générateur. Il soulage votre esprit grandement
Une fois, j'ai besoin de itérer à travers les objets qui sont plus proches d'un point donné qu'une certaine distance. Les objets résidaient dans une grille 2D régulière de cellules, et ils avaient la position dans la cellule et je voulais le faire aussi efficacement que possible tout en gardant tout le code d'itération à l'écart du code qui traite réellement ces objets. Les générateurs m'ont permis de créer un code très clair.
1) Il produira toujours des frictions, car je dois agrandir l'état mutable de n'importe quelle fonction. C'est un facteur énorme lors du débogage de quelqu'un d'autre code, car vous devez Rechercher toutes les utilisations Chaque fois que je ne vois aucun const avant une variable. 2) Comme dit, je veux dire la complexité cyclomatique, pas besoin de deviner. Un autre argument de 10 ans: le code court bien. Vous quittez la compagnie. 10 ans plus tard, la société décide d'ajouter plus de fonctionnalités. Les nouveaux devs sont embauchés. Les bugs apparaissent. En ce qui concerne cela non même si vous avez réalisé toutes les implications de cette implémentation génératrice, et ce n'est dans aucun livre C ++ ...
"Quelque chose d'autre que des travaux de commutation": faux. Et le fait que vous ne voyez pas cela souligne grandement mon argumentation contre cette bête. Exemple: int côté = 1; pour (int x = 1; x <5; ++ x, fac * = x); $ Rendement (FAC); . Échouer. {Const Float Pi = 3.14159 ... F;} . Échouer. Vous pouvez toujours utiliser uniquement des variables mondiales ou membres. Avec toutes les implications.
À propos de votre exemple de cellule: Stackoverflow.com/a/9485821/76722 . Pas d'itération de boucle. Juste une Lambda appliquée par champ et un algorithme générique réutilisable. C'est encore mieux, car vous pouvez encapsuler des algorithmes d'indexation de grille plus complexes, tels que Code Morton Du reste du monde. Je pense que vous avez choisi une approche de plus que sous-optimale là-bas / et j'ai travaillé dans C # depuis quelques années, qui propose également des générateurs. Mon esprit est donc déjà soulagé.
La chose génératrice est discutable. Boost.Context a été provisoirement accepté en mai 2011 et officiellement en janvier 2012, nous pouvons donc utiliser Boost pour les coroutine et les générateurs, etc. Voir OK73.OK.FUNPIC.de/Boost / libs / contexte / doc / html / context / ... et groups.google.com/group/boost-developers-Archive/Browse_thre ad / ...
@Gurgeh: C'est une implémentation propre, mes points sont plus contre ce monstre macro-monstre. Le boost on ne souffre pas la plupart des points que je mentionne :)
@phresnel "échoue". Vous réalisez que tous ces cas échouent parce que vous définissez les variables locales, non? Tant que vous définissez int pa, i et const float pi avant $ émettre, tout va bien. J'ai déjà dit que les variables locales sont un problème, vous ne signalez pas quelque chose de nouveau.
@phresnel La question de Stackoverflow que vous avez liée est beaucoup plus simple que mon problème, je n'ai plus besoin d'accéder aux éléments du tableau. Les cellules de la grille avaient une zone finie et je devais vérifier si une partie de cette zone est tombée à la distance du point. En outre, je voulais pouvoir garder le code de traitement agnostique sur la forme de la grille. Je pourrais passer à une grille hexagonale, voire un quad-arbre
@phresnel "Ce n'est dans aucun livre C ++" C # n'est dans aucun livre C ++ non plus. La bibliothèque de la matrice Eigen n'est pas non plus ... en ce qui concerne la complexité cyclomatique, je ne veux pas entrer dans les détails, mais je ne pense pas que la mise en œuvre du générateur introduira plus que vous le feriez tout en essayant de mettre en œuvre la même chose tout en gérant le fonctionnement Etat manuellement. Bien sûr, vous pourriez transformer la mise en œuvre et faire quelque chose de complètement différent pour réduire la complexité cyclomatique, mais je suis sûr que vous aurez des autres compromis.
D'AILLEURS. Si vous êtes si mal à l'aise avec l'utilisation de bibliothèques avec des macros, Boost en est plein d'entre eux. @Gurgeh merci d'avoir pointé sur Boost.Context, je vais y jeter un coup d'œil.
@enobayram: re "échec": que est un problème. _Re_starting Loops Chaque itération nécessite un hack. Et encore une fois, vous ne pouvez utiliser aucune valeur constructible non par défaut qui dépend de quelque chose à l'intérieur du bloc émetteur / arrêt. / À propos de votre problème de cellule: je crains que la section de commentaire soit trop courte. Je vous crois que les générateurs sont, comme une technique abstraite, utile. Mais si j'avais le choix entre les autres idiomes C ++ et Fedoniouk, je resterais avec les idiomes C ++; Je suis à peu près sûr, on peut trouver des méthodes tout aussi bonnes (ou encore meilleures). Les algorithmes génériques peuvent devenir assez puissants.
Il n'y a pas de piratage, vous venez de définir Int N en tant que membre de la classe, pas comme une variable locale ... re non-défaut - constructible, c'est la deuxième fois que cela se présente, donc je vais dire la même chose. Vous pouvez les construire non par défaut dans la liste d'initialisation du constructeur de votre générateur ...
@enobayram: Re "malases-macros": Je n'utilise aucune bibliothèque de boost qui me demande d'utiliser des macros. Re "book": mais c # -enérateurs sont décrits dans C # -Books, ce qui est le point. Re "complexité cyclomatique": vous avez raison. Cependant, vous introduisez l'état à une plus grande échelle. Avec des foncteurs ou des Lambdas, vous pouvez tout faire localement à la partie de code où elle est utilisée, ce qui aide chaque mainteneur.
@enobayram: re "No Hack": il y a encore une fois, je parle de RE -Starting Loops Chaque fois Le bloc d'émetteur est entré . Cela nécessite un hack. La même chose en matière de construction par défaut: je cible un objet local au bloc émetteur , avec des conditions préalables calculées dans le bloc émettant . Cela n'est pas possible et l'initialisation de la génératrice-CTOR n'aident pas.
Pour donner un exemple: votre générateur nécessite un scoped_lock dans le bloc émetteur. Vous ne pouvez pas le mettre en tant que membre, car une autre partie entrelacée temporellement utilise le même mutex. Ne peut pas le faire du tout avec la macro-peluchonne. Et s'il vous plaît rappelez-vous: je ne discute pas des générateurs, mais cette mise en œuvre particulière.
@phresnel vous avez raison sur "avec des conditions préalables calculées dans le bloc émettant", bien que je pense que c'est un cas très spécial avec des générateurs et dans un cas aussi spécial (si vous insistez vraiment pour que je puisse être capable d'utiliser quelque chose sous tout Les circonstances pour pouvoir l'aimer) Vous pourriez avoir recours au placement nouveau (cela affaibli mon argument n'est-ce pas :)). En ce qui concerne les boucles, je suis désolé mais je ne vois pas comment pour (i = 0; i <10; i ++) est tellement pire que pour (int i = 0; i <10 ; i ++) . Je pense que nous devrons accepter d'être en désaccord, car nous semblons avoir des perspectives différentes sur ce qui est plus important dans un morceau de code.
Je viens de voir le scoped_lock remarque que vous pouvez définir le scoped_lock en tant que variable locale, car vous n'avez pas besoin de vous rappeler son état la prochaine fois. Si vous avez besoin de le garder enfermé entre différents appels au générateur, cela ne fonctionnera évidemment pas, mais encore une fois, des cas très particuliers ... (bon exemple)
Je viens de remarquer quelque chose de très important. Il n'y a aucun risque d'introduire des bugs silencieux en définissant les variables locales. Le compilateur donnera simplement une erreur de compilateur dans des circonstances qui créeraient autrement un bogue. Cela est dû aux sauts interdits entre les initialisations en C ++. Il autorisera toujours le scoped_lock que j'ai mentionné ci-dessus.
@enobayram: Votre dernière remarque: C'est exactement ce que je parlais de la moitié de la moitié du temps. Vous ne pouvez tout simplement pas déclarer une variable avec une portée émettrice; Comme dit j'ai étudié le code que vous avez lié à tous les aspects: d. Un scoped_lock peut avoir un sens de toute façon, qui a moins à voir avec le trucs croisé croisé, mais plus avec un accès exclusif à une ressource à un moment donné. Après avoir cédé, je m'attendrais à ce que la serrure soit libérée. Mais je suis d'accord sur nous désaccord;)
Je suis content que nous ayons d'accord avec SMT :) À propos de cette remarque, je savais depuis le début que c'était une erreur logique, mais je pensais oublier que cela pourrait causer des bugs sinistres. Je voulais juste souligner qu'il n'y a pas de risque ce type, vous obtiendrez simplement une erreur de compilateur. Ce qui est aussi bon, c'est; Vous n'obtiendrez pas d'erreur de compilateur si la variable locale n'est pas une erreur logique. Maintenant que vous avez passé autant de temps à ce sujet, j'espère que vous lui donnerez une chance une journée dans des conditions contrôlées;)
@enobayram: J'ai bien peur de ne pas faire à cause de raisons a déclaré :)
parasht.com/c+-faq-lite <- Link est mort.
Cette question devient assez vieille, mais voici quelques références qui m'ont été utiles:
Guide de transition: Python à C ++ (PDF)
Une brève introduction à C ++ pour les programmeurs Python (incomplet mais assez bon)
Apparemment, cela a déjà été corrigé
Choisissez un: C ou C ++. "C / C ++" n'existe pas. C ++ est plus facile à apprendre que c à mon avis.
@daknok_t je doute que. C ++ est très productif à utiliser, une fois que vous le savez très bien, mais c'est l'un des plus difficiles à apprendre.
@DAKNOK_T: Je n'ai pas encore été décidé entre C ou C ++, j'ai donc écrit "C / C ++"! Mais lequel d'entre eux correspond à mieux, mes besoins sont une autre question!
Je viens de piloter un projet de Python à C, peut-être environ 10k LOC - m'a pris 4 mois et je suis toujours pas clair sur la façon de commencer à le faire, c'était assez horrible, peut-être peut-être recadrer le Question de telle manière que cela rend complètement irréalisable de vouloir le faire?
@HIETT, je ne suis pas sûr de ce que vous voulez dire ..
Je veux dire être absolument sûr que vous devez faire le port avant de le faire. Le portage d'une langue de haut niveau à une langue de niveau inférieure n'est pas très agréable IMHO. Enquêter sur d'autres options telles que Swig, Ctypes, etc.
Ah ok! En fait, ce que je fais, c'est essayer de faire du port de petits codes pour apprendre c parce que j'en ai besoin pour d'autres projets!