ich würde gerne einen Array an eine Funktion übergeben.
In dieser Funktion soll der letzte Wert gelöscht werden und die restlichen Werte um eins nach hinten verschoben werden.
An die Stelle "null" soll jetzt ein neuer Wert eingefügt werden.
Danach soll der neue Array an eine weitere Funktion übergeben werde, die den Array ausgibt.
Generell musst du verstehen dass Arrays als Zeiger übergeben werden. Auch wenn man bei den Parametern die eckigen Klammern verwendet. Ein Array Name zerfällt zu einem Zeiger auf das erste Element
Rückgabewerte solltest du dir mal genauer ansehen. Bei shiftArray() hast du einfach float aus Rückgabewert. Wenn du die Funktion direkt in andere Funktionen einsetzen willst, muss der Rückgabewert float* sein. Genau das was die Fehlermeldung auch anmeckert. Float ist schließlich nur ein einzelner Wert. Aber kein Array
Und printArray() hat eine Rückgabewert, aber gibt nichts zurück
combie:
Reicht es nicht, einfach nur einen Zeiger zu verschieben?
Da er vorne wieder einen neuen Wert reinschreibt wohl eher nicht. Oder er müsste das Ganze als Umlaufpuffer organisieren.
@TO: Da Du - wie Serenifly schon schrieb - einen Zeiger auf dein Array übergibst, wird auch dein Original-Array verändert. D.h. Du muss da für deine Funktionalität erstmal gar nichts zurückgeben.
P.S. Es waren auch noch Tipfehler in deinem Sketch.
P.P.S. Der feste Wert in der for-Schleife ( z=9 ) ist eine potentielle Fehlerquelle, wenn Du mal die Größe deines Arrays änderst.
In dieser Funktion soll der letzte Wert gelöscht werden und die restlichen Werte um eins nach hinten verschoben werden.
An die Stelle "null" soll jetzt ein neuer Wert eingefügt werden.
Danach soll der neue Array an eine weitere Funktion übergeben werde, die den Array ausgibt.
Ein solcher Container ist leicht zu bauen.
Der tuts dann auch mit allen Arduino kompatiblen Boards.
Zu haltender Datentype und Größe ist einstellbar.
Die [] Operatoren sorgen dafür, dass man es wie ein Array behandeln kann
Der Zuweisungsoperator ruckelt weiter und fügt die Daten an Position Null an.
Anstatt die Daten durch den Speicher zu schieben, wird nur ein "Zeiger" über die Daten bewegt.
So liegt das zuletzt angefügte Element immer auf container[0]
template<typename DataType, size_t count>
class CombiesContainer : public Printable
{
private:
DataType data[count];
unsigned dataIndex;
public:
CombiesContainer():dataIndex(0){}
constexpr size_t size()
{
return count;
}
void fill(const DataType value)
{
for(DataType &d:data) d = value;
}
DataType operator [](const size_t index) const
{
size_t i = dataIndex + index;
while(i>=count)i -= count; // wrap around
return data[i];
}
DataType &operator[] (const size_t index)
{
size_t i = dataIndex + index;
while(i>=count) i -= count; // wrap around
return data[i];
}
DataType operator = (const DataType value)
{
dataIndex--;
while(dataIndex>=count) dataIndex += count; // wrap around
data[dataIndex] = value;
return value;
}
virtual size_t printTo(Print &p) const override
{
size_t len = 0;
for(unsigned i = 0; i < size(); i++)
{
len += p.print("Index ");
len += p.print(i);
len += p.print(": ");
len += p.println((*this)[i]);
}
len += p.println("------------ ");
return len;
}
};
CombiesContainer<float,10> container;
void setup()
{
Serial.begin(9600);
// container fluten
container.fill(1.1);
Serial.println(container);
// ein paar Dinge hinein tun und dabei den internen "Zeiger" weiter setzen
container = 33.3;
container = 34.3;
container = 35.3;
Serial.println(container);
// an eine gegebene Position schreiben, ohne den "Zeiger" zu bewegen
container[6] = 4711.0;
Serial.println(container);
// noch ein Ding hineintun, und weiter ruckeln
container = 55.55;
Serial.println(container);
}
void loop()
{
}
Und in dieser Sache kann ich wahrlich auf alte Erfahrungen zurückgreifen.
Man schiebt einfach keine Daten durch die Gegend,
wenn man nicht unbedingt dazu gezwungen wird.
Denn Daten werden durch kopieren meist weder besser,
noch sonst irgendwie schmackhafter.
Ich halte es da gerne mit Pipi Langstrumpf:
Ich mach mir die Welt, widde widde wie sie mir gefällt.
Und dafür nutze ich hier den Pool der C++ Möglichkeiten.
So habe ich beides....
Die Sicht auf ein Array, welches die die Daten weiter ruckelt und immer am Anfang einfügt.
Und intern, nur den weiter laufenden "Zeiger"
Im Grunde sind das zwei völlig unterschiedliche Sichtweisen/Projektionen.
Das "Innen" wird vom "Außen" durch die Schnittstelle abgegrenzt.
Für dich sicherlich,
Viel Übung mit Sichtweisen und Projektionen.
Das ist mir ein wichtiges "Ding".
ich bin noch unterwegs.
Da bin ich noch unterwegs!
Aus dem Nähkästchen:
Leider neige ich dazu, einmal erfolgreich umgesetzte "Dinge" immer wieder auf die gleiche Art zu erledigen!
Streng nach dem "Prinzip der geringsten Verwunderung":
Was du einmal auf die eine Art getan hast,
erledige immer wieder auf die gleiche Art.
Notwendige Erweiterung:
Halte dich an das "Prinzip der geringsten Verwunderung", bis dir
neue Erkenntnisse ins Hirn tropfen, oder du eines Besseren belehrt wirst.
Dazu querläufig, sagte Nico Semsrott mal:
Jede Entscheidung, ist der Tod von Milliarden Möglichkeiten.
Hier kann man das Wort "Möglichkeiten" auch durch "Sichtweisen/Projektionen" ersetzen.