String zerlegen und umwandeln ?!

**izaseba** · 03.08.2007, 17:57

Was für einen Compiler benutzt Du?

Genau, vorsicht, Roberto nutzt CodeVision, bin auch schon drauf reingefallen

Trotzdem muß die Standardbibliothek funktionieren, nur die AVR spezifischen Sachen haben die Jungs anders gelöst als bei avr-gcc

@Roberto,
ein Tip von mir, besorge Dir C Kompiler für PC ( dev-c++, oder so)
Damit kannst Du erstmal rumprobieren, bis Du die Arrays und Zeiger verstanden hast

Gruß Sebastian

**Roberto** · 03.08.2007, 18:36

Hallo

Sch.... C

Aber ich werde nicht aufgeben

Schreibe gerade einen minimum Code um ein bisschen zu probieren.
Da kann ich dann auch die Wertübergabe bei den Funktionen probieren und die Zeiger.
Eventuell dann im GCC gegenvergleichen

Frage mich nur, warum das in C so kompliziert sein muss

(Strings)
Bringt das irgendeinen Vorteil ?
In Bascom kann man einfach: String= "text" eingeben und fertig.

Und warum findet man da eigentlich so wenig im Forum darüber

Danke einstweilen für die Geduld

l.G. Roberto

**izaseba** · 03.08.2007, 19:07

Hmmm,
ich frage mich, warum es C sein muß, wenn Du Dich mit Bascom gut auskennst ?

Frage mich nur, warum das in C so kompliziert sein muss (Strings)
Bringt das irgendeinen Vorteil ?

Was ist daran kompliziert ?
Und ja, es bringt einen Vorteil mit sich, schon alleine bei der übergabe an eine Funktion.
Egal, wie groß Dein String ist wird immer ein Zeiger auf die erste Speicherzelle übergeben, also 16Bit.
Auch bei Strukturen, egal wieviele Elemente sie haben, werden auch nur 16 Bit übergeben.
Das bringt Power mit sich.

Und warum findet man da eigentlich so wenig im Forum darüber

Gibt es nicht genug C Tutorials/Bücher ?

Ach ja C lernt man nicht von Heute auf morgen, ich widerhole mich nicht gerne, aber fang mit C auf PC an
Gruß Sebastian

**Roberto** · 03.08.2007, 20:30

Hallo Izaseba

ich frage mich, warum es C sein muß, wenn Du Dich mit Bascom gut auskennst ?

Najaaa, irgendwann werde ich wohl C brauchen.
Sind ja schon fast alle Programmier-Sprachen irgendwie an C angelehnt.

Gibt es nicht genug C Tutorials/Bücher ? Think

Meinte Beiträge zum Thema String u.s.w. im Forum

l.G. Roberto

**p_mork** · 03.08.2007, 20:45

Hallo!

Zitat von Roberto

In Bascom kann man einfach: String= "text" eingeben und fertig.

Dann musst Du wohl auf C++ umsteigen. Aber bis es soweit ist, erklär mir bitte erstmal, wofür Du 'sting="text"' brauchst. Gib mir ein Praktisches Beispiel dafür.

MFG Mark

**Roberto** · 04.08.2007, 01:37

Hallo Mark

Aber bis es soweit ist, erklär mir bitte erstmal, wofür Du 'sting="text"' brauchst. Gib mir ein Praktisches Beispiel dafür.

z.B. Für Menues auf einem Grafik Display, Meldungen auf einem LCD ,
übertragung von Text über die Serielle u.s.w.

l.G. Roberto

Ps.:

Was für einen Compiler benutzt Du? Keinen GCC oder? 'flash unsigned char*' ist kein Standart-C sondern anscheinend auf die AVRs angepasstes. Ich nehme an, es soll einen Zeiger auf ein char im Flash darstellen. Dann musst Du auch in der Funktion anstatt 'unsigned char*pstr' 'flash unsigned char*pstr' schreiben.

Habe gerade deinen Code auf dem GCC probiert und funktioniert

(Zumindest kein Error)
Hab es dann beim CodeVison probiert mit:
void( LCD_puttext( flash unsigned char *pstr,unsigned char x_pos,... )

Dann geht es mit :
LCD_puttext ("test",1,1);

Zumindest der Compiler schreit nicht

Den Rest werde ich morgen mal probieren. Jetzt gehe ich mal ins Bett

Ps.:
Programmiert Ihr eigentlich alle mit WinAVR und makefile?

**Sternthaler** · 04.08.2007, 04:04

Hallo zusammen.

@Roberto
Ich will mal versuchen die Strings in C doch noch mal klarzustellen.
izaseba hat ja schon angekündigt, dass gerade bei der Parameterübergabe nur 16 Bit benötigt werden. Warum aber?

Code:

Beispiel von izaseba:

#include<string,h>
char puffer[30]; /*Hier passen max 29 Zeichen*/
const char eintext[]="noch was";
char nocheinpuffer[10];

Ergibt:
Speicher-  Speicher-
adresse    inhalt
00         
01         
02         
03         
04         
05         
06         
07         
08         
09         
10         
11         
12         
13         
14         
15         
16         
17         
18         
19         
20         
21         
22         
23         
24         
25         
26         
27         
28         
29         
30         n
31         o
32         c
33         h
34         
35         w
36         a
37         s
38         NULL
39         
40         
41         
42         
43         
44         
45         
46         
47         
48         

Wofür werden "puffer", "eintext" und "nocheinpuffer" benötigt?
In diesen Namen stehen 'nur' die Adressen der Speicherstellen in denen der eigendliche Inhalt vorhanden ist.
Um diese Adressen aber selbst zu speicher, benötigen wir noch mehr Speicherplätze:
49         0     puffer ist hier und --> zeigt <-- auf 0*255 + 0 = Adresse 0
50         0        da puffer mit '[30]' gemacht wurde, 'gehört' ihm noch Adresse 29
51         0     eintext ist hier und --> zeigt <-- auf 0*255 + 30 = Adresse 30
52         30       eintext wurde mit '[]="noch was"' gemacht, geht also bis Adresse 38
53         0     nocheinpuffer ist hier und --> zeigt <-- auf 0*255 + 39 = Adresse 39
54         39        wie bei puffer nun bis Adresse 48

Was macht "strcpy(puffer,"Hallo Roberto");"?
--> Erst mal müssen wir fragen wo steht "Hallo Roberto" im Speicher?
Natürlich auch wieder in unserem Speicher. Also weitere Adressen: (Dürfen auch Adressen im ROM oder EEPROM sein)
55         H
56         a
57         l
58         l
59         o
60         
61         R
62         o
63         b
64         e
65         r
66         o
67         NULL   Das ist bei C nun einmal so. Basic kann nur eine begrenzte Anzahl Zeichen
                  in einem String speichern, weil die Anzahl der Bytes vorne im Speicher
                  der Variablen steht. Das sieht du nur nicht.
                  Somit hat C schon wieder einen Vorteil, weil du BELIEBIG lange Strings
                  speichern kannst. Hinten ist halt das NULL-Zeichen.
Nun kann also die Funktion strcpy (??, ??) etwas machen.
Was passiert?
izaseba hat es schon gesagt:
Die Zeiger (man spricht auch von Pointern) auf Speicherstellen werden als Parameter in die Funktion
reingegeben.
Welche Zeiger sind das? Natürlich die Zeiger auf Adressen.
Hier also wird der Aufruf zu:
strcpy (0, 55)   <-- 0, weil puffer den Zeiger auf Adresse 0 hat
                 <-- 55, weil "Hallo Roberto" den Zeiger auf Adress 55 hat.
                         Das weiss der Kompiler, weil es keine Variable ist.

Nun wird strcpy einfach folgendes machen:
merke 55 in quelle
merke 0  in ziel
loop
  Nimm den Inhalt aus der Speicherstelle quelle und schreibe ihn nach ziel
  Prüfe, ob in Speicherstelle quelle ein NULL steht
  Wenn nein:
    erhöhe quelle um 1
    erhöhe ziel   um 1
    gehe wieder an den Anfang von loop
  Wenn ja
    verlasse die loop
ende loop

Und schon sieht unser Speicher so aus:
00         H
01         a
02         l
03         l
04         o
05         
06         R
07         o
08         b
09         e
10         r
11         t
12         o
13         NULL
14         
15         
16         
17         
18         
19         
20         
21         
22         
23         
24         
25         
26         
27         
28         
29         
30         n
31         o
32         c
33         h
34         
35         w
36         a
37         s
38         NULL
39         
40         
41         
42         
43         
44         
45         
46         
47         
48         
49         0     puffer
50         0
51         0     eintext
52         30
53         0     nocheinpuffer
54         39
55         H
56         a
57         l
58         l
59         o
60         
61         R
62         o
63         b
64         e
65         r
66         o
67         NULL

(Beim nächsten Beispiel bitte Variablen mit weniger Speicher benutzen

)

Nocheinmal: Es werden hier also keine Variablen verschoben/kopiert oder Sonstiges. Es werden nur Inhalte aus Speicherstellen von a nach b kopiert.
Von wo nach wo sagt man der Funktion. Und damit man sich als Programmierer nicht die Speicherstellen selber merken muss, nimmt man dafür Variablen, die selber NUR die Adressen speichern wo der Daten-Inhalt deiner Variablen im Speicher steht. Diese Variablen nennt man Pointer-Variablen. Ihr Inhalt zeigt auf die Daten um die es dir/dem Programmierer geht.
Alle String-Variablen in C arbeiten so.

Vorsicht: Eine Variable in der Form
char zeichen = 'x';
ist KEIN String. Dies ist nur ein einzelnes Zeichen, welches nur genau ein Byte benötigt, und auch NICHT mit NULL beendet wird.

Ich hoffe, dass dies etwas geholfen hat.

**ehenkes** · 04.08.2007, 06:03

Strings in C:
http://de.wikibooks.org/wiki/C-Progr...trings#Strings
http://ivs.cs.uni-magdeburg.de/bs/le...seminar3.shtml

Wenn Du eine einfachere String-Handhabung wünschst, wechselst Du am besten zu C++ und schreibst Dir eine eigene kleine String-Klasse mit dem operator= auf Basis char. Hier einige Vorbilder, da selbst gestrickte String-Klassen erstaunlicherweise nicht leicht zu finden sind:
http://www.c-plusplus.de/forum/viewt...s-estring.html
http://www.c-plusplus.de/forum/viewt...art-is-10.html
http://forum.2lucky.de/archive/o_t__...ingklasse.html
Buch: Till Jeske, C++, Addison-Wesley, aus der Nitty Gritty Reihe (Klasse 'Text' siehe Anhang).

Hier ein bei avr-g++ funktionierendes ausbaufähiges Beispiel:

Code:

/*****************
*  Stringklasse  *
******************/

// Ersatz für new, new[], delete und delete[] der fehlenden C++-Standard-Bibliothek
void* operator new      (size_t size) { return malloc(size); }
void* operator new[]    (size_t size) { return malloc(size); }
void  operator delete   (void* ptr)   { free(ptr); }
void  operator delete[] (void* ptr)   { free(ptr); }

class MyString
{
  private:
    char * pData_;

  public:
    friend MyString operator+( const MyString &, const MyString & );
    MyString() : pData_( NULL ) {} // inline ctor
    MyString( const char * pText );
    MyString( const MyString & text ); // Copy-Konstruktor
    ~MyString(); // dtor
    const MyString & operator=( const MyString & text );

    bool operator==( const MyString & text ) const;
    char operator[]( int index ) const;
    operator const char * () const; // cast zum C-String
    operator char * () const; // cast zum C-String
    int getLaenge() const;
    void ausgeben() const;
};

MyString operator+( const MyString & leftstring, const MyString & rightstring );

/******************************************************************/

// ctor mit C-String als Argument
MyString::MyString( const char * pText ) : pData_( NULL )
{
  if( pText )
  {
    pData_ = new char[ strlen( pText ) + 1 ];
    strcpy( pData_, pText );
  }
}

// copy-ctor
MyString::MyString( const MyString & text ) : pData_( NULL )
{
  if( text.pData_ )
  {
    pData_ = new char[ strlen( text.pData_ ) + 1 ];
    strcpy( pData_, text.pData_ );
  }
}

// dtor
MyString::~MyString()
{
  delete[] pData_;
}

// ==
bool MyString::operator==( const MyString & text ) const
{
  if( pData_ == NULL || text.pData_ == NULL )
  {
    return ( pData_ == NULL && text.pData_ == NULL );
  }
  return ( strcmp( pData_, text.pData_ ) == 0 );
}

// []
char MyString::operator[]( int i ) const
{
  if( i >= 0 && i < getLaenge() )
  {
    return pData_[i];
  }
  else
  {
    return '\0';
  }
}  

// Länge des Textes ermitteln
int MyString::getLaenge() const
{
  if( pData_ == NULL )
  {
    return 0;
  }
  else
  {
    return strlen( pData_ );
  }
}

// cast zu C-String
MyString::operator const char * () const
{
  return pData_;
}

// cast zu C-String
MyString::operator char * () const
{
  return pData_;
}

// Zuweisungs-Operator
const MyString & MyString::operator=( const MyString & text )
{
  if( this == &text ) // Selbstzuweisung abfangen
  {
    return *this;
  }  
  delete[] pData_;
  if( text.pData_ )
  {
    pData_ = new char[ strlen( text.pData_ ) + 1 ];
    strcpy( pData_, text.pData_ );
  }
  else
  {
    pData_ = NULL;
  }
  return *this;
}

void MyString::ausgeben() const
{
  // TODO
}

/******************************************************************/

MyString operator+( const MyString & leftstring, const MyString & rightstring )
{
  MyString result;
  if( leftstring.pData_ != NULL && rightstring.pData_ != NULL )
  {
    result.pData_ = new char[ strlen( leftstring.pData_ ) +
                              strlen( rightstring.pData_ ) + 1 ];
    strcpy( result.pData_, leftstring.pData_ );
    strcat( result.pData_, rightstring.pData_ );
  }
  else if( rightstring.pData_ != NULL )
  {
    result = rightstring;
  }
  else if( leftstring.pData_ != NULL )
  {
    result = leftstring;
  }
  return result;
}

**robocat** · 04.08.2007, 10:32

so eine stringklasse ist am rechner ja praktisch, aber in einem kleinen controller nimmt das zuviel speicher. ausserdem hat man sich damit des problems entledigt, ohne es verstanden zu haben. dabei ist es wirklich kein zauberwerk.

wenn die max. länge der zeichenkette zur compilezeit bekannt ist, kann man arrays nehmen, das wurde ja schon angesprochen.

wenn nicht, kann man dynamisch speicher allozieren:

Code:

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int main()
{
  char *p=malloc(7);
  strcpy(p,"123456");
  printf("%s\n",p);
  p=realloc(p,13);
  strcat(p,"789ABC");
  printf("%s\n",p);
  free(p);
  return 0;
}

gruesse