Zeichenketten verbinden

[TekWarrior]

Wie kann ich zwei Zeichenketten verbinden?

Beide sind vom Typ TCHAR.

[cYrus]

CHAR = CHAR1 +CHAR2

sollte doch gehen oder wo ist das problem?

so long
cYrus

[TekWarrior]

Nein geht nicht.

Visual C++ 6.0:
error C2110: Zwei Zeiger koennen nicht addiert werden

Vielleicht hilft das weiter:
Beide sind vom Typ TCHAR [100].

[Felix Kaiser]

Probiers mal so:

Zeichenkette1 = strcat(Zeichenkette1,Zeichenkette2);

Musst natürlich strings.h über Include referenzieren. Sollte gehen.

[TekWarrior]

Ich hab eine Möglichkeit ohne Compiler Error gefunden, aber dafür stürzt es zur Laufzeit ab:

TCHAR str1[100],str2[100];
...
strcat(str1,str2);
...

[TekWarrior]

Lösung gefunden:

#include <TCHAR.h>

Damit wird strcat für TCHAR benutzt.

[MrEasy]

warum nicht so:

*char foo = char1 + char2;

[xOOn]

also mal zur aufkaerung:

in c++ gibt es (leider) mehr als einen string!

2 davon stind standard der alte char * und der neuerer std::string, und vc++ builder und co haben haeufig dann noch ihre eigenen strings!

ein char * ist nichts anderes als ein simpler array -> zeiger

char x[256], y[256];

dann ist x = x + y; ganz einfach

x zeigt auf speicherbereich 123, und y zeigt auf speicherbereicht 321 ->> x ist nach der zuweisung ein zeiger auf 444 und da denkt sich dann windows (oder zumindest sollte windows das), was will der typ in diesem speicherbereich das ist nicht seiner also weg mit dem dreck! ... Access Violated........

da das strcat strcpy und co ziemlich suck, haben die mal den std::string entworfen, der hat mit einem datentyp nichts gemeinsam, es ist einfach eine klasse, und bei klassen kann man operatoren definieren wie zB + ==, [], ...... und so weiter also bei den std::string kann man folgendes schreiben

string a,b;
string a = a + b; weil dann einfach der operator + vom string aufgerufen wird, der versteht das ganze und addiert die beiden strings, und den operator = kennt er auch, und deswegen kopiert er alles in a rein:

noch ein bsp fuerdie mitdenken warum funkt variante 1 und variante 2 nicht

1:
string a,b;
a = b + "aasjfl" + "gsklj";

2:
string a,b;
a = "aghjkhfghasdk" + b + "ashfjkh";

[Jan Krüger]

typkollision. "vjasdfhj" == char[] und b == string.
im ersten beispiel werden die char[]s nach string umgewandelt, im zweiten beispiel wird b nach char[] umgewandelt und schon kann man nix mehr addieren und nich mehr a zuweisen.
oder lieg ich da falsch? (bin c++ antiexperte) :D

[xOOn]

jepp da hast du recht;
auswertung von links nach rechts bei 1 ist das ein string also wird der + operator vom strig genommen und der kann char * mit string addieren oder er macht implizit cast, aber das ist egal. bei 2 ist es umgekehrt char * hat auch nen + operator, und der will char * als wird der string implizit cast nach char* gemacht und schon haben wir die scheisse

[Mephisto_I]

Hallo xOOn!

Original geschrieben von xOOn

noch ein bsp fuerdie mitdenken warum funkt variante 1 und variante 2 nicht

1:
string a,b;
a = b + "aasjfl" + "gsklj";

2:
string a,b;
a = "aghjkhfghasdk" + b + "ashfjkh";

Beide Varianten (_muessen_) funktionieren.

Wieso sollte 2 nicht funktionieren? Hast du es ausporbiert?

Gruss
Mephisto_I

[Mephisto_I]

Original geschrieben von xOOn
jepp da hast du recht;

Nein, leider stimmt das nicht. :confused:


auswertung von links nach rechts bei 1 ist das ein string also wird der + operator vom strig genommen und der kann char * mit string addieren oder er macht implizit cast, aber das ist egal. bei 2 ist es umgekehrt char * hat auch nen + operator, und der will char * als wird der string implizit cast nach char* gemacht und schon haben wir die scheisse

Es gibt einen Operator, der das kann:

template<class charT, class traits, class Allocator>
basic_string<charT,traits,Allocator>
operator+(const charT* lhs,
const basic_string<charT,traits,Allocator>& rhs);


Und selbst wenn es diesen nicht gaebe, wuerde der Compiler die beiden const char* implizit nach std::string casten, sodass nachher


std::string = std::string + std::string + std::string;


da seht.

Gruss
Mephisto_I

[xOOn]

@Mephisto_I

scheint zu funktionieren auch die 2. methode.
aber irgendwas war mal mit diesen strings!

der + operator kann bei der 2. methode nicht verwendet werden weil char * keinen hat, der arsch macht implizit cast!! warum is das bei mir nicht gegangen

[Mephisto_I]

Original geschrieben von xOOn
der + operator kann bei der 2. methode nicht verwendet werden weil char * keinen hat, der arsch macht implizit cast!!

Doch, er kann verwendet werden. Es ist ja nicht der Operator irgendeiner Klasse (char * oder std::string), sondern ein globaler Operator, der genau so aussieht:


template<class charT, class traits, class Allocator>
basic_string<charT,traits,Allocator>
operator+(const charT* lhs,
const basic_string<charT,traits,Allocator>& rhs);


Dieser Operator kann genau auf Fall 2 angewandt werden. Selbst wenn das nicht der Fall waere, koennte der Compiler aufgrund dieses _globalen_ Operators dann implizit casten, wie er lustig ist.

Alles klar? :)


warum is das bei mir nicht gegangen

Vielleicht hast du eine alte STL verwendet...

Gruss
Mephisto_I

[xOOn]

Builder 4:confused: :confused:

naja ok, dann funkt die 2. methode weil die richtigen operatoren vorhanden sind