4. Array übergeben

Array übergeben

  • A

    Hi

    Ich überegebe einer Funktion, besser gesagt einer Klasse einen CArray. Dies funktioniert ohne Probleme! Nun möchte ich aber den Array in einen anderen Array kopieren/ übergeben! (Der neue Array ist im Header und ich kann dann von allen Funktionen darauf zugreifen) Ich habe es schon mit pa_sprache(sprache);
    pa_sprache(&sprache);
    pa_sprache=sprache;
    pa sprache=&sprache;

    versucht aber keines funktioniert!
    Wie bringe ich es zu Stande, dass der gesammt Array dem neuen Array übergeben wird?

    0
  • M

    hi,

    ich weiß nicht genau, aber ich denke mal, pa_sprache ist jetzt n pointer. damit der auf das kopierte array zeigt, musst du das array erstmal kopieren ;). dazu erstmal den speicherplatz für das neue array anlegen und dann kopieren. dafür brauchst du erstmal den befehl malloc (für c), damit wird speicherplatz angelegt, dann memcpy, damit kopierste.

    probier mal, poste, was du gemacht hast, wenns nicht klappt 🙂

    viele grüße,

    mata

    0
  • A

    Sorry aber ich kapiere es nicht ganz!

    Also a_sprache diesen Array möchte ich in pa_sprache kopieren
    Ich benutze C++ und nicht C!

    Wie geht das genau?

    0
  • E

    Hallo,

    damit das Array kopiert werden kann, müssen die Elemente im Array den Copykonstruktor und den Zuweisungsoperator implementieren.

    Danach lassen sich die Array's problemlos kopieren.

    class Element : public CObject
{
public:
	Element(int value = 0) : m_value(value) {};
	~Element() {};

	Element(const Element& rElement)
		: m_value(rElement.m_value)
	{
	}

	Element& operator = (const Element& rElement)
	{
		if (this != &rElement)
		{
			m_value = rElement.m_value;
		}

		return *this;
	}

	int GetValue() const
	{
		return m_value;
	}

private:
	int m_value;

public:
	virtual void Dump(CDumpContext& dc) const;
};

void Element::Dump(CDumpContext& dc) const
{
	CObject::Dump(dc);

	dc << "Address: " << &m_value << "\tValue: " << m_value << "\n";
}

typedef CArray<Element> ElementArray;

// array lokal erzeugen...
ElementArray arr;
arr.Add(Element(1));
arr.Add(Element(2));
arr.Add(Element(3));
arr.Add(Element(4));
arr.Add(Element(5));

// array auf den heap erzeugen
ElementArray* p_arr = new ElementArray;

// lokales array in das auf den heap liegende array kopieren
p_arr->Copy(arr);

// array's vergleichen...
ASSERT(arr.GetCount() == p_arr->GetCount());
DEBUG_ONLY( arr.Dump(afxDump) );
DEBUG_ONLY( p_arr->Dump(afxDump) );
for (INT_PTR i = 0; i < arr.GetCount() && i < p_arr->GetCount(); ++i)
{
	arr.GetAt(i).Dump( afxDump );
	p_arr->GetAt(i).Dump( afxDump );
}

// array auf heap zerstören
delete p_arr;

    Hoffe damit kommst du weiter...

    Gruss

    0
  • E

    brauchst du wirklich nachher 2 verschiedene arrays (die inhalte differieren nachher)? wenn dem nicht so ist, dann setz lieber n 2. pointer auf das array.

    Esco

    0
  • A

    das habe ich versucht!
    Ich habe es so gemacht:

    void CDrucken::Print(CArray<CString,CString>* pArray)

    das funktionierte auch! Wenn ich aber nun z.B

    pArray[10]

    holen wollte, gab es einen Fehler beim Ausführen! (angeblich war nichts im Array)
    das Array war aber gefüllt, denn wenn man nut pArray eingab wurde angezeit dass 50 Einträge drin waren....

    Wo liegt denn da der Fehler?

    0
  • E

    Hallo,

    also erstmal mußt Du dich etwas klarer ausdrücken, was Du möchtest!
    Dein Titel lautet Parameterübergabe jedoch redest Du im Text von kopieren 😕

    So wie du es machen willst, funktioniert es so:

    void PushArrayByReference(CArray<CString, CString>& rArray)
{
	for (INT_PTR i = 0; i < rArray.GetCount(); ++i)
		TRACE(_T("%s\n"), rArray.GetAt(i));
}

void PushArrayByPointer(CArray<CString, CString>* pArray)
{
	for (INT_PTR i = 0; i < pArray->GetCount(); ++i)
	{
		TRACE(_T("%s\n"), pArray->GetAt(i));	
		TRACE(_T("%s\n"), (*pArray)[i]);	
	}
}

CArray<CString, CString> StringArray;
StringArray.Add(_T("Deutsch"));
StringArray.Add(_T("Englisch"));
StringArray.Add(_T("Spanisch"));
StringArray.Add(_T("Französisch"));
StringArray.Add(_T("Portugiesisch"));

PushArrayByReference(StringArray);

PushArrayByPointer(&StringArray);

    Für Strings gibt es übrigens eine fertige Klasse CStringArray

    void PushMfcStringArrayByReference(CStringArray& rArray)
{
	for (INT_PTR i = 0; i < rArray.GetCount(); ++i)
		TRACE(_T("%s\n"), rArray.GetAt(i));
}

void PushMfcStringArrayByPointer(CStringArray* pArray)
{
	for (INT_PTR i = 0; i < pArray->GetCount(); ++i)
	{
		TRACE(_T("%s\n"), pArray->GetAt(i));	
		TRACE(_T("%s\n"), (*pArray)[i]);	
	}
}

CStringArray MfcStringArray;
MfcStringArray.Add(_T("Deutsch"));
MfcStringArray.Add(_T("Englisch"));
MfcStringArray.Add(_T("Spanisch"));
MfcStringArray.Add(_T("Französisch"));
MfcStringArray.Add(_T("Portugiesisch"));

PushMfcStringArrayByReference(MfcStringArray);

PushMfcStringArrayByPointer(&MfcStringArray);

    Wenn Du das Array per Pointer übergibst und dann den Operator [] verwenden willst,
    mußt du den Zeiger vorher dereferenzieren!

    (*pArray)[i]

    oder die IMHO hässliche Variante über den Zeiger

    pArray->operator [](i)

    Falls das Array nicht verändert wird, sollte man die Parameterübergabe
    konstant machen.

    void PushArrayByReference(const CArray<CString, CString>& rArray)
// bzw.
void PushArrayByPointer(const CArray<CString, CString>* pArray)

    Das Du die Copy- und Zuweisungsfunktionen nicht selber schreiben
    mußt, liegt daran, weil dir die CString-Klasse der MFC das bereits alles
    abnimmt.

    Das sollte aber auf jedenfall helfen.

    Gruss

    0
  • A

    Zuerst wollte ich den Array kopiere....
    Es währe aber vie sinvoller, wenn ich einen Pointer auf den Array hätte und dann nur noch den Array auslesen könnte (Array[20] z.B
    Ich sehe es also richtig, dass ich dem Array zuerst mitteilen muss, dass er versch. Daten hat. [0],[1] etc.

    Wo muss ich den dann die Zeile

    (*pArray)[i]

    einfügen? Kommt die gleich im Funktionsname?

    0
  • E

    Hi,

    okay, ich glaube du verstehst die Parameterübergabe noch nicht...

    void CDrucken::Print(CArray<CString,CString>* pArray) // Array wird per Pointer übergeben!
{
    // Bei Zeiger zugriff auf Member per -> operator
    pArray->GetAt(0);
    pArray->GetCount(); // usw.

    // um auf das Objekt zu kommen muss der Zeiger derefenziert werden!
    CArray<CString, CString>& ArrayReference = *pArray; // * derefenziert Zeiger

    ArrayReference.GetCount();  // ArrayReference ist nun eine Referenz auf den Inhalt des Zeigers!

    ArrayReference[0]; // liefert das 0te Element im Array

    // oder eben in einem Schritt
    (*pArray)[0]; // ist gleich ArrayReference[0]

    // oder lieber hässlich
    pArray->operator[](0); // liefert auch das 0te Element
}
    0
Anmelden zum Antworten