C++ - arguments à la main

Question

question très basique. j'essaye d'écrire un programme qui produit les noms de fichiers des fichiers traînés sur l'exe.

j'ai suivi ce guide pour les arguments principaux: http://publications.gbdirect.co.uk/c_book/chapter10/arguments_to_main.html

voici mon code:

#include "stdafx.h" 
#include <iostream> 
using namespace std; 
int _tmain(int argc, _TCHAR* argv[]) 
{ 
    cout<<"num arguments: "<<argc<<"\n"; 

    while(argc--) 
     printf("%s\n", *argv++); 

    cout<<"press any key"; 
    getchar(); 
    return 0; 
} 

mais tout ce qu'il s est sortie: si je cours

sans glisser & glisser des fichiers sur l'exe:

num arguments: 1

G

appuyez sur une touche

si je fais glisser & déposer 3 fichiers seront sortie:

arguments num: 4

G

G

G

G

appuyez sur une touche

ni le nom de l'application, ni le nom de l'un des fichiers commençant par « G »

quel est le problème?

merci!

Answer 1

Utilisez ceci:

while(argc--) 
    printf("%s\n", argv[argc]); 

Answer 2

Vous obtenez seulement la première lettre que vous mixez Unicode et non. Je ne peux pas expliquer le désolé Gs (à moins que tous vos fichiers sur le lecteur G :?) mais vous verrez les noms de fichiers complets avec

while(argc--) 
    _tprintf(_T("%s\n"), *argv++); 

à la place.

Afterthought, et battu à par la réponse de l'OSMŒ: Je ne peux pas trouver un _tcout à utiliser comme

_tcout << *argv++; 

au lieu si vous voulez rester C++ - Je suppose que vous auriez à définir un, par exemple Bien que ce soit C++, ils ne devraient probablement pas être définis mais quelque chose d'autre, et je ne suis pas sûr à 100% quoi.

Answer 3

argv[0] est toujours le nom de l'exécutable. (Ce qui signifie que argc > 0 est toujours vrai.) Si vous voulez afficher des caractères larges (je pense que _TCHAR correspond à wchar_t, BICBWT), vous ne devez pas utiliser une sortie étroite. En C++, la sortie est effectuée en utilisant des flux de sortie. Le flux de sortie de la large console est std::wcout.

#include <iostream> 

//Beware, brain-compiled code ahead! 
template< typename InpIt > 
void output(InpIt begin, InpIt end) 
{ 
    while(begin != end) 
    std::wcout << *begin++ << L'\n'; 
} 

int _tmain(int argc, _TCHAR* argv[]) 
{ 
    std::wcout << L"num arguments: " << std::argc << L'\n'; 

    output(argv+1, argv+argc) 

    return 0; 
} 

Comme mentionne Rup, _TCHAR change sa valeur (ou charwchar_t) selon une définition. D'abord et avant tout: Avez-vous vraiment besoin de cette commutation? En pratique, lorsque vous avez besoin de caractères larges, le plus souvent vous en avez vraiment besoin et le programme ne fonctionnera pas correctement avec des caractères étroits.
Il est donc très probable que vous pouvez simplement vous contenter de caractères larges purs, vous débarrasser de la commutation, et utiliser le code ci-dessus comme écrit. Toutefois, si vous avez vraiment besoin de basculer, vous devez basculer entre les flux de console étroits et larges vous-même. (Ceci n'est vrai que pour les objets de flux de la console, BTW Pour vos propres flux, disons, par exemple, les flux de fichiers, vous pouvez simplement utiliser _TCHAR et laisser le compilateur comprendre le reste: std::basic_ofstream<_TCHAR>.) Une façon de le faire serait traits classe:

//Beware, brain-compiled code ahead! 
template< typename Char > 
struct console_stream_traits; // leave undefined 

template<> 
struct console_stream_traits<char> { 
    typedef std::basic_ostream<char> ostream; 
    typedef std::basic_istream<char> istream; 
    std::basic_ostream<char>& cout = std::cout; 
    std::basic_ostream<char>& cerr = std::cerr; 
    std::basic_ostream<char>& clog = std::clog; 
    std::basic_istream<char>& cin = std::cin; 
}; 

template<> 
struct console_stream_traits<wchar_t> { 
    typedef std::basic_ostream<wchar_> ostream; 
    typedef std::basic_istream<wchar_> istream; 
    std::basic_ostream<wchar_t>& cout = std::wcout; 
    std::basic_ostream<wchar_t>& cerr = std::wcerr; 
    std::basic_ostream<wchar_t>& clog = std::wclog; 
    std::basic_istream<wchar_t>& cin = std::wcin; 
}; 

typedef console_stream_traits<_TCHAR> my_ostream; 
typedef my_console_stream_traits::ostream my_ostream; 
typedef my_console_stream_traits::ostream my_ostream; 

my_ostream& my_cout = my_console_stream_traits::cout; 
my_ostream& my_cerr = my_console_stream_traits::cerr; 
my_ostream& my_clog = my_console_stream_traits::clog; 
my_istream& my_cin = my_console_stream_traits::cin; 

Avec cela, la boucle dans la fonction output() ci-dessus deviendrait:

while(begin != end) 
    my_cout << *begin++ << _T('\n'); 

Answer 4

Il suffit d'utiliser la fonction 'principale' ASCII et tout sera OK. Changer

int _tmain(int argc, _TCHAR* argv[]) 

à

int main(int argc, char *argv[])