Themen-Überblick
(Aktualisieren)
| Autor |
Nachricht |
SeppJ
|
| Rawr Tiger schrieb: |
Naja, ich habe gelesen, dass Int Zahlen für den Computer am "natürlichsten" sind und er damit am besten arbeiten kann. |
Richtig und doch so falsch. Ein Computer kann nur mit Zahlen arbeiten. Deshalb sind Zeichen auch Zahlen.| Zitat: | | Deshalb ersetzte ich erst alle eingegeben Zeichen durch Int Zahlen und stelle das um, dadurch kann man auch vielleicht schlechter nachvollziehen, dass 7 eigentlich "e" ist. |
 Du implementierst Cäsar und argumentierst mit Sicherheitsargumenten? Und noch dazu mit einem Obscurity Argument? Das ist, wie nicht zu schnell Fahrrad zu fahren, damit man nicht zu viel Benzin verbraucht.| Zitat: |
Und Global ist es, weil ich damit vorraussichtlich öfters arbeiten werde. |
Das ist ein besonders guter Grund, es nicht global zu machen. Denn je häufiger du ein globales Objekt benutzt, desto wahrscheinlicher bekommst du die Nachteile globaler Variablen zu spüren. |
|
|
 |
Rawr Tiger
|
| DirkB schrieb: | Warum ist text_caesar ein int-Array?
Und warum ist es global?
Ist bei while (text_caesar[i] != '0') {i++;} wirklich das Zeichen '0' gemeint? Das ist etwas anderes als '\0'.
Dein crypt_retrorsum kopiert die Stelle text_caesar[0] nicht, weil die Schleife vorher abbricht.
Zeile 45 ist eigentlisch ein Fall für eine for-Schleife. Und in C wird in Zählschleifen meist auf < statt != getestet. Also for(i=0; i<20; ++i) |
Naja, ich habe gelesen, dass Int Zahlen für den Computer am "natürlichsten" sind und er damit am besten arbeiten kann. Deshalb ersetzte ich erst alle eingegeben Zeichen durch Int Zahlen und stelle das um, dadurch kann man auch vielleicht schlechter nachvollziehen, dass 7 eigentlich "e" ist.
Und Global ist es, weil ich damit vorraussichtlich öfters arbeiten werde.
Das mit dem "\0" war es wohl.
Aufjedenfall wurde das nun verbessert und funktioniert. Ich editiere das am besten oben, damit ich nicht wieder den ganzen Quellcode posten muss. |
|
|
|
DirkB
|
Warum ist text_caesar ein int-Array?
Und warum ist es global?
Ist bei while (text_caesar[i] != '0') {i++;} wirklich das Zeichen '0' gemeint? Das ist etwas anderes als '\0'.
Dein crypt_retrorsum kopiert die Stelle text_caesar[0] nicht, weil die Schleife vorher abbricht.
Zeile 45 ist eigentlisch ein Fall für eine for-Schleife. Und in C wird in Zählschleifen meist auf < statt != getestet. Also for(i=0; i<20; ++i) |
|
|
|
icarus2
|
Also du willst im Prinzip Caesar implementieren? Oder sehe ich das falsch  |
|
|
|
Rawr Tiger
|
Ich versuche eine "Verschlüsselung" zu programmieren. Hier vielleicht erst der Code und dann die Erklärung wie ich mir das Vorstelle.
| C++: | 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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208 | #include <stdio.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
int caesar (char);
void crypt_retrorsum ();
int crypt_meth2 (int*);
int crypt_meth3 (int*);
int crypt_meth4 (int*);
int crypt_meth5 (int*);
int crypt_meth6 (int*);
int crypt_meth7 (int*);
int crypt_meth8 (int*);
int crypt_meth9 (int*);
int crypt_meth10 (int*);
int crypt_meth11 (int*);
int crypt_meth12 (int*);
int crypt_meth13 (int*);
int crypt_meth14 (int*);
int crypt_meth15 (int*);
int crypt_meth16 (int*);
int crypt_meth17 (int*);
int crypt_meth18 (int*);
int crypt_meth19 (int*);
int crypt_meth20 (int*);
void write_files (int*,bool*);
int text_caesar [10240];
main () {
char text [10240];
bool methlist [20];
int i = 0;
srand((unsigned)time(NULL));
printf("Methodenliste: ");
for(i=0; i<20; ++i)
{
methlist[i] = rand() % 2;
printf("%i", methlist[i]);
}
i = 0;
printf("\n\nVerf\x81gbare Zeichen\n================================\n\nabcdefghijklmnopqrstuvwxyz\nABCDEFGHIJKLMNOPQRSTUVWXYZ\n0123456789\n!?,.:\"\n\x81\x84\x94 \x9A\x8E\x99\n\n(sonstige Zeichen werden nicht verschl\x81sselt)");
printf("\n\nBitte Text eingeben\n================================\n\n");
gets(text);
printf("\n================================\n\n");
while(text[i] != '\0')
{
text_caesar [i] = caesar (text[i]);
i++;
}
crypt_retrorsum ();
write_files (text_caesar,methlist);
}
int caesar (char textan) {
switch (textan)
{
case ' ' : return 42; break;
case 'e' : return 7; break;
case 'n' : return 8; break;
case 'i' : return 9; break;
case 's' : return 1; break;
case 'r' : return 2; break;
case 'a' : return 3; break;
case 't' : return 4; break;
case 'd' : return 5; break;
case 'h' : return 6; break;
case 'u' : return 15; break;
case 'l' : return 16; break;
case 'c' : return 17; break;
case 'g' : return 18; break;
case 'm' : return 19; break;
case 'o' : return 11; break;
case 'b' : return 12; break;
case 'w' : return 13; break;
case 'f' : return 14; break;
case 'k' : return 20; break;
case 'z' : return 26; break;
case 'p' : return 27; break;
case 'v' : return 28; break;
case 'ß' : return 29; break;
case 'j' : return 21; break;
case 'y' : return 22; break;
case 'x' : return 23; break;
case 'q' : return 24; break;
case 'E' : return 25; break;
case 'N' : return 30; break;
case 'I' : return 37; break;
case 'S' : return 38; break;
case 'R' : return 39; break;
case 'A' : return 31; break;
case 'T' : return 32; break;
case 'D' : return 33; break;
case 'H' : return 34; break;
case 'U' : return 35; break;
case 'L' : return 36; break;
case 'C' : return 40; break;
case 'G' : return 48; break;
case 'M' : return 49; break;
case 'O' : return 41; break;
case 'B' : return 43; break;
case 'W' : return 44; break;
case 'F' : return 45; break;
case 'K' : return 46; break;
case 'Z' : return 47; break;
case 'P' : return 50; break;
case 'V' : return 51; break;
case 'J' : return 52; break;
case 'Y' : return 53; break;
case 'X' : return 54; break;
case 'Q' : return 55; break;
case '0' : return 56; break;
case '1' : return 57; break;
case '2' : return 58; break;
case '3' : return 59; break;
case '4' : return 60; break;
case '5' : return 65; break;
case '6' : return 66; break;
case '7' : return 67; break;
case '8' : return 68; break;
case '9' : return 69; break;
case '!' : return 61; break;
case '"' : return 62; break;
case '.' : return 63; break;
case ',' : return 64; break;
case ':' : return 70; break;
case '?' : return 71; break;
case 0x81 : return 77; break; //ü
case 0x84 : return 78; break; //ä
case 0x94 : return 79; break; //ö
case 0x9A : return 72; break; //Ü
case 0x8E : return 73; break; //Ä
case 0x99 : return 74; break; //Ö
default : return 0;
}
}
void write_files (int *text_caesar, bool *methlist) {
FILE *stream;
int i = 0;
if((stream = fopen("crypt","w")) == NULL)
{
printf("\nFehler beim Oeffnen!");
exit(1);
}
while(text_caesar[i] != '\0')
{
fprintf(stream,"%x ",text_caesar [i]);
i++;
}
fclose(stream);
i = 0;
if((stream = fopen("methodenliste.txt","w")) == NULL)
{
printf("\nFehler beim Oeffnen!");
exit(1);
}
while(i != 20)
{
fprintf(stream,"%i",methlist [i]);
i++;
}
fclose(stream);
}
void crypt_retrorsum () {
int text_temp [10240];
int i = 0, r = 0;
while (text_caesar[i] != '\0') {i++;}
while (i != 0)
{
text_temp [r] = text_caesar[i];
i--;
r++;
}
} | |
So, Zuerst wird halt eine "Methodenliste" erstellt, 20 stellig. Davon wird später abhängig sein, wie der Text dann verstellt wird. int crypt_meth2 - int crypt_meth20 sind provisorisch. Die erste Methode ist praktisch den Text rückwärts zu setzten. Falls nun in der Methodenliste der Index [0] = 1 ist soll die Funktion "crypt_retrorsum" den Text umstellen.
Zum Schluss wird halt der umgestellte Text in einer Datei gespeichert und zusätzlich die Methodenliste, damit man später diese eintippen kann und das Programm zum Entschlüsseln weiss, welche Methoden verwendet wurden.
Nachträglich editiert :
| C++: | | while (text_caesar[i] != '\0') {i++;} | |
war | C++: | | while (text_caesar[i] != '0') {i++;} | |
war |
|
|
|
DirkB
|
Du musst auch zwischen Größe des Arrays und Anzahl der gültigen Werte (Länge der Daten) unterscheiden.
Bei char text[200] = "Hallo Welt"; ist das Array 200 Zeichen groß. Davon sind 11 Zeichen belegt (inklusive der '\0').
Mit strlen() bekommst du 10 heraus. |
|
|
|
icarus2
|
| Rawr Tiger schrieb: |
Ich habe noch eine Frage, wie kommt es, dass :
trotzdem funktioniert ?
|
Was soll denn der Code ueberhaupt machen?
| Rawr Tiger schrieb: |
Ich trage ja Werte in die Array ein z.B. 5 6 7 8 und jetzt wäre die Anzahl der eingetragenen Zahlen ja 4, von Index 0 bis 3.
|
Ich sehe nicht, dass irgendwelche Zahlen eingetragen werden.
Du sollst wissen, dass
| C++: | | while(intarray[i] != '\0') | |
aequivalent ist zu
| C++: | | while(intarray[i] != 0) | |
(Ich hoffe zumindest, dass alle Implementierungen 0 verwenden, um '\0' zu codieren). |
|
|
|
Rawr Tiger
|
Ich habe noch eine Frage, wie kommt es, dass :
| C++: | 1
2
3
4
5
6
7
8 | int intarray [10240];
while(intarray[i] != '\0')
{
fprintf(stream,"%x ",intarray [i]);
i++;
} | |
trotzdem funktioniert ?
Ich trage ja Werte in die Array ein z.B. 5 6 7 8 und jetzt wäre die Anzahl der eingetragenen Zahlen ja 4, von Index 0 bis 3. Und falls ich es mit den angegeben Codes sowohl von icarus2 als auch von SeppJ versuche zeigt er mir halt "10240" an und hängt sich dann auf. |
|
|
|
icarus2
|
| C++: | int array[10];
printf("%d\n", sizeof(array) / sizeof(array[0]) ); | |
Funktioniert nicht bei dynamisch allozierten Arrays. |
|
|
|
Unregistrierter
|
sizeof(intArr). Funktioniert natürlich nicht, wenn das Array per malloc() erstellt wurde.
EDIT: Nicht ganz korrekt. SeppJ hat die richtige Lösung. |
|
|
|
|
|
|
|
|
Twitter
Facebook