heute brauche ich mal wieder eure Hilfe.
Steh voll aufm Schlauch.
Habe ein byte array. Das wird über die serielle Schnittstelle gefüllt. Anschliessend will ich in dem array nach einer definierten Bytefolge suchen, und die Position zurück bekommen.
Da ich hier keine fertige Funktion (so wie strstr() für charrArrays) kenne, wollte ich es zu Fuß machen.
Aber irgendwie scheitere ich schon an der Übergabe an meine Funktion.
Hier mal der entsprechende Code. Abgespeckt auf ein 1Byte-Pattern
byte SerIn[300]; //Eingangspuffer serielle Schnittstelle
// Array wird über die serielle Schnittstelle gefüllt
byte SearchStr[] = {0xFF};
int ziel = Search (SerIn, SearchStr);
UdpDebug << "Zeiger auf Ergebnis: " << ziel << endl;
//--------------------------------------------
int Search(byte src[], byte pattern[])
{
int c = sizeof(src) - sizeof(pattern) + 1;
for (int i = 0; i < c; i++)
{
if (src[i] == pattern[0]){
return i;
}
}
return -1;
}
//--------------------------------------------
postmaster-ino:
Versuch Mal Folgendes;
int Search(byte* src, byte* pattern)
Hi, danke für den Tip.
klappt aber iwie wieder nicht.
Bekomme immer wieder -1 zurück, obwohl das Muster definitiv im Array SerIn[] drin ist.
Glaube, dass die Übergabe nicht funktioniert, da ich für sizeof(src) und auch für sizeof(pattern) den Wert 4 bekomme.
Ein Zeiger beansprucht den Platz von 4 Byte - somit hast Du also einen Zeiger übergeben - lag ich schon Mal nicht ganz falsch :).
Ok, dann tausche das * gegen ein &, mit etwas Glück übergibst Du damit eine Referenz - wenn Ja, arbeitet die Funktion mit den Original-Daten - also Änderungen an Diesen ändern die Daten auch außerhalb.
Wenns denn klappt (oder auch nicht) - bin ich aber raus, da ich keine Ahnung habe, was dann Da wirklich abläuft
postmaster-ino:
Ok, dann tausche das * gegen ein &, mit etwas Glück übergibst Du damit eine Referenz - wenn Ja, arbeitet die Funktion mit den Original-Daten - also Änderungen an Diesen ändern die Daten auch außerhalb.
Nix besser ;-(
Bei der Zeigerübergabe geht die Länge des Arrays verloren.
Aha, das ist wohl des Pudels Kern....
Hab jetzt mal einen festen Wert für die Länge rein geschrieben. Sieht schon besser aus
Also das mit dem template und so weiter kapier ich beim besten Willen nicht.
Mach dir nix draus...
Zumindest hat die Template Variante den Vorteil, dass sie mit ALLEM funktioniert, was man irgendwie in ein Array stopfen kann. Wenn es denn einen brauchbaren == Operator dafür gibt, kann man damit sogar Äpfel in einer Birnenkiste finden.
Auf dieser Ebene sind Templates nicht so kompliziert. Das wird erst im Zusammenhang mit der STL und komplexerem Code unleserlich
Templates sind Code Generatoren. Man gibt einen generischen Typ an und der Compiler übernimmt alle Arbeit. Dann kann man beliebige Datentypen übergeben und der Compiler erstellt einfach neue Funktionen ohne dass du das siehst
z.B. mit Klassen:
template<typename T>
class Test
{
T data[10];
};
Test<int> test1;
Test<long> test2;
Und das kannst du auch ohne Templates machen:
A (&haystack)[Acount]
Arrays als Referenzen übergeben. Dann kann man sizeof() machen. Das Problem dabei ist dann normalerweise dass man nur Arrays dieser Größe übergeben kann.
Das Template umgeht das einfach indem es für andere Größen zusätzliche Funktionen erstellt
Einerseits über recht notwendige Grundlagen, hier: Zeiger+Arrays
Und hier drüber:
C++ ist eine Multiparadigmen Sprache.
Und wenn einem das jeweilige Paradigma noch nicht begegnet/bekannt ist, dann schaut man halt, wie das gern als Beispiel genommene Schwein, ins Uhrwerk.
Lasst mich mal raten:
Ihr habe beide ein Informatikstudium hinter euch?
Da kann ich leider nicht mithalten.
Dass Zeiger, Referenzen usw.. Grundlagen sind, die ich, trotz Sereniflys (und auch von anderen) unermüdlicher Hilfe noch immer nicht ganz verinnerlicht habe, muss ich leider anerkennen. Schande über mich.
Aber so was wie Paradigmen.... Ehrlich... Bahnhof.
Ich hab vor einer gefühlten Ewigkeit Nachrichtentechnik studiert, und damals gabs nur Turbo Pascal gelehrt. Mit den Jahren fällt man dann über alle möglichen Programmiersprachen drüber...
Wobei ich mich bei SPS und Assembler/Maschinensprache noch am wohlsten fühle.
Mein "Programmierparadigma" hat sich dann im Laufe der Zeit nach folgendem Schema entwickelt.
Ich definiere mir ein Programmierziel
Welcher Befehlssatz steht mir zur Verfügung?
Mit möglichst einfachem Code das Ziel erreichen
Den Code so schreiben, dass ich ihn nach 2 Wochen noch verstehe
Und...ja, ich will nicht stehen bleiben. Aber der Aufwand/Nutzen-Faktor soll noch im Rahmen bleiben. Ist und bleibt für mich ein Hobby. (Eines von mehreren)
Und wenn ich mal gar nicht mehr weiter weiß, dann gibts hier super Leute, die mit einer Eselsgeduld weiter helfen.
In einem Studium lernst du das nicht unbedingt. Da geht es größtenteils um allgemeine Dinge. Ich hatte da einen freiwilligen C++ Kurs, aber größtenteils habe ich mir das selbst beigebracht.
hk007:
Lasst mich mal raten:
Ihr habe beide ein Informatikstudium hinter euch?
Autodidakt.
Bin also eher sowas wie: Eine eingewiesene Person mit fundiertem Halbwissen.
Habe allerdings auch viele Jahre im Team agieren dürfen.
Verschiedenste Sprachen und Zielsysteme.
So lernt man dann die grundlegenden Konzepte/Pattern und kann sie auch benennen. (oder geht unter)
OK, kein Informatikprofessor unter euch.
Dann hab ich ja noch Hoffnung für mich.
Aber ich mache damit einfach zu wenig, um meine Kenntnisse entsprechend zu erweitern.
Tipp:
Eigentlich ist es eine Frage der inneren Einstellung:
Solange man noch für sich selber begründet, "warum" man "dies oder das" gerade nicht lernen kann, solange wird das auch nichts.
Das ist recht zuverlässig der Fall.
Das witzige daran:
Es ist ein sich selbst stabilisierendes System/Konzept.
Denn: Jegliches aufzählen dieser Gründe, ist eine Tätigkeit im Rahmen der Selbstsuggestion, und festigt so die Situation.
Leitsatz:
Wer will, findet Wege.
Wer nicht will, findet Gründe.
