ich habe eine Funktion, die mir alle möglichen Permutationen einer Zahl ausgibt. Nun möchte ich diese aber in einem Array speichern und nicht einfach ausgeben. So sieht der Quelltext aus:

#include <iostream>
#include <string>

using namespace std;

void permut(string str, int endIndex) 
{
    if(endIndex == 0)
		 cout << str << endl;
    else
       permut(str,endIndex-1);
       for(int i = 0; i<endIndex;i++)
	   {
		   std::swap(str[i],str[endIndex]);
           permut(str,endIndex-1);
           std::swap(str[i],str[endIndex]);
	   }
} 

int main()
{
    string str;
    cout << "Eingabe: ";
    cin >> str;
    permut(str, str.length()-1);

	return 0;
}

Ich möchte also, dass in einem die Array die Werte gespeichert werden, die durch die Rekursion ausgegeben werden.

Meine Frage:

1.) Wenn ich nicht std::vector nehmen möchte, gibt es eine saubere Möglichkeit, mit einem dynamsichen Array zu arbeiten. Ich weiß nämlich bis zum letzten SChritt der Rekursion nicht, wie viele Elemente das Array hat. Dann müssten irgendwie alle Werte da drin gespeichert werden.

2.) Wo müsste ich ein dynmaisches Array überhaupt deklarieren? In der Rekursion kann das ja nicht gemacht werden, sonst würde das ja ganz schön häufig passieren.

Vielen dank
lg, freakC++

void permut(string str, int endIndex, std::vector<std::string>& v)

Ich habe jedoch noch ein ganz anderes Problem: Das obige Progrmam habe ich jetzt mal mit vector gemacht. Es sieht dann so aus:

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

using namespace std;
std::vector<string> num;  

void permut(string str, int endIndex) 
{
	if(endIndex == 0) {
		num.push_back(str);
		//cout << str << endl;
	}
    else
       permut(str,endIndex-1);

       for(int i = 0; i<endIndex;i++)
	   {
		   std::swap(str[i],str[endIndex]);
           permut(str,endIndex-1);
           std::swap(str[i],str[endIndex]);
	   }
} 

int main()
{
    string str;
    cout << "Eingabe: ";
    cin >> str;
    permut(str, str.length()-1);
    cout << num.capacity();
	return 0;
}

Ich gebe jetzt die Anzahl aller Elemente aus - also n!. Wenn ich eine dreistellige Zahl eingebe, dann erscheint 6. Das ist richtig. Wenn ich jedoch eine vierstellige Zahl geben kommt nich 4! = 24, sondern 28. Bei einer fünfstelligen Zahl erscheint eine 141 und nicht 120. Da ist also noch ein Fehler, den ich aber nicht sehe. Sieht von euch jemand diesen logischen Fehler?

edit: @!!! In einem anderen Thread wurde mir diese Funktion bereits vorgeschlagen. Ich habe mich aber entschieden, die Permutationen per Hand selber zu programmieren

Vielen Dank
lg, freakC++

#include <string>
#include <iostream>

using namespace std;

class MyArray
{
private:
	std::string *arr;
	unsigned int size;
	unsigned int pos;

	static const int BLOCK_SIZE;

public:
	MyArray() : arr(NULL), size(BLOCK_SIZE), pos(0)
	{
		arr = new std::string[size];
	}

	~MyArray()
	{
		delete[] arr;
	}

	// !!! Copy Constructor, etc. fehlen !!!

	void Push(const std::string& str)
	{
		if (size >= pos)
		{
			Resize(size + BLOCK_SIZE);
		}

		arr[pos] = str;

		++pos;
	}

	void Resize(unsigned int newSize)
	{
		std::string *tmp = new std::string[newSize];

		for (unsigned int i = 0; i < size; ++i)
		{
			tmp[i] = arr[i];
		}

		delete[] arr;

		arr = tmp;

		size = newSize;
	}

	std::string At(unsigned int i)
	{
		return arr[i];
	}

	unsigned int FilledSize() const
	{
		return pos;
	}

	unsigned int TotalSize() const
	{
		return size;
	}
};

const int MyArray::BLOCK_SIZE = 32;

// ----------------------------------------------

void permut(string str, int endIndex, MyArray& arr)
{
    if(endIndex == 0)
	{
		arr.Push(str);
	}
    else
       permut(str,endIndex-1, arr);
       for(int i = 0; i<endIndex;i++)
       {
           std::swap(str[i],str[endIndex]);
           permut(str,endIndex-1, arr);
           std::swap(str[i],str[endIndex]);
       }
}

int main()
{
	MyArray arr;

    string str;
    cout << "Eingabe: ";
    cin >> str;

    permut(str, str.length()-1, arr);

	for (unsigned int i = 0; i < arr.FilledSize(); ++i)
	{
		std::cout << arr.At(i) << std::endl;
	}

    return 0;
}

Als Übung ist sowas okay, aber in der Praxis ist das mehr als schwachsinnig! Das Beispiel ist wegen des fehlenden Copy Constructors, etc. nicht vollständig!

Wenn ich eine dreistellige Zahl eingebe, dann erscheint 6. Das ist richtig. Wenn ich jedoch eine vierstellige Zahl geben kommt nich 4! = 24, sondern 28. Bei einer fünfstelligen Zahl erscheint eine 141 und nicht 120. Da ist also noch ein Fehler, den ich aber nicht sehe. Sieht von euch jemand diesen logischen Fehler?

Die Grösse eines Vectors bestimmt man durch .size() und nicht durch .capacity(). Letzeres gibt dir die Anzahl allokierter (und noch ungebrauchter) Elemente an.

Weißt Du oder jemand anderes denn, warum bei mir falsche Werte ausgegeben werden? Das Problem habe ich in meinem vorherigen Post beschrieben.

Vielen Dank
lg, freakC++

Das wusste ich nicht. Ich bin verglichen mit euch noch ein Anfänger und habe mit der STL noch nie gearbeitet. Deswegen bin ich noch ein Freund von dynamischen Arrays.

Danke! Jetzt funtionierts.

lg, freakC++

Als Übung und zum besseren Verständnis ist es aber nett, wenn man sowas mal selber bastelt. Macht ja auch irgendwie Spaß

Macht ja auch irgendwie Spaß

Das sehe ich eben genau so!

Vielen Dank
lg, freakC++