Hallo,
bin zwar neu hier, aber hätte ein paar Fragen zu Zeigern, wäre euch sehr dankbar, wenn ich mir diese beantworten könntet, da ich das noch nicht (ganz) verstehe.
Es reichen auch simple Ja/Nein.
Bitte korrigieren, wenn was falsch ist.
Und sorry wenn es sich hier um triviale Dinge handelt, hatte aber vorher nie C++/Zeigern zu tun.
Und eine Frage vorab, welche Schreibweise empfiehlt ihr?
int* pointer;
int * pointer;
int *pointer;
Ich weiß, dass das alles gleich ist, aber vielleicht gibt es da eine bevorzugte Schreibweise?
|
C-/C++-Quelltext
|
1
2
3
|
int i = 11;
int *ip; // ip ist ein Zeiger auf einen int-Wert
ip = &i; // ip zeigt auf die Adresse von i
|
Ist dieser Code äquivalent zu:
|
C-/C++-Quelltext
|
1
2
|
int i = 11;
int *ip = &i;
|
?
Das verwirrt mich etwas, denn normal wäre ja z. B. *ip = 100; aber hier wird die Adresse von i "gespeichert".
Also kann man die zweite Schritte int *ip; ip = &i; in einem zusammenfassen: int *ip = &i. Sehe ich das richtig so?
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
|
double d[10] = {1,2,3,4,5,6,7,8,910};
double *dp1 = d; // mit d übergibt man den Anfang des arrays? Wieso nicht &d?
cout << dp1 << endl; // wäre dann die Adresse von d[0].
cout << *dp1 << endl; // wäre dann d[0], in diesem Falle 1.
double *dp2 = dp1 + 1; // dp2 zeigt auf Adresse von a[1]?
cout << dp2 - dp1 << endl; // Adresse von a[1] - Adresse von a[0] = 1?
|
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
|
const int n = 10;
int a[n+1];
int key = 6;
int i;
a[n] = key;
int *p = a;
while(*p++ != key); // Solange der Wert von der Adresse auf die p zeigt ungleich key, inkrementiere die Adresse auf die p zeigt um eins? Müsste nicht *(p++) stehen, sonst könnte man doch meinen dass der Wert von der Adresse auf die p zeigt inkrementiert wird?
i = p - a - 1; // Wieso hier -1?
|
|
C-/C++-Quelltext
|
1
2
|
matrix[i][j] // Zweidimensionales Array
matrix[i, j] // Was ist das?
|
Dann noch mehr Fragen - zu C-Zeichenketten.
|
C-/C++-Quelltext
|
1
2
3
4
5
6
|
char *str = "ABC"; // Zeiger zeigen doch auf Adressen, wieso wird hier "ABC" "zugewiesen"?
// Oder gilt hier char *str == char str[]?
cout << str; // Ausgabe: ABC. Wieso ABC?
int i = 1;
cout << str[i]; // Ausgabe: B. Wieso kann hier bei str auf eine Stelle zugegriffen werden, wie bei einem Array?
cout << *(str + i); // Ausgabe: B. Hier das gleiche.
|
|
C-/C++-Quelltext
|
1
2
3
4
5
6
|
char *str = "Irgend ein Text.";
char *tmp = str; // tmp zeigt auf str und str zeigt auf "Irgend ein Text."?
int len = 0;
while(*tmp++) // Wieso nicht *str++?
len++;
cout << "Laenge des Strings " << str << " = " << len << endl;
|
|
C-/C++-Quelltext
|
1
2
3
|
char *original = "Irgend ein Text.";
char *duplikat;
duplikat = original; // Wäre hier auch char *duplikat = original möglich?
|
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
|
/* C-Strings kopieren */
char *source = "Irgend ein Text.";
char dest[80];
char *s = source;
char *d = dest;
while (*d++ = *s++); // Was muss denn hier passieren, damit es abgebrochen wird?
|
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
|
char *sa[] = {"eins\n", "zwei\n"}; // Wieso hier noch der *? Ist das char sa[][] bzw. char **sa?
char **sp = sa; // Wie wäre das in 2 Schritten? char **sp; sp = sa?
cout << sa[0] << endl; // eins
cout << *sa << endl; // eins
cout << sa[1] << endl; // zwei
cout << sa[1][0] << endl; // z
cout << *sp << endl; // eins
cout << sp[1] << endl; // zwei
|
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
#include
using namespace std;
struct Person
{
char name[80], address[80];
double salary;
};
Person person[50];
void printperson(Person const &p)
{
cout << "Name: " << p.name << endl;
cout << Adress: " << p.address << endl;
}
Person const &getperson(int index) // Was soll hier das & bei getperson bedeuten/bringen?
{
// ...
return person[index];
}
int main()
{
Person boss;
printperson(boss);
printperson(getperson5));
}
|
Dann habe ich hier noch einen längeren Quellcode mit paar Fragen.
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
|
#include <iostream>
#include <stddef.h>
using namespace std;
// Liefert die Anzahl der Zeichen, die in s enthalten sind. Das abschließende Null-Byte wird nicht mitgezählt.
size_t my_strlen(const char *s);
// Kopiert die Zeichenkette src Zeichen für Zeichen in die Zeichenkette dest. Das abschließende Null-Byte wird auch kopiert. Liefert dest als Funktionsewert zurück.
char *my_strcpy(char *dest, const char *src);
// Hängt eine Kopie der zeichenkette src an die zeichenkette dest an. Liefert dest als Funktionswert zurück.
char *my_strcat(char *dest, const char *src);
// Liefert einen Zeiger auf das erste Vorkommen des Zeichens in der Zeichenkette s zurück oder aber NULL, falls c nicht in s enthalten ist.
char *my_strchr(const char *s, char c);
// Vergleicht die Zeichenketten s1 und s2; liefert einen Wert <0, wenn s10, wenn s1>s2 ist.
int my_strcmp(const char *s1, const char *s2);
int main (int argc, char * const argv[])
{
const char *str1 = "Wie man sich bettet, so liegt man.";
const char *str2 = "Wie man in den Wald hineinruft, so schallt es heraus.";
char ziel[256];
char *tmp;
cout << "Die Zeichenkette \"" << str1 << "\" enthaelt "
<< my_strlen(str1) << " Zeichen.\n" << endl;
my_strcpy(ziel,str1);
cout << ziel << "\n" << endl;
my_strcpy(ziel+21, str2+32);
cout << ziel << "\n" << endl;
my_strcat(ziel, " ");
my_strcat(ziel, str2);
cout << ziel << "\n" << endl;
tmp = my_strchr(ziel, ',');
cout << (tmp == NULL?"NULL":tmp) << endl;
tmp = my_strchr(ziel, 'S');
cout << (tmp == NULL?"NULL":tmp) << "\n" << endl;
cout << my_strcmp(str1, str2) << endl;
return 0;
}
size_t my_strlen(const char *s)
{
const char *p = s; // Was genau passiert hier? Worauf zeigt p?
while(*++p);
return p-s;
}
char *my_strcpy(char *dest, const char *src) // Wofür ist der * bei my_strcpy?
{
char *temp = dest;
while(*dest++ = *src++);
return temp;
}
char *my_strcat(char *dest, const char *src)
{
char *temp = dest;
while(*dest)
dest++;
while(*dest++ = *src++);
return temp; // Wieso nicht return dest?
}
char *my_strchr(const char *s, char c)
{
while(*s)
{
if(*s==c)
return const_cast<char*>(s); // s ist doch schon const char*? Wofür das Casten?
s++;
}
return NULL;
}
int my_strcmp(const char *s1, const char *s2)
{
for(; *s1 == *s2; s1++, s2++)
if(*s1 == '\0')
return 0;
return *s1 - *s2;
}
|
Danke schonmal.
VG AF1.