grundsätzlich kann sich ja die Array-Länge automatisch nach er Anzahl der Füll-Elemente bestimmen ala int array[]={1,2,3}.
Wenn ich anstelle der Zahlen Variablen nehmen möchte, habe ich es nur hinbekommen mit vorherheriger Deklaration.
int array[]=(a,b,c)
Gibt es dazu auch eine Möglichkeit, in der gleichen Zeile die Variablen die Füllelemente als Variablen zu deklarieren?
Also in etwa int array[]={int a=1; int b=2; int c=3} ?
Prinzip dürfte erkennbar sein, funktioniert in dieser Form jedoch nicht.
Teletrabi:
in einer struct kann ich dann aber nicht über die Elemente iterieren, oder?
Öh ... naja ... wenn Du in der Struktur ein Array „verpackst“, ist es ein Array.
Erzähl' doch mal, was Du konkret vorhast und zeige evtl. ein Sketch, in dem Du das anwenden möchtest. Alles, was ich mir jetzt spontan vorstellen kann, hat mit Klasse(n) zu tun.
hmm, vielleicht meine ich am ehesten sowas wie ein int* array[]={int &a; int& b;};
Also letztlich geht's um in ints abgelegte Informationen über die Aktivität an einer Handvoll Eingängen.
Da das ganze recht ähnlich verabeitet wird hab, ich den Code einigermaßen übersichtlich und universell gehalten, indem die Adressen in einem Array zusammengefasst übergeben und dann durchiteriert werden.
Vorteil: ich hab einerseits Zugriff über vernünftige, aussagekräftige Namen für die jeweilige Variable und zum anderen via dem adress-array die Möglichkeit ähnliche Abläufe zu wiederholen.
Nachteil: ich muss sowohl die int-Variable initialisieren wie auch deren Adresse im Array einfügen.
Wenn irgend möglich würde ich das vermeiden wollen, und automatisch ein Array richtiger Länge über alle verwendeten Eingänge haben. Einfach um bei Abänderungen weniger Fehlermöglichkeiten in der Konfiguration zu haben.
Teletrabi:
Also letztlich geht's um in ints abgelegte Informationen über die Aktivität an einer Handvoll Eingängen.
Wenn ich das lese, erinnert es mich an etwas, was ich in einem anderen Thema gemacht habe. Da beinhalten die Variablen aktZustand und altZustand den Zustand eines Eingangs. Je Eingang lege ich eine Struktur an, auf deren Variablen ich zugreifen kann. Das geht über eine Methode oder auch direkt.
dein Beispiel könnte passen, kann es aber noch nicht so ganz nachvollziehen. Zuviel Namenskonflikte um t/Taster :o)
Und wäre deutlicher Anpassungsaufwand. Hab es ja am laufen mit dem Vektor/1-dim-array. Wollte es nur möglichst idiotensicher, dass kein mehrfaches einpflegen zusätzlicher Eingangspins erforderlich ist. Daher die Überlegung, ob man bei den Elementen im adress-array irgendwie diese verlinkten Komponenten selbst gleich mit erschaffen kann.
a) meine PIN-Definition vornehmen und dafür sprechende Texte haben damit ich sie im Source einzeln ansprechen kann
b) alle PIN-Definitionen in einem Array haben, damit ich drüber iterieren kann.
daher hat er auch dieses non working example gebracht:
Nur, glaube ich, dass dieser Wunsch, eine Ursache hat.
Und, dass, wenn man die Ursache aus einem anderen Blickwinkel betrachtet, der Wunsch sich plötzlich in Luft auflöst.
Oder die Lösung auf der Hand liegt.
Dein a) und b) habe ich schon verstanden....
Und dennoch schließen sich die beiden quasi gegenseitig aus.
Nicht im technischen Sinn, unbedingt...
Aber im logischen.
Für mich riecht das so, als wenn man so Unmengen an Seiteneffekten Tür und Tor öffnet.
Meine Intuition sagt: Es verschlimmert die Situation eher, als dass sie verbessert wird.
Ich sehe hier das Bestreben, nach globalen Variablen bzw. nach Variablenbezeichnern im globalen Namensraum.
Und das eben möchte ich herausfinden, ob das nötig ist, oder der Wunsch nur darum besteht, weil keine Alternativen bekannt sind.
Nimm 2 Arrays, eines mit den Pin-Nummern, und eines für die zugehörigen Werte. Dann iterierst Du über die Array-Elemente, bekommst die PinNr aus dem ersten Array, und speicherst den von dort eingelesenen Wert in das zweite Array.
int array[] {4,5,9};
int & a = array[0];
int & b = array[1];
int & c = array[2];
void setup()
{
Serial.begin(9600);
Serial.println("Start");
Serial.println(a++);
Serial.println(array[0]++);
Serial.println(a++);
Serial.println(array[0]++);
Serial.println(a++);
Serial.println(array[0]++);
}
void loop()
{
}
Klar funktioniert das mit Referenzen....
Aber sonderlich sinnvoll scheint mir das nicht.
Eine Möglichkeit das in einem Statement zu tun, ist mir nicht bekannt.
Und auch den Wunsch habe ich noch nie verspürt.
Ich halte meinen globalen Namensraum möglichst sauber.
Was schlägt Combie denn vor?
"Problem" hat noiasca ja nochmal nschaulich beschrieben, auch wenn es mir hier nicht um die Pinnummern geht sondern einen int-Wert pro Eingang, der sowohl Flanken als auch (nicht)Betätigungszeiten repräsentiert. (1/-1 als Flankenmarker, (negative) ms seit letztem ein (aus)schalten).
Derzeit generiere ich mir jeweils einen int pro Pin und packe die Adressen in einen Vektor, der dann an die read- und debounce-Funktionen gegeben wird, die im Ergebnis in die dort hinterlegte Adresse (der int-Variable) den besagten Wert reinschreiben.
Derzeit generiere ich mir jeweils einen int pro Pin und packe die Adressen in einen Vektor, der dann an die read- und debounce-Funktionen gegeben wird, die im Ergebnis in die dort hinterlegte Adresse (der int-Variable) den besagten Wert reinschreiben.
Ich würde eher den Pin so an die Auswertung koppeln, so dass man sich nur an einer einzigen Stelle um die Abhängigkeit kümmern muss.
Wie ich das machen würde? Hier im Eingangsposting, siehst du so ein Beispiel von mir.
Im folgenden kommt dann einiges an Erklärungen.
Natürlich ist das kein Muss, das so zu tun....
Es gibt einige Möglichkeiten, was vergleichbares zu erreichen.
Da die Taster im Beispiel frei von jeder Bedeutung sind, habe ich sie taster[0] und so weiter genannt. Es wäre aber auch taster[LichtAn].fallend möglich, was doch schöne viele Informationen enthält. Der Konstanten LichtAn kann man dann den Wert 0 zuordnen. Das geht mit #define, einer Konstanten LichtAn = 0 oder enum.
Noch Wünsche offen?
Ergänzung 13:40 Uhr: Da LichtAn eine konstante Zahl ersetzt, ist auch eine Schleife mit taster[j].fallend möglich. Das hast Du wohl mit Iteration gemeint?
Ja, ich hätte da noch einen: Kein #define zu benutzen. Ich kenne bislang keinen Fall, bei dem ich nicht um die Benutzung herum gekommen wäre. Egal, wie konstant Konstanten sind, sie kommen in ordentliche Variablen, damit der Compiler eine vollständige Typprüfung durchführen kann.
Bleibt die Frage, wie es (syntaktisch) aussieht, wenn so ein Vektor-Element (welches?) an eine read-Funktion übergeben wird. Wenn dafür eine Variable namens a verwendet werden soll, dann kann die so wie bereits beschrieben benannt worden sein. Dazu braucht man keinen Vektor, es reicht schon ein array.
