# include <iostream>
using namespace std; 
void main ()
{
	char A[6];
	char B[5];
	int t=0;
    char C[11];
    int counter=0;

	for (int i=0;i<6;i++)
		cin>>A[i];
	for (i=0;i<5;i++)
		cin>>B[i];

	for (i=0;i<6;i++)
	{ for (int j=0;j<6;j++)

	{
		if (B[i]==A[j])
			counter++;}
	if (counter==0)
	{B[i]=C[t];
	t++;
	counter=0;}
	}
	for (i=0;i<6;i++)
		cout << A[i];
	for (i=0;i<t;i++)
		cout <<C[i];
}

vielen dank

Das ist der Fehler, main muss int zurück geben.

Das war nicht der Fehler? Dann wäre es vielleicht ganz hilfreich, wenn du sagst, was der Fehler ist, den wir suchen sollen.

P.S.: Gah! Welcher Compiler kann denn den Code compilieren? Der verletzt ja so ziemlich alle Regeln. Hast du da irgendetwas von 1993 ausgegraben?

int main()
{
  while(1)
  {
   ...
  }

}

Wobei da sagt mein Compiler nicht die Funktion main muss einen Wert zurückgeben anscheind erkennt er die main.

Und wenn er sowas hätte?^^

Dein Programm darf auch endlos laufen, der Rückgabetyp der Funktion muss aber trotzdem stimmen. Das ist einfach technische Notwendigkeit.

(Jetzt Superklugscheißermodus:

int main()
{
  while(1)
  {
   ...
  }

}

Falls das "..." wirklich gar nichts wäre (genauer gesagt: etwas was weder das Programm beendet, noch etwas ausgibt, noch ein volatile Objekt verändert, noch eine Synchronisierungsoperation vornimmt), dann ist das Verhalten undefiniert.

Ende Superklugscheißermodus)

hallo
kann mir einer von euch den fehler in diesem programm zeigen?
in diesem Programm soll ich aus 2 eingegeben char. arrays ein array machen. das neue array soll aber die doppelten buchstaben nicht wiederholen
also z.b
[A]=A B C D E F
[B]=D E F G H I
das neue array soll so aussehen
[C]=A B C D E F G H I

[cpp]# include <iostream>
using namespace std;
void main ()
{
char A[6];
char B[5];
int t=0;
char C[11];
int counter=0;

for (int i=0;i<6;i++)
cin>>A[i];
for (i=0;i<5;i++)
cin>>B[i];

for (i=0;i<6;i++)
{ for (int j=0;j<6;j++)

{
if (B[i]==A[j])
counter++;}
if (counter==0)
{B[i]=C[t];
t++;
counter=0;}
}
for (i=0;i<6;i++)
cout << A[i];
for (i=0;i<t;i++)
cout <<C[i];
}[/cpp]

vielen dank

Das ist doch prinzipiell sehr einfach. Du fügst beide Array-Inhalte in eine [c]std::list<charTyp>[/c] und führst sort() (hier nehme ich an dass du keinen eigenen Funktor als Vergleichs-Objekt übergeben hast, der die Elemente nicht nach Größe Ordnet) und anschließend unique() aus.

Anschließend ziehst du das ganze zurück in ein neues, am besten allokiertes char-array (oder gleich std::string ) ein.

P.S.: Wenn du den unterliegenden Container zu string änderst ist schon besser, aber du hast immer noch zwei Zusatzschritte, die du überhaupt gar nicht bräuchtest.

@Hacker: Was hast du eigentlich immer mit deiner std::list? Die ist hier (wie fast immer) total unangebracht. std::list + std::sort + std::unique = std::set, bloß 999999999999999 Mal ineffizienter.

Oder mein obiger Post. Und was heißt bitte "Was hast du eigentlich immer..."?

Oder mein obiger Post. Und was heißt bitte "Was hast du eigentlich immer..."?

Vielleicht verwechsele ich dich gerade mit jemandem, aber irgendwie habe ich das Gefühl, dass du in letzter Zeit dauernd total umständliche Sachen vorschlägst und sehr oft eine list darin vorkommt.

P.S.: Gah! Welcher Compiler kann denn den Code compilieren? Der verletzt ja so ziemlich alle Regeln. Hast du da irgendetwas von 1993 ausgegraben?

VS2010. Also bis auf die Tatsache dass i nur in der ersten Schleife definiert ist.

Zu deinem Programm:

for (i=0;i<6;i++)
{
    for (int j=0;j<6;j++)
    {
        if (B[i]==A[j]) // Speicherzugriffsfehler

B[i]=C[t]; // Andersrum

in C werden nie Werte geschrieben.

Ich hätte das (bei dem Ansatz) so gelöst: (Wobei die Ausgabe recht umständlich ist)

# include <iostream>
#include <vector>
#include <string>

using namespace std; 
void main ()
{
	string A,B;
	vector<char> C;
	bool exists=false;
	cin>>A;
	cin>>B;

	for (unsigned int i=0;i<A.size();i++)
	{ 
		C.push_back(A[i]);
	}
	for (int i=0;i<B.size();i++)
	{ 
		for (int j=0;j<A.size();j++)
		{
			if (B[i]==A[j])
				exists=true;
		}
		if (!exists)
			C.push_back(B[i]);
		else
			exists=false;
	}
	char*text=new char[C.size()+1];
	text[C.size()]='\0';
	memcpy( text, &C[0], C.size() );
	cout <<text;
	delete text;
}

Hacker schrieb:

Oder mein obiger Post. Und was heißt bitte "Was hast du eigentlich immer..."?

Vielleicht verwechsele ich dich gerade mit jemandem, aber irgendwie habe ich das Gefühl, dass du in letzter Zeit dauernd total umständliche Sachen vorschlägst und sehr oft eine list darin vorkommt.

HÄ!? Meinst du PI? Der liebt nähmlich die std::list (er hat mir gesagt, std::list ist sehr sexy).

Aber schau mal hier, mein Vorschlag ist Drei mal Schneller als deiner:

Mein Vorschlag:

#include <iostream>
#include <string>
#include <algorithm>

int main()
{
      char const firstStr [] = {"ABCDEF"},
                 secondStr[] = {"CDEFGHI"};

      std::string output = firstStr;
      output += secondStr;
      std::sort(output.begin(), output.end());
      output.assign(output.begin(), std::unique(output.begin(), output.end()));
}

HÄ!? Meinst du PI? Der liebt nähmlich die std::list (er hat mir gesagt, std::list ist sehr sexy).

Ist sie auch. Aber nur aus Sicht eines STL-Implementers (gibts dafür ein ordentliches, deutsches Wort?). std::vector ist langweilig, std::deque viel zu viel Frickelei. Und trotzdem schlag ich im Normalfall keine std::list vor.

Hacker schrieb:

Aber schau mal hier, mein Vorschlag ist Drei mal Schneller als deiner:

Mein Vorschlag:

...

Warum erzeugst du überhaupt std::strings? kannst du das nicht ohne?
(Übrigens: Das schreit geradezu nach einem Template-Metaprogramm.)

#include <iostream>

namespace tmp
{
        template <char...>
        struct string
        {
                static char const c_str[];
        };

        template <char... S>
        char const string<S...>::c_str[] = { S..., 0 };

        template <typename T>
        struct valdef
        {
                typedef T value;
        };

        template <typename, typename>
        struct concat;

        template <char... S1, char... S2>
        struct concat<string<S1...>, string<S2...>>
                : valdef<string<S1..., S2...>>
        {};

        template <char, typename>
        struct push_front;

        template <char C, char... S>
        struct push_front<C, string<S...>>
                : valdef<string<C, S...>>
        {};

        template <char, typename>
        struct remove;

        template <char C>
        struct remove<C, string<>>
                : valdef<string<>>
        {};

        template <char C, char Head, char... Tail>
        struct remove<C, string<Head, Tail...>>
                : valdef
                <
                        typename push_front
                        <
                                Head,
                                typename remove<C, string<Tail...>>::value
                        >::value
                >
        {};

        template <char C, char... Tail>
        struct remove<C, string<C, Tail...>>
                : valdef<typename remove<C, string<Tail...>>::value>
        {};

        template <typename>
        struct unique;

        template <>
        struct unique<string<>>
                : valdef<string<>>
        {};

        template <char Head, char... Tail>
        struct unique<string<Head, Tail...>>
                : valdef
                <
                        typename push_front
                        <
                                Head,
                                typename unique
                                <
                                        typename remove<Head, string<Tail...>>::value
                                >::value
                        >::value
                >
        {};
}

int main()
{
        typedef tmp::string<'A', 'B', 'C', 'D', 'E', 'F'> first;
        typedef tmp::string<'D', 'E', 'F', 'G', 'H', 'I'> second;

        std::cout << tmp::unique<tmp::concat<first, second>::value>::value::c_str;
}

Die Ausgabe ist wie vom TE erwartet. http://ideone.com/7ka9p

Zu beachten gilt, dass ich hier das Ergebnis nicht sortiere, da dies nicht explizit verlangt war. Es war nur verlangt, Duplikate zu entfernen.

Des Weiteren ist der ganze Template-Schrott hier in einem Namespace tmp, damit es bei Ideone kompiliert. Ansonsten kollidiert remove mit einer globalen Funktion remove, von der ich keine Ahnung habe, woher sie kommt.

Des Weiteren ist der ganze Template-Schrott hier in einem Namespace tmp, damit es bei Ideone kompiliert. Ansonsten kollidiert remove mit einer globalen Funktion remove, von der ich keine Ahnung habe, woher sie kommt.

Jup, irgendwie ist Ideones GCC komisch.. für Trigraph-Sequenzen muss man sogar ein Flag angeben (was ich natürlich nicht kann).
Werd mich jetzt mal hinsetzen und deinen Code analysieren

Jup, irgendwie ist Ideones GCC komisch.. für Trigraph-Sequenzen muss man sogar ein Flag angeben (was ich natürlich nicht kann).

Das ist beim GCC ganz normal.

Hacker schrieb:

Jup, irgendwie ist Ideones GCC komisch.. für Trigraph-Sequenzen muss man sogar ein Flag angeben (was ich natürlich nicht kann).

Das ist beim GCC ganz normal.

Bei meinem muss man das aber nicht...