Nun, mein Programm sieht folgendermaßen aus:

#include <iostream>
#include <cstring>
using namespace std;

int main()
{
	char wort[15];
	strcpy(wort,"Hallo");
	cout << wort;
	cout << "\n" << strlen(wort);
	strcat(wort," Welt!");
	cout << "\n" << wort;
	cout << "\n" << strlen(wort);

	std::cin.clear();
	std::cin.ignore( std::cin.rdbuf()->in_avail() );
	std::cin.get(); 
	return 0;
}

Mein Compiler (Visual C++ Express Edition) sagt mir, dass "strcpy" und "strcat" veraltet ist, wie heißen denn die "neuen" Versionen?

MfG
Luinechor

std::string(wort,"Hallo");

Da bekomm ich ne Fehlermeldung...^^
Und was ist dann mit strcat?

Wie die "neue" Funktion heisst, steht in der Compilermeldung übrigens direkt neben der Behauptung, dass die Funktion veraltet ist - aber wie gesagt: Das ist Microsofts Meinung. Glaube nicht, dass Du das Programm mit den neuen Funktionen noch irgendwo anders übersetzt bekommst.

(Darauf, dass ein OO-Buch mit Char-Arrays statt mit std::strings anfängt, sollte es denn so sein, gehe ich an dieser Stelle zur Abwechslung mal nicht ein).

EDIT:
Gleich mal nen Grundkurs in Fragen stellen: "...bekomme ich ne Fehlermeldung" ist nicht aussagekräftig

Und zum Thema "wie schreibt man das":

#include <iostream>
#include <string> // <-
using namespace std;

int main()
{
    string wort; // <-
    wort = "Hallo"; // <-
    cout << wort;
    cout << "\n" << wort.length(); // <-
    wort += " Welt!"; // <-
    cout << "\n" << wort;
    cout << "\n" << wort.length(); // <-

    std::cin.clear();
    std::cin.ignore( std::cin.rdbuf()->in_avail() );
    std::cin.get();
    return 0; 
}

- Luinechor

Edit:
Jo, das weiß ich, dass das nicht aussagekräftig ist, allerdings muss ich erstmal wissen, wie es geschrieben wird/wie man es verwendet, wenn DANN noch eine Fehlermeldung kommt, dann muss sie natürlich aussagekräftiger sein.

#include <iostream>
#include <string> // <-

int main()
{
    std::string word("Hallo");
    std::cout << word << std::endl;
    std::cout << "String-Laenge: " << word.length() << std::endl;
    word += " Welt!";
    std::cout << word << std::endl;
    std::cout << "String-Laenge: " << word.length() << std::endl;

    std::cin.clear();
    std::cin.ignore(std::cin.rdbuf()->in_avail());
    std::cin.get();
    return 0;
}

so sollte das eigentlich auch gehen ...

Wie die "neue" Funktion heisst, steht in der Compilermeldung übrigens direkt neben der Behauptung, dass die Funktion veraltet ist

Wie heist den die Funktion die man, laut MS, nehmen sollte?

errno_t strcpy_s(
   char *strDestination,
   size_t numberOfElements,
   const char *strSource 
);
errno_t strcat_s(
   char *strDestination,
   size_t numberOfElements,
   const char *strSource 
);

weil durch die neuen bibos die cout anweisung in einem namensraum liegt -> std;

die namensräume wurden eingeführt damit es keine überschneidungen der variablen bei großen projekten gibt.

Ich benutze immer "using namespace std;", damit muss man dann std:: nicht hinschreiben, warum machen es dann doch immer alle?
Bin da grad ein bisschen verwirrt (kann in C++ noch fast nix, hab erst angefangen..^^)

PS:
Bei mir steht neben der Warnung (also das sie veraltet ist) nichts, nur dass es veraltet ist.^^

Öh, und was macht "std::endl;" ?

Es macht einen Zeilenwechsel und zusätzlich macht es, dass die Ausgabe direkt auf dem Schirm erscheint, da cout gepuffert ist.

Ich benutze immer "using namespace std;", damit muss man dann std:: nicht hinschreiben, warum machen es dann doch immer alle?

Kann man auch machen, nur in Headerdateien sollte man "using namespace" vermeiden. Ich denke bei so Lehrbuchbeispielen ist es nicht verkehrt, den Ursprung dazuzuschreiben, im Zweifel denk es dir einfach weg

PS:
Bei mir steht neben der Warnung (also das sie veraltet ist) nichts, nur dass es veraltet ist.^^

Jo, sorry, mein Fehler.
Um den Ergänzungstext zu sehen klicke mal unter den Fehlermeldungen auf den Reiter "Ausgabe". Falls der Reiter nicht vorhanden ist über das Menü Ansicht->Ausgabe aktivieren, dann siehst Du was ich meinte

weil durch die neuen bibos die cout anweisung in einem namensraum liegt -> std;

die namensräume wurden eingeführt damit es keine überschneidungen der variablen bei großen projekten gibt.

Da hast du doch die Antwort.
Je nachdem wie viele Header du einbindest kommen uU schon sehr viele std:: funktionen zusammen, deren Namen du nicht verwenden solltest wenn du using namspace std hast.

Außerdem hast du mit dem std:: immer auf den ersten Blick die Übersicht was stdlib - Funktionen sind und was nicht.

[OT]
gibt es was vergleichbares zu std::endl für "\t" ich hatte endl bei meinen ersten gcc-Projekten immer per #define endl "\n", da MSVC an einigen stellen auch ohne das std:: Übersetzt.

btw. strcpy_s und strcat_s sind nicht Standard konform und auf anderen Systemen wird zB strlcpy und strlcat als sichere Funktionen angeboten.

@darthdespotism
ne, endl ist kein #define endl '\n'

Schau dir mal an, was endl genau macht.

Ich habe mir aber dann für '\t' ein #define angelegt (#define TAB '\t') hat er gemeint das wäre irgendwie vom Standart verboten (g++ 4.1) daher dachte ich gibts hier vll auch einen festen std::

Ich habe mir aber dann für '\t' ein #define angelegt (#define TAB '\t') hat er gemeint das wäre irgendwie vom stan**** verboten (g++ 4.1) daher dachte ich gibts hier vll auch einen festen std::

Was spricht dagegen, eine Konstante anzulegen?

namespace constants {
    char const tab = '\t';
    char const wtab = L'\t';
};

Ich kann es mir übrigens nicht verkneifen, noch eine Bemerkung zum OP-Problem zu machen: Die "neue" Version von 'strcpy' lautet 'operator =', die von 'memcpy' lautet 'std::copy' (!).

darthdespotism schrieb:

Ich habe mir aber dann für '\t' ein #define angelegt (#define TAB '\t') hat er gemeint das wäre irgendwie vom stan**** verboten (g++ 4.1) daher dachte ich gibts hier vll auch einen festen std::

Was spricht dagegen, eine Konstante anzulegen?

namespace constants {
    char const tab = '\t';
    char const wtab = L'\t';
};

Wenn schon, dann bitte const wchar_t wtab = L'\t'

Im Zusammenhang mit endl sollte ich vielleicht noch flush erwähnen - der schickt den Inhalt des Ausgabepuffers ans System, ohne vorher etwas zu schreiben ( cout<<endl; ist letztendlich cout<<'\n'<<flush; ).