Druckbare Version
Genau, vorsicht, Roberto nutzt CodeVision, bin auch schon drauf reingefallen :-)Zitat:
Was für einen Compiler benutzt Du?
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
Hallo
Sch.... C ](*,)
Aber ich werde nicht aufgeben O:)
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 :-k (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 :-k
Danke einstweilen für die Geduld ;-)
l.G. Roberto
Hmmm,
ich frage mich, warum es C sein muß, wenn Du Dich mit Bascom gut auskennst ?
Was ist daran kompliziert ?Zitat:
Frage mich nur, warum das in C so kompliziert sein muss (Strings)
Bringt das irgendeinen Vorteil ?
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.
Gibt es nicht genug C Tutorials/Bücher ? :-kZitat:
Und warum findet man da eigentlich so wenig im Forum darüber
Ach ja C lernt man nicht von Heute auf morgen, ich widerhole mich nicht gerne, aber fang mit C auf PC an
Gruß Sebastian
Hallo Izaseba
Najaaa, irgendwann werde ich wohl C brauchen.Zitat:
ich frage mich, warum es C sein muß, wenn Du Dich mit Bascom gut auskennst ?
Sind ja schon fast alle Programmier-Sprachen irgendwie an C angelehnt.
Meinte Beiträge zum Thema String u.s.w. im ForumZitat:
Gibt es nicht genug C Tutorials/Bücher ? Think
l.G. Roberto
Hallo!
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.Zitat:
Zitat von Roberto
MFG Mark
Hallo Mark
z.B. Für Menues auf einem Grafik Display, Meldungen auf einem LCD ,Zitat:
Aber bis es soweit ist, erklär mir bitte erstmal, wofür Du 'sting="text"' brauchst. Gib mir ein Praktisches Beispiel dafür.
übertragung von Text über die Serielle u.s.w.
l.G. Roberto
Ps.:
Habe gerade deinen Code auf dem GCC probiert und funktioniert :-)Zitat:
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.
(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?
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?
(Beim nächsten Beispiel bitte Variablen mit weniger Speicher benutzen ;-) )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
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.
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;
}
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:
gruesseCode:#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;
}
Klasse lässt sich sicher noch optimieren. Ich verwende C++ beim ATmega32 oder ATmega128. Da gibt es damit bisher kein Problem.Zitat:
aber in einem kleinen controller nimmt das zuviel speicher