Quelle est la différence entre _tmain() et() en C++?

Si je lance mon application C++ avec la suite de méthode main (), tout est OK:

int main(int argc, char *argv[]) 
{
   cout << "There are " << argc << " arguments:" << endl;

   //Loop through each argument and print its number and value
   for (int i=0; i<argc; i++)
      cout << i << " " << argv[i] << endl;

   return 0;
}

- Je obtenir ce que je pense et mes arguments sont imprimés.

Cependant, si j'utilise _tmain:

int _tmain(int argc, char *argv[]) 
{
   cout << "There are " << argc << " arguments:" << endl;

   //Loop through each argument and print its number and value
   for (int i=0; i<argc; i++)
      cout << i << " " << argv[i] << endl;

   return 0;
}

Il affiche uniquement le premier caractère de chaque argument.

Quelle est la différence la cause?

InformationsquelleAutor joshcomley | 2009-05-21

arguments c++unicode

343

_tmain n'existe pas en C++. main n'.

_tmain est une extension Microsoft.

main est, selon la norme C++, le programme du point d'entrée.
Il a une de ces deux signatures:
```
int main();
int main(int argc, char* argv[]);
```
Microsoft a ajouté un wmain qui remplace la deuxième signature avec ceci:
```
int wmain(int argc, wchar_t* argv[]);
```
Et puis, pour le rendre plus facile de basculer entre Unicode (UTF-16) et de leurs caractères multioctets, ils ont défini _tmain qui, si Unicode est activé, est compilé comme wmain, et dans le cas contraire main.

Comme pour la deuxième partie de votre question, la première partie de l'énigme est que votre principale fonction est mal. wmain devrait prendre un wchar_t argument, pas char. Puisque le compilateur ne pas appliquer ce pour la main fonction, vous obtenez un programme où un tableau de wchar_t les chaînes de caractères sont transmis à la main fonction, qui les interprète comme char chaînes.

Maintenant, en UTF-16, le jeu de caractères utilisé par Windows lors de l'Unicode est activée, tous les caractères ASCII sont représentés comme la paire d'octets \0 suivie par la valeur ASCII.

Et depuis le CPU x86 est little-endian, l'ordre de ces octets sont inversés, de sorte que la valeur ASCII vient d'abord, puis suivi par un octet nul.

Et dans une chaine de caractères, quelle est la chaîne de caractères généralement fin? Yep, par un octet nul. Si votre programme voit un bouquet de chaînes de caractères, chacun des octets de long.

En général, vous disposez de trois options lorsque vous faites de la programmation sous Windows:
- Explicitement l'utilisation de l'Unicode (appel wmain, et pour chaque fonction API Windows qui prend en char-les arguments d'appel de la -W version de la fonction. Au lieu de CreateWindow, appel CreateWindowW). Et au lieu d'utiliser char utilisation wchar_t, et ainsi de suite
- Désactiver explicitement Unicode. Appel principal, et CreateWindowA, et l'utilisation char pour les chaînes.
- Permettent à la fois. (appel _tmain, et CreateWindow, qui résoudre à main/_tmain et CreateWindowA/CreateWindowW), et l'utilisation TCHAR au lieu de char/wchar_t.
La même chose s'applique à la chaîne de types définis par windows.h:
LPCTSTR résout soit LPCSTR ou LPCWSTR, et pour chaque autre type qui comprend char ou wchar_t, a-T - version existe toujours, qui peut être utilisé à la place.

Noter que tout cela est Microsoft. TCHAR n'est pas un standard C++ type, c'est une macro définie dans windows.h. wmain et _tmain sont également définis par Microsoft uniquement.
- je me demande s'ils ont un tcout trop? de sorte qu'on pourrait tout faire tcout << argv[n]; et il se résout à le cout de l'Ansi et wcout en mode Unicode? Je soupçonne que pourrait être utile pour lui dans cette situation. et +1 bien sûr, belle réponse 🙂
- Quel inconvénient serait la désactivation de l'UNICODE fournir?
- Schaub - litb : autant que je sache, ils ne fournissent pas un tcout (même s'ils fournissent cout et wcout). Sur Visual C++2003, j'ai eu à définir, ainsi que de définir et/ou définition de type de tous les autres STL symboles liés à la je voulais utiliser un TCHAR. Je ne sais pas sur Visual C++2008 ou 2010, mais.
- -1 Aucun des trois options ci sont pratiques. Le moyen le plus pratique pour les Fenêtres de programme est de définir UNICODE. Et certains autres ajustements pour C++, etc., avant, y compris <windows.h>. Ensuite, utilisez les fonctions Unicode comme CreateWindow (en général sans W nécessaires à la fin).
- Exactement pourquoi considérez-vous que pour être plus pratique?
- "..._tmain sont également définis par Microsoft" Votre dernier paragraphe est absolument inexact, _tmain est mis en œuvre exactement la même dans RAD Studio, C++Builder. En fait, sous C++Builder par défaut de _TCHAR mapping, en utilisant simplement des principaux échouera.
- Merci! C'est un problème frustrant pour moi quand j'ai commencé à l'aide de Visual Studio. Je comprends pourquoi Microsoft fait les différents changements qu'ils ont fait, mais c'est horrible essayer de faire la conversion... Semble que tout ce que je fais qui a bien fonctionné dans gcc est cassé dans VS. 🙂
- logiquement, ils venaient tout juste de surcharger le cout<< opérateur de gérer tchar/wchar correctement, pas besoin de faire un dédié wcout
- jalf.com signifie que _tmain est spécifique de Windows (et le système d'exploitation de l'API Windows est défini par Microsoft). Sur Linux ou MacOSX ou les systèmes FreeBSD n'est pas _tmain point d'entrée!
- Ne devrait-elle pas être que _tmain resolves to main/wmain pas main/_tmain
- ur tout commentaire est absolument inexacte. _tmain sera seulement de compiler et de l'exécuter sur ms-os, n'importe quel ide u utiliser, même si u manuellement utilisation ml.exe et link.exe
InformationsquelleAutor jalf
34

_tmain est une macro qui obtient redéfini en fonction de si oui ou non vous compilez avec Unicode ou ASCII. C'est une extension Microsoft et n'est pas garanti de fonctionner sur n'importe quel autres compilateurs.

La déclaration correcte est
```
 int _tmain(int argc, _TCHAR *argv[]) 
```
Si la macro UNICODE est définie, qui s'étend à
```
int wmain(int argc, wchar_t *argv[])
```
Sinon, il se développe pour
```
int main(int argc, char *argv[])
```
Votre définition va pour un peu de chaque, et (si vous avez UNICODE définie) s'étend à
```
 int wmain(int argc, char *argv[])
```
qui est tout simplement faux.

std::cout travaille avec des caractères ASCII. Vous avez besoin de std::wcout si vous utilisez des caractères larges.

essayer quelque chose comme cela
```
#include <iostream>
#include <tchar.h>

#if defined(UNICODE)
    #define _tcout std::wcout
#else
    #define _tcout std::cout
#endif

int _tmain(int argc, _TCHAR *argv[]) 
{
   _tcout << _T("There are ") << argc << _T(" arguments:") << std::endl;

   //Loop through each argument and print its number and value
   for (int i=0; i<argc; i++)
      _tcout << i << _T(" ") << argv[i] << std::endl;

   return 0;
}
```
Ou vous pouvez simplement décider à l'avance si l'utilisation ou à l'échelle de caractères étroits. 🙂

Mis À Jour Le 12 Novembre 2013:

Changé le traditionnel "TCHAR" à "_TCHAR" qui semble être la dernière mode. Les deux fonctionnent très bien.

Mise À Jour De Fin
- +1 _tmain utilise TCHAR pas char.
- "C'est une extension Microsoft et ne fonctionne pas sur toutes les autres compilateurs." Pas autant que RAD Studio est concerné.
- Couper les cheveux en quatre, de l'outil de liaison pour les utilisations "_TCHAR", plutôt que "TCHAR" donc il n'est pas compatible (si elle ne falsifier ma déclaration). Cependant j'aurais dit "C'est une extension Microsoft et n'est pas garanti de fonctionner sur n'importe quel autres compilateurs.". Je vais modifier l'original.
- J'étais principalement en se référant à "des Changements de Code..." de la section, ce qui explique pourquoi RAD Studio utilise maintenant _tmain en place de la principale, et en fait, il est maintenant la norme par défaut pour Embarcadero C++Builder.
- C'est la deuxième fois que récemment que ce quatre-année-vieille réponse a été downvoted. Ce serait bien si downvoters fait un commentaire expliquant quels sont les problèmes qu'ils perçoivent et (si possible) comment améliorer la réponse. b1naryatr0phy trouvé une phrase mal écrite, mais j'ai corrigé que jusqu'en Mars. Tout conseils seraient appréciés.
- de ne pas être offensant, mais son _TCHAR pas TCHAR. Il vous manque le _ ici..:) Merci de modifier..que je ne vais pas être en mesure de modifier ce problème mineur..
- vous avez tort. Son _TCHAR..
- Ahmad Zeeshan -- MSVC++ a utilisé le terme "TCHAR" depuis au moins au moins MSC version 4 (longtemps avant MSVC++ version 1). Les docs toujours spécifier "TCHAR". Voir msdn.microsoft.com/en-us/library/office/cc842072.aspx. Je viens de remarquer que VC++ 2012 (express) est générateur de code par défaut avec "_TCHAR" donc je suppose que c'est OK aussi, mais TCHAR est toujours très bien à utiliser.
- Viens de réaliser ce qui s'est passé. MS ont été poussant leur adhésion à la norme C++ docs, de sorte qu'ils sont la préfixation de tout ce qui n'est pas dans la norme avec un "_". Je dirais qu'à l'aide de "TCHAR" ou "_TCHAR" est OK.
- Ce n'est pas correct. TCHAR et _TCHAR ont toujours existé. TCHAR contrôle le jeu de caractères utilisé par Windows fichiers d'en-tête. _TCHAR contrôle le jeu de caractères utilisé par le CRT. La différence est subtile, mais bien justifié. Depuis le point d'entrée est la partie de la CRT, en utilisant _TCHAR est correct, qu'. Pour référence, voir TEXTE vs _TEXT vs _T, et UNICODE vs _UNICODE.
- Vous êtes dans l'erreur.Ni TCHAR, ni _TCHAR ont toujours existé. TCHAR, apparue au milieu des années 1990. Je ne me souviens pas exactement quand _TCHAR est apparu, mais je pense que c'était autour de l'an 2000. Raymond Chen article que vous avez lié ne parle pas de TCHAR. Comme je l'ai dit en 2009 lorsque cela a commencé, les anciennes versions de Visual C++ serait de générer un _tmain utilisé TCHAR. Les versions les plus récentes semblent utiliser _TCHAR. Je serai surpris si vous pouvez trouver un cas pratique où il fait une différence.
- suite ... Presque personne n'manuellement définit les caractères UNICODE/_UNICODE ces jours-ci. Ils cliquez sur une case à cocher dans Visual Studio et il arrive tout de l'auto-magiquement.
- L'article que j'ai lié à l'explique, pourquoi il y a des symboles avec et sans un trait de soulignement, et quand à utiliser. Un cas pratique ont été de ce fait, c'est quand il s'agit de salaire. Les symboles Unicode n'ont jamais été définie par le biais d'une case à cocher dans Visual Studio. Cela a toujours été une zone de liste déroulante. Et avec CMake intégré à Visual Studio, en commençant par en 2017, de définir les symboles de préprocesseur est devenu assez commun en tant que bien. Peu importe, cette réponse est stock complet de mal que je suis perplexe, pourquoi vous avez même se plaindre de la voix. Ils sont bien justifiées.
- Vous m'avez pris: j'ai dit case lorsque j'aurais dit de la liste. Si mon post a une erreur, dites-moi ce que c'est et je vais le corriger. Je n'ai pas à me plaindre à propos de downvotes, seulement downvotes où aucune raison n'est donnée. Raymond Chen est écrit à propos de deux paires de symboles, pas tous les symboles en général.
- Raymond Chen spécifiquement parle des symboles utilisés par le générique de texte mappages. Le raisonnement derrière un trait de soulignement s'applique à tous symbole, y compris la TCHAR/_TCHAR paire de symboles. Des erreurs dans votre réponse proposée: Alors qu'il est possible de compiler pour ASCII, ce n'est pas directement accessible par le biais de l'IDE de Visual Studio. De même, std::cout n'est pas seulement un soutien ASCII.
- La vie est trop courte pour cela.
- encore une fois, personne ne s'intéresse à une seule IDE, qui utilise même RAD trucs
InformationsquelleAutor Michael J
9

la _T convention est utilisée pour indiquer que le programme doit utiliser le jeu de caractères défini pour l'application (Unicode, ASCII, MBCS, etc.). Vous pouvez entourer votre cordes avec _T( ) pour les avoir stockées dans le format correct.
```
 cout << _T( "There are " ) << argc << _T( " arguments:" ) << endl;
```
- En fait, MME recommande cette approche, autant que je sache. De faire votre demande unicode, ils l'appellent... à l'aide de la _t version de toutes les fonctions de manipulation de chaîne, trop.
- Et sur Windows, ce est comment faire votre demande unicode-prêt (je préfère le terme de l'unicode: prêt-à -courant), si elle était fondée sur char s avant. Si votre application utilise directement wchar_t, alors votre demande est unicode.
- Par ailleurs, si vous essayez de compiler sur UNICODE, puis votre code ne compile pas que votre outputing wchar_t à l'intérieur d'un char à base de cout, là où il devrait avoir été wcout. Voir Michael J réponse pour un exemple de la définition d'un "tcout"...
- Aucun si ce n'est recommandée par Microsoft, en grande partie, parce que c'est simplement faux. Lors de la compilation pour l'Unicode, le code écrit pointeur valeurs du flux de sortie standard. -1.
InformationsquelleAutor Paul Alexander
5

Ok, la question semble avoir été entendu assez bien, l'UNICODE surcharge de prendre un large tableau de caractères comme second paramètre. Donc, si le paramètre de ligne de commande est "Hello" qui serait probablement jusqu'à la fin comme "H\0e\0l\0l\0o\0\0\0" et votre programme d'imprimer uniquement la 'H' avant qu'il voit ce qu'il pense est un terminateur null.

Alors maintenant, vous demandez peut-être pourquoi il même compile et des liens.

Eh bien, il compile parce que vous êtes autorisé à définir une surcharge d'une fonction.

La liaison est un peu plus complexe. En C, il n'est pas décoré symbole de l'information jusqu'à ce qu'il trouve une fonction appelée main. L'argc et argv sont probablement toujours là, comme la pile des appels paramètres, juste au cas où, même si votre fonction est définie avec la signature, même si votre fonction arrive à les ignorer.

Même si le C++ n'ont décoré des symboles, il est presque certainement utilise C-lien de main, plutôt que d'un savant éditeur de liens qui ressemble, pour chacun, à tour de rôle. Donc, il a trouvé votre wmain et de mettre les paramètres dans la pile des appels dans le cas où il est le int wmain(int, wchar_t*[]) version.
- Ok, si j'ai un problème de portage de mon code pour windows widechar depuis des années maintenant et C'est la première fois que j'ai compris pourquoi cela se produit. Ici, prendre toutes ma réputation! haha
InformationsquelleAutor CashCow

-1

Avec un peu d'effort de création d'un modèle de cela, il wold travailler avec une liste d'objets.

#include <iostream>
#include <string>
#include <vector>

char non_repeating_char(std::string str){
    while(str.size() >= 2){
        std::vector<size_t> rmlist; 
        for(size_t  i = 1;  i < str.size(); i++){        
            if(str[0] == str[i]) {
                rmlist.push_back(i);
            }      
        }          

        if(rmlist.size()){            
            size_t s = 0;  //Need for terator position adjustment   
            str.erase(str.begin() + 0);
            ++s;
            for (size_t j : rmlist){   
                str.erase(str.begin() + (j-s));                
                ++s;
            }
         continue;
        }
        return str[0];
   }
    if(str.size() == 1) return str[0];
    else return -1;
}

int main(int argc, char ** args)
{
    std::string test = "FabaccdbefafFG";
    test = args[1];
    char non_repeating = non_repeating_char(test);
    Std::cout << non_repeating << '\n';
}

InformationsquelleAutor Misgevolution

Vous devez vous connecter pour publier un commentaire.