Ich versuche schon seit einiger Zeit eine Funktion zu schreiben, wo ich ein String übergebe.

Beispiel:

#include <conio.h>
#include <iostream>
#include <windows.h>

using namespace std;

void Ausgabe(string *sParameter)
{ cout << sParameter << "\n";}

int main(void)
{
Ausgabe("Guten Tag!");
getch();
}

Doch es klappt einfach nicht.

Könnte mir jemand bitte helfen und ein besseren oder gar richtigen Weg vorschlagen?

Mit freundlichen Grüßen,
Understood.

void Ausgabe(string sParameter)
{ cout << sParameter << "\n";}

Also den String nicht per zeiger sondern einfach so übergeben.
Dann klappt es.

MfG, Jochen

void Ausgabe(const string& sParameter)
{ cout << sParameter << "\n";}

Hoffe konnte helfen.

Lg freeG

#include <iostream>
#include <windows.h>
#include <conio.h>
#include <cstdio>

void _Out(char* strPM)
{
	printf("%s",strPM);
}

int main(void)
{
	_Out("Guten Tag!");
	getch();
}

Lg freeG

1. Was bedeutet "new" und "delete", könntet Ihr mir es bitte in einem nicht zu sehr starkem Hochdeutsch erklären (oder einfach weniger Fachbegriffe nutzen), weil dann kapiere ich so ziemlich garnichts.

2. Was bedeutet es, wenn ich eine Klasse erstelle und dann dort eine Funktion reinschreibe, die überhaupt keinen Rückgabetyp hat, also noch nicht mal davorsteht "void" o.Ä. und danach ein ~Funktionsname(...); kommt?

Beispiel in der Klasse:

Funktions_Name(int sx, int sy, int s_width,int s_heigh);
~Funktions_Name();

Warum steht dort kein "void" o.Ä.?

Und die Funktion:

Curveball_Bot::Curveball_Bot(int sx=0, int sy=0, int s_width=GetSystemMetrics(SM_CXSCREEN),
int s_height=GetSystemMetrics(SM_CYSCREEN)) : p_found(false)
{
this->sy=sy;
this->sx=sx;
this->hdcDesktop=GetDC(0);
this->hdcMemory=CreateCompatibleDC(this->hdcDesktop);
this->s_width=s_width;
this->s_height=s_height;
}

MfG,
Understood.

Zu 1:
new und delete sind für die dynamische Speicherallokation zuständig. Also du forderst damit speicher für dein Objekt an bzw gibst ihn wieder frei. (im Heap)

Zu 2:
Das erste ist ein Konstruktor. Diese DÜRFEN keinen Rückgabetyp haben. Konstruktoren sind für die initialisierung deiner Objekte zuständig, also dafür sie in einen korrekten Anfangszustand zu versetzen.
Das ~Klassenname() ist dann der Destruktor. Der eben dafür da ist alle überreste deiner Klasse wieder abzubauen.

Beide müssen den EXAKT GLEICHEN NAMEN haben wie deine Klasse-

Aber wie gesagt am besten vo nem gescheiten Buch dir erklären lassen.

Alles geklärt und auch hilfreich.
Könntest Du mir eventuell ein Beispiel mit "new" und/oder "delete" geben?

#include <iostream> //wg. cout

int main()
{
    using namespace std;
    int* pI = new int(8); // legt eine int-Variable mit dem Inhalt 8 an.
    cout << "*pI = " << *pI << endl; // Inhalt von *pI ausgeben
    delete pI; // Speicher wieder freigeben
    return 0;
}

Gruß
Werner

class Obj
{
public:
Obj(){cout << "Objekt erzeugt" << endl;}
~Obj(){cout << "Destruktor aufgerufen" << endl;}
void Method(){/**/}
};

Obj* MyObj = new Obj; // Hier wird Speicher für das Objekt bereitgestellt und der Konstruktor aufgerufen
MyObj->Method(); // Methode aufrufen
delete MyObj; // Hier wird der Destruktor aufgerufen und der Speicher freigegeben.

//Und so kann man dynamische Arrays erstellen.

int* IntArray = new int[1000]; // Speicher für 1000 int-Werte reservieren
for(int i=0;i<1000;i++)IntArray[i]=i; // Array füllen (Nur so zum Spaß)
delete[] IntArray; // Speicher freigeben.

Ich hoffe, das ist so verständlich.

MfG, Jochen

1. Was bedeutet "new" und "delete", könntet Ihr mir es bitte in einem nicht zu sehr starkem Hochdeutsch erklären (oder einfach weniger Fachbegriffe nutzen), weil dann kapiere ich so ziemlich garnichts.

Ich kann leider nur Hochdeutsch, wenn ich versuche Dialekt zu schreiben, geht das schief. Denk dir den folgenden Text einfach mit sächsischer Aussprache:

Angenommen wir haben eine Klasse foo . Dann liefert uns new foo einen Zeiger auf einen foo. Aber nicht bloß irgendeinen Zeiger, sondern an der Stelle wo der Zeiger hinzeigt, ist tatsächlich ein gültiger foo, mit dem man dann ganz normal arbeiten kann. Das klingt ja erstmal nicht so spannend, denn statt

foo *pointer_auf_foo = new foo;
// ... Mit *pointer_auf_foo arbeiten...

hätten wir ja auch wie gewohnt

foo ein_foo;
// ... Mit ein_foo arbeiten...

schreiben können. Und das wäre auch richtig und daher gebraucht man new in der Regel dazu auch nicht.
Das kann man auch mit Arrays von foo machen:

foo *array_von_foo = new foo[5];
// entspricht (bis auf Kleinigkeiten):
foo array_von_foo[5];

// ...mit array_von_foo arbeiten...

Eigentlich immer noch nichts neues. Das lustige an der Sache ist nun, dass Arrays ja immer eine konstante Größe haben müssen, aber bei new braucht dies nicht so zu sein:

int groesse;
cin >> groesse;
foo *array_von_foo = new foo[groesse]; // Geht!
foo array_von_foo[groesse];  // Compilerfehler! (Geht bei manchen Compilern trotzdem als Zusatzfeature, ist aber nicht Standard)

Dies ist eine der Hauptanwendungen von new. Doch dies braucht man auch eher selten, da man in C++ ja std::vector hat und dieser eigentlich alle Bedürfnisse die man an dynamische Arrays hat, decken kann. Daher eine Fausregel: new braucht man nur ganz selten. Wenn du als Anfänger glaubst, new zu brauchen, dann glaubst du falsch.
Es gibt noch zwei andere Anwendungsgebiete von new, das erste ist technischer Art und könnte nur mit fachwörtern erklärt werden. Es geht dabei um die Größe von Objekten, new erlaubt einem größere Objekte (vom Speicherverbrauch her) anzulegen als die normalen Variablen:

long double *grosses_array = new long double[999999999999];  // Wird wahrscheinlich funktionieren (aber Rückgabewert trotzdem prüfen!)
long double grosses_array[999999999999];  // Programm wird in der Regel abstürzen

Die dritte und letzte Anwendung dreht sich um die Lebensdauer einer Variablen. Manchmal(d.h. ganz selten) hat man sehr spezifische Anforderungen an die Lebensdauer einer Variablen. Aus deinen Fragen schließe ich aber, dass eine Erklärung hier nicht viel nützen Würde, da dir die Grundlagen fehlen, um dies zu verstehen. Du wirst es höchstwahrscheinlich vorerst auch nicht benötigen.

Apropos Lebensdauer: Delete beendet die Lebensdauer eines Objekts, welches vorher mit new angelegt wurde, dass ist alles. Man sollte höchst genau darauf achten, dass zu jedem new das man macht, ganz genau ein delete ausgeführt wird (oder delete[], wenn man mit new ein Array angelegt hat).

2. Was bedeutet es, wenn ich eine Klasse erstelle und dann dort eine Funktion reinschreibe, die überhaupt keinen Rückgabetyp hat, also noch nicht mal davorsteht "void" o.Ä. und danach ein ~Funktionsname(...); kommt?

Das sind Konstruktoren und Destruktoren. Was das ist, kann man im Rahmen dieses Forums nicht erklären. Das Thema ist aber ungeheuer wichtig, ich empfehle dir ein Buch zu lesen.

Am Montag kriege ich meine Bücher wieder zu Gesicht und dann heißt es: lernen, lernen und lernen.

Mit freundlichen Grüßen,
Understood.

@SeppJ:
Auch wieder eine Danksagung an Dich.