c++ konsolenanwendung xcopy quell/zielfrage

Hi,
ich habe seit Monaten eine kleine batch Datei, die mir ein Backup von D:\ auf K:\ macht. (Datenpartion auf Externe Festplatte)

Nun möchte ich aber, da ich manchmal vorher den USB Stick anstecke, dass ich Ziel bzw Quellordner auswählen kann, und das aber in C++.

Die Umformung meiner Batch Datei gelang ja ohne Probleme von Batch (Shell) in C++.

system("XCOPY D:\*.* K:\ /S /D /-Y");

Ist der Befehl für das Backup!

Nun wollte ich fragen, wie ich D:\ zu einer Variable 'Quelle' und K:\ zu einer Variablo 'Ziel' mache.

Danke im Vorraus
Mfg
Anonymus

Mario Sandler

char quelle,ziel;
char xcopy[1024];

cin >> quelle;
cin >> ziel;

sprintf(xcopy,"XCOPY %c:\*.* %c:\ /S /D /-Y",quelle,ziel);

system(xcopy);

(ungetestet)

Nicht unbedingt C++, aber tut seinen Zweck

thordk

warum c++?

xcopy %1*.* %2 /S /D /-Y in ne bat, aufruf mit "file.bat quelle ziel".

warum c++?
weil ichs gerade lerne batchen könnt ich das ding auch ^^
aber danke auch dafür
ausserdem soll das ding später auch noch eine oberfläche bekommen, und das mit batch?^^ *gg*

ok, und zur c++ lösung, könntest du mir diese methode bitte ewtwas erläutern, da ich zwar die grundlagen von c++ durch bin, aber diese methode ist ma so noch nicht untergekommen

[cpp]char quelle,ziel; //Das sind Funktionen...oder? wozu dann 1024?
char xcopy[1024]; //Quelle und Ziel versteh ich ja

cin >> quelle;
cin >> ziel;

sprintf(xcopy,"XCOPY %c:\. %c:\ /S /D /-Y",quelle,ziel); //sprintf?

system(xcopy);

Danke im Vorraus
Mfg
Anonym

*D*Evil

hmm ...

#include <cstdlib> // std::system
#include <string> // std::string, std::getline
#include <iostream> // std::cout, std::cin
#include <sstream>

int main()
{
    std::cout << "Quelle: " << std::flush;
    std::string source;
    std::getline(std::cin, source); // holt alles ausm buffer bis zum '\n' und nicht nur bis zum nächsten space.
    std::cout << "Ziel: " << std::flush;
    std::string dest;
    std::getline(std::cin, dest);
    std::ostringstream ss;
    ss << "XCOPY " << source << "*.* " << dest << "/S /D /-Y";
    std::system(ss.str().c_str());
}

thordk

wenn du dir damit c++ beibringen willst, verzichte auf den system call und bastel dir das kopieren mit c/c++ bordmitteln nach. das berührt ziemlich viele punkte, die man mal gesehen haben sollte.

Danke für diese 2. Lösung, doch ich fand die erste besser, und leichter... vorallem für einen Anfänger wie mich

doch diese Zeilen versteh ich nciht ganz:

char xcopy[1024]; warum 1024?
sprintf(xcopy,"XCOPY %c:\. %c:\ /S /D /-Y",quelle,ziel); warum nach der klammer xcopy? warum alles unter " " <- text und dann %c darin, und am ende ziel, quelle?

system(xcopy); //der befehlsaufruf der nach der klammer definiert wurde?

Das wären jetzt mal so meine spontanen Fragen, da ich gern wüsste was ich meinem code steht *gg*

Danke im Vorraus
mfg
anonym

thordk

http://cppreference.com/stdio/sprintf.html
http://tutorial.schornboeck.net/arrays.htm

(sry für doppelpost, doch der letzte post ist interessant und wurde während ich geschrieben habe gepostet)

thordk, stimmt, warum sollte ich ein gemisch aus shell und c++ machen, wenn ich doch c++ lernen will, aber für die version 1 akzeptabel, nun haben ich ein neues ziel, dies mit boardmitteln zu schreiben

Wie ich an diese Sache rangehn soll habe ich noch wenig ahnung, doch ich werde mal googlen, wenn daweil "zufälligerweise" stichworte kommen, die helfen könnten/es tun, dann wäre da nett

doch bitte keine fertigen codeteile, nur bei anfrage, da ich eigentlcih das meiste selbst schreiben will, da dies wohl die effektiveste methode des lernen ists

danke im vorraus
mfg
anonym

PS: super board, super schnelle antworten, nette, sinnvolle antworten, 1A FORUM
lob an alle, das mus auch mal gesagt werden!!

*D*Evil

Das sind alles Fragmente aus C ... mein Code ist hingegen pur C++!

char xcopy[1024]; // warum 1024? Weil du damit nicht so leicht Gefahr läufst, dass das was am ende in xcopy steht zu viel für den Array ist.
sprintf(xcopy,"XCOPY %c:\*.* %c:\ /S /D /-Y",quelle,ziel);  //  wo %c steht wird ein char eingesetzt, der bei quelle angegeben wird. das 2. %c wird durch ziel ersetzt.

[cpp] #include <cstdlib> // std::system
#include <string> // std::string, std::getline
#include <iostream> // std::cout, std::cin
#include <sstream> // std::stringstream

int main()
{
std::cout << "Quelle: " << std::flush; // Quelle: ausgeben
std::string source; // String anlegen
std::getline(std::cin, source); // Mit std::cin alles bis zum nächsten '\n' einlesen und in unseren String packen
std::cout << "Ziel: " << std::flush; // Ziel: ausgeben
std::string dest; // String anlegen
std::getline(std::cin, dest); // Wieder einlesen ... diesmal in dest
std::ostringstream ss; // einen stringstream anlegen ... ist in etwa sprintf in C ...
ss << "XCOPY " << source << ". " << dest << "/S /D /-Y"; // Alles zusammen setzen ...
std::system(ss.str().c_str()); // std::system aufrufen (jap, auch system liegt im Namespace std ... man muss nur den richtigen Header nutzen!
}[/cpp]

Öhm und zum lernen ist sicherlich mein Code besser ... und auch sonnst.

Wenn ich deinen Code benutzte, kommt die Meldung:

Quelle: D
Ziel: K
Zyklische Kopie nicht möglich
0 Datei(en) kopiert
Drücken Sie eine beliebige Taste . . .

Was bedeutet das?

*D*Evil

hmm dann mach mal folgendes:

#include <cstdlib> // std::system
#include <string> // std::string, std::getline
#include <iostream> // std::cout, std::cin
#include <sstream> // std::stringstream

int main()
{
    std::cout << "Quelle: " << std::flush;
    std::string source;
    std::getline(std::cin, source); 
    std::cout << "Ziel: " << std::flush; 
    std::string dest;
    std::getline(std::cin, dest);
    std::ostringstream ss; 
    ss << "XCOPY " << source << "*.* " << dest << "/S /D /-Y";
    std::cout << "Command: " << ss.str() << std::endl; /* ! DAS ! */
    std::system(ss.str().c_str());
}

Und vergleich das was hinter "Command: " steht mit dem was du haben willst.

#include <cstdlib>
#include <string>
#include <iostream>
#include <sstream>

int main() 
{ 
    std::cout<<"Quelle: "<<std::flush; 
    std::string source; 
    std::getline(std::cin, source); 
    std::cout<<"Ziel: "<<std::flush; 
    std::string dest; 
    std::getline(std::cin, dest); 
    std::ostringstream ss; 
    ss<<"XCOPY "<<source<<":\*.* "<<dest << ":\ /S /D /-Y"; 
    std::cout<<"Command: "<< ss.str()<< std::endl;
    std::system(ss.str().c_str()); 
    std::cin.get();
}

Mit dieser Abänderung des Codes funktioniert alles super, danke, jetzt gilt es mir nur noch diese Hyroglyphen zu entziffern *gg*

std::cout ist mir schon unbekannt

ich kenne nur:

cout<<"text"<<endl;
cin>>var;
cin.get();

std steht ja für den namespace, der benötigt wird um ein/ausgabe zu machen, soweit ich das verstanden hab, aber wozu diese schreibweise? das ist mir ein rätsel mit:

std::cout<<"Quelle: "<<std::flush;

mfg
danke
anonym

so, habe jetzt eine seite gefudnen die diese schreibweise mit std::cout, flush,.. behandelt, und werde diese mal durchmachen, da ihr ja nicht alles beantwortn müsst

hier:

http://www.highscore.de/cpp/einfuehrung/

danke für allels
mfg
xiix

Melde mich morgen wieder

*D*Evil

hmm ...
also...

void foo()
{
    using namespace std;
    cout << "Bar" << endl;
}

void foo()
{
    std::cout << "Bar" << std::endl;
}

macht genau das selbe. Meiner Meinung nach legt man allerdings mit der using-direktive einen Namespace lahm. Denk mal bsw. an folgendes:

namespace foo
{
    void bar() { // ... // }
};

namespace abb
{
    void bar() { // ... // }
};

using namespace foo;
using namespace abb;

int main()
{
    bar(); // Na welche Funktion soll er denn jetzt nehmen?
}

deswegen gehen manche dann über den Umweg nur bestimmte Funktionen zu "usen"
=>

#include <iostream>

using std::cout;
using std::endl;

int main()
{
    cout << "Das geht!" << endl;
}

. Ich seh aber gerne in welchem Namespace ich welche Funktion habe!

<<std::flush;

ist in diesem Fall unnötig. std::cin flusht den Stream eh. Hmm ... beim flushen wird der Buffer geleert d.h. das was du reingepackt hast wird direkt ausgegeben.

Noch Fragen? Ich erkläre es dir gerne

ok, dann würde man eben einen namepsace lahm legen, doch meine frage, wozu benötige ich überhaut einen zweiten namespace?

mfg

CStoll

anonym schrieb:

doch meine frage, wozu benötige ich überhaut einen zweiten namespace?

Vor allem um Namenskollisionen zu vermeiden (die C++ Standardbibliothek ist riesig - da besteht immer die Gefahr, daß ein Bezeichner schon von einer externen Bibliothek verwendet wird).