Entwicklung neues Plugin - Probleme mit C++ und Char/String und Objekten

Moin!

Also erst mal vorweg, damit du schnell zu einem Ziel kommst: am besten benutzt du die Klasse cString des vdr.
Einen neuen erstellst du am einfachsten mit:

cString desc = cString::sprintf("das übliche %s printf-Gedöns", Description);

und da "SetDescription" einen "const char*" (das ist ein Pointer auf ein char-Type, meistens ein Array, das somit zu einem String wird), und cString da einen passenden Operator hat (schau einfach mal in tools.[hc]):

Event->SetDescription(*desc);

Um ein wenig auszuholen... Ich versuch das mal aus dem Stehgreif. Gleich kommt noch ein Post...

Lars.

Hi,
Ich komme von der Delphi Ecke also reiner "Hobbyverbrecher", der sich sich auch schon daran versucht hat C++ zu lernen.
Mit wenig Erfolg

Zitat von CafeDelMar

Und obwohl ich mich bereits darüber informiert habe, ist mir immer noch nicht ganz klar, wann man das * (Dereferenzierung) bei den Variablen benutzen muss.

Hier würde ich sagen, wenn du auf den Wert des Pointers zugreifen willst.

So, nun geht's weiter...

Einen festen String deklarieren, z.B.

char text[255];

Da hast du nun 255 Zeichen Platz, um deine Buchstaben loszuwerden.
Auf einen bestimmten Platz greifst du mit dem Index-Operator zu

text[0] = 'a';

Das macht natürlich erst mal keinen Spaß...

Da der vdr intern eher C statt C++ benutzt (libc statt stl), also nicht std::string, musst du einfach mal ein paar Manpages zu printf usw. lesen.
Prinzipiell musst du selbst für das Alloziieren (und Freigeben!) des Speichers sorgen, sonst fliegt's dir um die Ohren.

So eine Funktion wie SetDescription erwartet einfach einen Pointer auf einen String, das kann dann wie oben einfach "text" sein (der Name des Arrays ist gleichzeitig ein Pointer auf das erste Element). Das Ende des Strings ist dann einfach ein Nullbyte. Füllst du also alle deine Arrayfelder mit Werten ungleich Null, bringst du den vdr auch zum Abstürzen, da er über das Ende des Arrays hinaus liest und damit auf nicht alloziierten Speicher zugreift. In andern Sprachen (Java etc.) bekommst du eine "Index out of Range"-Exception, wenn du auf ein Element eines Arrays zugreifst, dass nicht da ist.

Die einfachste Art, einen vorhandenen String zu kopieren, ist strdup (immer manpages lesen, wenn ich sowas erwähne).

char *text = strdup(Description);

Wenn du den Text nicht mehr brauchst, musst du den Speicher wieder freigeben (nix da mit Garbage Collector usw.):

free(text)

Das darfst du aber erst, wenn der String nicht mehr benötigt wird. Im Falle von SetDescription macht diese Funktion seine eigene Kopie des Strings und braucht den Pointer also anschließend nicht mehr.
Übrigens ist das ein "char *", weil du den Inhalt deiner Kopie durchaus verändern darfst.

Weil das ganze etwas umständlich ist, hat Klaus seine eigene String-Klasse geschrieben. Vor über 10 Jahren war die stl (C++ Standard Template Library) einfach noch nicht so flott. Damals hab ich auch meine eigenen Klassen geschrieben (die heute auch immer noch produktiv bei uns in der Firma benutzt werden). Immer, wenn ich was für den vdr programmiere, benutze ich die, weil's damit einfacher geht und ich nicht so leicht vergessen kann, den Speicher wieder freizugeben - das macht der Destruktor.

cString text(Description);

erstellt einfach eine Kopie.
Der Konstruktor hat noch einen weiteren Parameter "TakePointer". Den setzt du auf true, wenn du selbst schon eine Kopie erstellt hast (z.B. mit strdup) und dich nicht mehr selbst um die Freigabe kümmern willst. Dann übernimmt das cString-Objekt die Herrschaft über den Pointer.

char *text = strdup(Description);
cString c(text, true);
//free(text); ist nicht mehr nötig, würde doppelt ausgeführt werden, weil der Destruktor es auch macht => Crash

Wenn du einen String aus unterschiedlichen Dingen wie Textfragmenten, Integern usw. zusammensetzen willst, ist sprintf dein Freund. Und auch dafür hat Klaus die schon erwähnte Funktion erstellt, die einem die meiste Arbeit abnimmt:

int zahl = 123;
const char *text = "456";
cString ergebnis = cString::sprintf("Ein Integer mit Wert %d und ein Stückchen Text %s", zahl, text);

So, wann braucht man nun die Dereferenzierung?
"int i = 5;" ist ein Werttyp, da wird also Speicher (in diesem Fall auf dem Stack) reserviert, in der man einen Integer speichern kann.
"int *j = &i;" j ist ein Zeiger auf einen Integer, Zeiger erkennt man an dem Sternchen hinter dem Typ bei der Deklaration der Variablen. Mit dem Adressoperator & bekommst du die Speicheradresse der Variablen i, und diese Adresse kannst du in dem Zeiger j speichern.
Um nun auf den eigentlichen Wert zugreifen zu können, musst du den Zeiger dereferenzieren, und das passiert auch mit dem Sternchen, allerdings in einem anderen Kontext, weshalb das anfangs manchmal etwas verwirrend ist...

int i = 5;
int *j = &i; // j selbst enthält eine Adresse 
int k = *j; // der Zeiger wird ausgewertet und das, worauf er zeigt, benutzt. k ist nun also auch 5

Und dann gibt's natürlich noch die fiese Zeigerarithmetik...

int zahlen[] = { 1, 2, 3, 4, 5, 0}; // der Compiler rechnet sich selbst die nötige Größe für das Array aus, deshalb kann man die in den eckigen Klammern weglassen
int *j = zahlen; // oder ausführlich: = &zahlen[0];
while (*j != 0) {
       j++;
       }

Hier wird nicht etwa "zahlen[0]", also die 1 hochgezählt, sondern j, der Zeiger. "j + 1" zeigt dann auf das zweite Arrayelement usw. Würde jetzt keine Null im Array vorkommen, würde die Schleife mit einem Zugriffsfehler abbrechen...
Aber sowas tust du dir am besten gar nicht erst an.

Um dann die Verwirrung noch komplett zu machen (was dir aber evtl. bekannter vorkommt), gibt's in C++ natürlich auch noch Referenzen.

void Funktion(int &i)
{
  i = i + 5;
}


int j = 0;
Funktion(j);
// jetzt hat j den Wert 5, weil es nicht per Wert, sondern per Referenz übergeben wurde

Und es gibt natürlich noch "const"-Referenzen, das ist insbesondere bei größeren "struct"-Gebilden usw. schneller in der Übergabe (weil nicht der ganze Struct kopiert werden muss), aber verhindert, dass die Funktion irgendwas an dem Inhalt verändern kann.

void Funktion(const int &i)
{
  i = i + 5; // Compiler meckert, er darf i nicht ändern
}

Das alles reicht jetzt natürlich überhaupt nicht, um ernsthaft in die C/C++-Programmierung einzusteigen, da musst du andere Quellen noch zu Rate ziehen.
Ich weiß auch nicht, ob ich nun mehr Fragen aufgeworfen als beantwortet habe, aber zumindest mit meiner ersten Antwort weißt du eigentlich genug, um zumindest deinen EpgHandler programmieren zu können.
Ich lese mir meinen Text jetzt auch nicht mehr durch, ich hoffe, ich hab keine zu großen Fehler drin...

Und wichtig: Niemals aufgeben!

Lars.

Zitat von CafeDelMar

Nur mal interessehalber und zum besseren Verständnis: Kann ich nicht auch die "neue" String-Bibliothek von C++ verwenden?

Bloß nicht! Dann kommt der Mreimer und schimpft, dass er wieder eine Library mehr dazu linken muss.

Gerald

Zitat von CafeDelMar

C

#include <string>
#include <iostream>
using namespace std;


int main()
{
  const char* var1 = "Test";
  string var2;
  var2 = var1;
  var2 += " ist OK";
  cout << var2;
}

Alles anzeigen

Ausgabe: Test ist OK

Nur mal interessehalber und zum besseren Verständnis: Kann ich nicht auch die "neue" String-Bibliothek von C++ verwenden?
Ich bin jetzt nach den ganzen Infos darauf gestoßen und sie scheint das "const char" zu schlucken.

CafeDelMar

PS: Jetzt bin ich mir schon wieder mit den * nicht ganz sicher.

Alles anzeigen

Natürlich soolte das funktionieren. Die hatte ich mir auch mal angeschaut. Du musst aber nicht zuerst einen cString deklarieren sondern kannst gleich mit c++ strings arbeiten. Und wenn der string fertig ist gibts sogar ne funktion die einen cstring zurück liefert.
Bei der vekettung mit "+" hat mir der compiler allerding eine warnung ausgegeben, dass diese Methode veraltet ist.

Mfg Thomas

Ohne es getestet zu haben würde ich es mal mit Event->ChannelID().ToString() probieren. Im VDR-Quelltext findet man mit grep hin und wieder auch einige passende Beispiele.

Moin!

Genau, tChannelID ist ein struct mit einer passenden Methode.
Die liefert ein cString, "%s" von printf kann aber nur "char*", weshalb du dann noch den cString dereferenzieren musst (der überladene *-Operator, der bei cString dann einfach ein "const char*" auf den internen Zeiger zurückgibt).

cString chanInfo = cString::sprintf("Changing Description 4 for Channel %s", *Event->ChannelID().ToString());

"cString" ist nicht dasselbe wie "char". An manchen Stellen kann der Compiler selbst umwandeln, aber nur, wenn er ganz genau weiß, was zu tun ist. Bei printf funktioniert das nicht.

Immer in die vdr-Quellen gucken, ohne kann man kein Plugin programmieren...
Bei mir sind die immer in einem extra Editor geöffnet, insbesondere die Header-Dateien.

Und genau, eine Shell im vdr-Verzeichnis hab ich auch immer offen, um danach zu greppen und zu gucken, wie das Zeug benutzt wird.

Lars.

Moin!

Ok, "cPluginEpgplus::epgDatabaseQuery" ist ein privates Member deiner Plugin-Klasse, d.h. du kannst nur von innerhalb der Klasse drauf zugreifen, aber nicht von anderen Klassen aus.
Dazu kommt, dass es nicht statisch ist, weshalb du immer ein Objekt brauchst, um darauf zugreifen zu können.

Ich würde dem Konstruktor deines EPG-Handlers einen Zeiger auf dein Datenbank-Objekt mitgeben:

bool cPluginEpgplus::Initialize(void)
{
  cString epgDatabaseFilename = cString::sprintf("%s/epgplus.sqlite", cPlugin::ConfigDirectory("epgplus"));
  epgDatabase = new Kompex::SQLiteDatabase(epgDatabaseFilename, SQLITE_OPEN_READWRITE, 0);
  //epgDatabaseQuery = new Kompex::SQLiteStatement(epgDatabase); <= das hier in den Konstruktor des EPG-Handlers verschieben?
  new cBroadcastedEpgHandler(epgDatabase);
  return true;
}

Die Deklaration musst du dann entsprechend anpassen und den Zeiger dir batürlich dort merken.
Außerdem würde ich dann im EPG-Handler das SQLiteStatement instantiieren, nicht im Plugin, da du es dort nicht brauchst (oder?).

Dann hast du innerhalb deines EPG-Handlers ein Objekt für deinen SQL-Zugriff "ganz für dich alleine".

Evtl. wäre es sogar sinnvoll, alle Datenbank-Objekte in den EPG-Handler zu verlagern. Oder musst du noch an anderen Stellen irgendwas damit machen?
Das hängt vom restlichen Code ab. Prinzipiell sollten Objekte dort sein, wo sie gebraucht werden.
Dein EPG-Handler-Objekt wird die ganze Laufzeit des vdr's verfügbar sein, es wird ja einmal am Anfang von dir erstellt und dann bei Programmende vom vdr gelöscht.
Deshalb dann im Destruktor des Handlers die Datenbank-Objekte wieder löschen (wenn du sie denn da erstellst). Wenn sie in der Plugin-Klasse bleiben, dann natürlich im Destruktor von cPluginEpgplus.

Aber ohne jetzt den ganzen Code zu sehen, wird es langsam schwieriger, die richtigen Tipps zu geben.
Hol dir doch einen github.com-Account und hoste den Code da. Ist ja egal, ob's schon läuft oder "häßlich" ist usw..

Lars.

CafeDelMar:

Zitat

Mit Delphi habe ich vor längerer Zeit auch viel gemacht, war da auch schon sehr tief in der objektorientierten Programmierung (neue GUI-Objekte zur Laufzeit, vererbte Objekte, ...) drin, aber selbst das war im Vergleich hierzu noch einfach.

Sowas mache ich in Delphi auch - mit spitzer Zunge würde man sagen Delphi ist besser zu verstehen und das Ergebnis ist das Selbe.
Mit den Anleitungen von den C++ Profis hier fällt es auch mir leichter dies zu verstehen - Ich habe heute etliche C++ Einsteiger Websites angesehen. *Kopfrauch*

Respekt wie weit du schon gekommen bist

Ich will deinen Thread nicht Off Topic machen, evtl. mach ich einen C++ Anfänger Thread auf.