C++ OOP Ringbuffer: gespeicherte Werte ausgeben (?)

Guten Abend,
ich sitze hier etwas ratlos an einer Aufgabe und brauche dringend einen Denkanstoß.
Aufgabe:
Schreibe eine Methode, die alle Elemente ausgibt, die tatsächlich in einem Ringpuffer gespeichert sind.
Schleife schreiben, die auf alle gespeicherten Elemente zugreift und diese mit cout ausgibt.
Lese -und schreib-index dürfen nicht verändert werden.
----------------------------------------------------------------------------------
Mit einem Ringbuffer hatte ich bisher nichts zu tun und kenne mich daher nicht wirklich mit der Materie aus.

Wie kann ich auf eine gespeichertes Element zugreifen?

Vielen Dank für die Hilfe!

cooky451

lol, es gibt nicht den Ringpuffer. Deine Frage kann man so nicht beantworten.

pumuckl

Ohne das Interface des Ringpuffers zu kennen kann man dir nicht helfen.

ersteinmal vielen dank, für die schnellen antworten!
Ich versuche die problemstellung etwas ausführlicher zu beschreiben.
Ich habe bereits folgende Klasse CRingBuffer:

class CRingBuffer
{
      private:
      int* m_pBuffer;   // Startadresse
      int m_nSize;   // max. Anzahl der Elemente (Datenbereich)
      int m_cntFilled;  // Anzahl aktueller Elemente (Füllstand)
      int m_idxWrite;   // Schreib-Index
      int m_idxRead;    // Lese-Index

      public:
      void CRingBuffer(int nSize);
      ~CRingBuffer();
      bool put(int nData);
      bool get(int& nData);
      void print();
      void clear();
};

Meine Methode

void print();

soll mir nur die Elemente ausgeben, die tatsächlich im Ringpuffer gespeichert sind.
Die gespeicherten Elemente sind die Elemente, die mit der Methode void put(); in den Buffer geschrieben wurden, aber noch nicht mit der Methode "get" ausgelesen wurden.
Das ganze soll dann über eine Schleife funktiontionieren.

Ich hoffe die Problemstellung wurde nun klarer.
Vielen Dank!

hier noch einige Grundüberlegungen.
Wann ist der Buffer voll?

m_cntFilled == m_nSize 
m_idxRead == m_idxWrite && m_cntFilled > 0

Wann enthält er Daten?

m_cntFilled > 0
m_idyWrite != m_idxRead || m_cntFilles > 0

pumuckl

Ich nehme mal an, dass m_idxWrite und m_idxRead die Stellen kennzeichnen, wo als nächstes beim put/get ein int eingefügt/rausgelöscht wird. Den Ringpuffer kannst du dir also in etwa so vorstellen:

|X|X|X|X|1|2|4|6|7|X|X|X|

, wobei die Zahlen den Inhalt des Puffers darstellen und die X unbelegten Speicher des Puffers.
m_idxWrite "zeigt" dann auf das erste X nach den Zahlen (wäre im Beispiel also 9).
m_idxRead "zeigt" auf die erste Zahl (wäre also 4).

Jetzt überleg dir, wie du nur an die Zahlen drankommst. Welcher Bereich des internen Arrays ist das? Die dann auszugeben dürfte einfach sein.

Wenn du das hast, hast du den trivialen Fall. Komplizierter sind die folgenden Fälle, für die dur dir auch noch was überlegen musst:

|X|X|X|X|X|X|X|1|2|4|6|7|

(m_idxRead = 8, m_idxWrite=0)

|6|7|X|X|X|X|X|X|X|1|2|4|

(m_idxRead = 10, m_idxWrite=2)

Das sollte dir weiterhelfen

Josh.Schr.

müsste man nicht einfach so ne schleife machen?:

solange read < write
m_cntFilled ausgeben
m_cntFilled+1

jetzt müsste man nur noch m_cntFilled nen startwert mitgeben.

m_nBuffer -> m_cntFilled
m_nBuffer+1

zum verstädnis war dein beitrag sehr hilfreich.
jedoch weiß ich nicht, wie ich das nun in c++ umsetzen kann.

die schleifen-idee kann so nicht funtkionieren, es kann nämlich sein, dass write_index auch einmal kleiner als read_index ist.

der trick bei dieser aufgabe wird es wahrscheinlich sein, den pointer m_nBuffer auf nData laufen zu lassen.
in nData befinden sich die informationen (also die Zahlen).

meine schleifen-idee wäre nun:

while(m_cntFilled < m_nSize) { // Füllstand kleiner als max. Elemente
if(m_cntFilled <= 0) // Puffer enthält keine Daten 
}

aber die zündende idee kam mir noch nicht.

Kann meinen Text leider nicht bearbeiten.

Den Source oben bitte ignorieren! ; )

pumuckl

LordVoodoo schrieb:

die schleifen-idee kann so nicht funtkionieren, es kann nämlich sein, dass write_index auch einmal kleiner als read_index ist.

Das wäre dann der Sonderfall, von dem ich oben gesprochen habe. Tip: mit zwei Schleifen ists dann zu schaffen

LordVoodoo schrieb:

der trick bei dieser aufgabe wird es wahrscheinlich sein, den pointer m_nBuffer auf nData laufen zu lassen.

Nein! m_nBuffer ist ein Zeiger auf das verwaltete Array, den brauchst du später, um das Array wieder freizugeben. Also Finger weg

Josh.Schr.

gibts was neues zum thema?

Programm ist fertig & wurde erfolgreich getestet!

Vielen Dank Pumuckl für die Denkanstöße!

[Kann geschlossen werden]

delete Topic // :)

Josh.Schr.

// .h File
#ifndef CRingBuffer_H
#define CRingBuffer_H

using namespace std;

	// TODO: Fügen Sie hier Funktionsprototypen oder Klassendefinitionen ein

class CRingBuffer {

private:
	int* m_pBuffer;
	int m_nSize;
	int m_cntFilled;
	int m_idxWrite;
	int m_idxRead;
	bool m_return;
	int m_nOutput;

public:

	CRingBuffer(int nSize = 10);
	~CRingBuffer();
	bool put(int nData);
	bool get(int& nData);
	void print();
	void clear();
};

#endif

// .cpp File

// GIT-Labor
// CRingBuffer.cpp

////////////////////////////////////////////////////////////////////////////////
// Header-Dateien
#include <iostream>		// Header für die Standard-IO-Objekte (z.B. cout, cin)
#include <stdlib.h>
// TODO: Fügen Sie hier weitere benötigte Header-Dateien ein

using namespace std;	// Erspart den scope vor Objekte der
						// C++-Standard-Bibliothek zu schreiben
						// z.B. statt "std::cout" kann man "cout" schreiben

// Ihr eigenes h-File wird includiert
#include "CRingBuffer.h"

////////////////////////////////////////////////////////////////////////////////
// Funktionen oder Klassen

// TODO: Implementieren Sie hier die Methoden der Klassen

CRingBuffer::CRingBuffer(int nSize)
{
	if(m_nSize > 0)
	{
		m_nSize = nSize;
	}

	else
	{cout << "Groesse des Ringpuffers ist unzulaessig!" << endl << endl;}

	m_pBuffer = new int[m_nSize];

	m_return = false;

	m_nOutput = 0;

	CRingBuffer::clear();

}

CRingBuffer::~CRingBuffer()
{
	delete [] m_pBuffer;
}

void CRingBuffer::clear()
{
   m_cntFilled = 0;
   m_idxWrite = 0;
   m_idxRead = 0;

   for (int i=0; i<m_nSize; i++)
   {
	   m_pBuffer[i] = 0;
   }
}

bool CRingBuffer::put(int nData)
{
  if(m_cntFilled == m_nSize)
  {
	  cout << "Schreiben war nicht moeglich -> Puffer voll!" << endl;

	  return false;
  }

  else
  {
      m_pBuffer[m_idxWrite] = nData;
      m_cntFilled++;
      m_idxWrite++;

      if (m_idxWrite >= m_nSize)
      {
    	  m_idxWrite = 0;

    	  return true;
      }

      else
      {
    	  return true;
      }
  }
}

bool CRingBuffer::get(int& nData)
{
	if(m_cntFilled == 0)
	  {

		  m_return = false;

		  cout << "Lesen war nicht moeglich -> Puffer leer!" << endl;

		  return false;
	  }

	  else
	  {

	      nData = m_pBuffer[m_idxRead];
	      m_nOutput = nData;
	      m_cntFilled--;
	      m_idxRead++;

	      if (m_idxRead >= m_nSize)
	      {
	    	  m_idxRead = 0;

	    	  m_return = true;

	    	  return true;

	      }

	      else
	      {

	    	  m_return = true;

	    	  return true;
	      }
	  }

}

void CRingBuffer::print()
{
	int z = 0;

  if(m_idxRead<=m_idxWrite)
  {
	  for (int i=m_idxRead; i<(m_idxWrite); i++)
	  {
		  cout << "Speicherstelle: " << z << ": " << m_pBuffer[i] << endl;

		  z++;

		  if(z == 5)
		 			  {
		 				  z = 0;
		 			  }
	  }
  }

	  else
	  {
		  for (int i=m_idxRead; i<(m_idxWrite + (m_nSize+1)); i++)
		  {

			  cout << "Speicherstelle: " << z << ": " << m_pBuffer[(i%m_nSize)] << endl;

			  z++;

			  if(z == 5)
			  {
				  z = 0;
			  }

		  }
		  }

  cout << "Fuellstand: " << m_cntFilled << endl;
  cout << "Lese-Index: " << m_idxRead << endl;
  cout << "Schreib-Index: " << m_idxWrite << endl << endl;

  if (m_return == true)
  {
	  cout << "Gelesener Wert: " << m_nOutput << endl << endl;

	  m_return = false;
  }

}

Freue mich auf Verbesserungs-Vorschläge