[Programmiererstammtisch] "Zum ächzenden Compiler"

[Quietsch]

Argh.
Wunderbar mich vollkommen verwirrt damit, dass du char **rest deklarierst....


Jetzt hab' ich es.
Du hast 2 Probleme: rest ist nicht char ** sondern nur char * (also, der rest in der main, nicht in der Funktionssignatur). Du willst ändern, auf welchen string char * rest zeigt.
Und char *w segfaultet, du brauchst char w[6] (siehe https://stackoverflow.com/questions/...lized-with-cha ) - Fuchs version funktioniert, weil er den Ursprungsstring nicht verändert, wenn du ihn aber kürzen willst (i.e. w[i] = '\0'), dann crasht es.

Achtung Spoiler:

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

int split(char * w, char c, char **rest);

int main(void){
	char c = 'a';
    char w[6] = "Hallo\0";
    //char *w = "Hallo\0";    
    char *rest = NULL;
	int i;
	printf("*w: %s\n", w);
	i = split(w, c, &rest);
	printf("%i\n", i);

	if(i == 1){
		printf("**rest: %s\n", rest);
	}

	return 0;	
}

int split(char * w, char c, char **rest) {
	int i = 0;
	while (w[i] != c && w[i] != '\0'){
    	++i;
    }
	if (w[i] == c && rest != NULL) {
		w[i] = '\0';
		*rest = &w[i + 1];
		return 1;
	}
	else
		return 0;
}

[Gobl]

Ich danke euch Habs noch ein klein wenig angepasst und jetzt diese Version:

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

int split(char * w, char c, char **rest);

int main(void){
	char c = 'a';
	char string[] = "Hallo";
	char *w = string;
	char *rest;
	int i;
	
	printf("*w: %s\n", w);
	i = split(w, c, &rest);
	printf("%i\n", i);

	if(i == 1){
		printf("**rest: %s\n", rest);
	}

	return 0;	
}

int split(char * w, char c, char **rest) {
	int i = 0;
	while (w[i] != c && w[i] != '\0')
		++i;
	if (w[i] == c) {
		if(rest != NULL){
                        w[i] = '\0';
			*rest = &w[i +1];
		}
	
		return 1;
	}
	else
		return 0;
}

D.h. der split-Funktion übergebe ich lediglich die Adresse des Pointers, sehe ich das richtig? Würde es denn auch gehen, hier einen Doublepointer zu übergeben? (Wahrscheinlich müsste man davor die Matrix definieren? )
Jetzt bin ich wenigstens ein bisschen schlauer, mal schauen, ob ich nach der Einführungsaufgabe, die restlichen schaffe

Edit: Falscher Code Der Link funktioniert bei mir nicht

[fuchs87]

Noch als Notiz: Die grundlegende Idee ist, der Funktion einen char-Pointer per "call by reference" zu übergeben.

[Gobl]

Nochmal eine Aufgabe:
Implementieren Sie eine Funktion void matrix_init_mult(int *m, int n), die eine uber den
Einfachzeiger m verwaltete n  n-Matrix (mi;j) 1 kleiner gleich i/j kleiner gleich n
mi;j := i
j

Mein Code:

Achtung Spoiler:

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

void matrix_init_mult(int *m, int n);

int main(void){
	int n, i, j;
	int **m;
	
	n = 5;
	
	m = malloc(n * sizeof(int*));
	
	for(i = 0; i < n; i++){
		m[i] = malloc(n *sizeof(int));
		if(!m[i]){
			for (j = 0; j < i; j++){
				free(m[j]);
			}
			free(m);
			printf("Fehler bei Spaltenreservierung");
			return 1;
		}
	}
	
	matrix_init_mult(&m[0][0], 5);
	
	for(i = 0; i < n; i++){
		for(j = 0; j < n; j++){
			printf("%i ", m[i][j]);
		}
		printf("\n");
	}
	
	return 0;
	
}

void matrix_init_mult(int *m, int n){
	int i, j;
	
	for(i = 1; i <= n; i++){
		for(j = 1; j <= n; j++){
			m[(i - 1) * n + j - 1] = i * j;
		}
	}
}

Nur irgendwie wird mein Array falsch befüllt

Achtung Spoiler:

Den Link hab ich dazu gefunden, nur irgendwie passt das Befüllen noch nicht ganz https://stackoverflow.com/questions/...er-to-a-matrix

Edit: Meine Ausgabe:
1 2 3 4 5 das passt noch
8 10 3 6 9
8 12 16 20 5
25 0 8323416 0 0
8344976 0 8323416 0 0

[Ramkhamhaeng]

1. Bitte nimmt nicht den gleichen Variablennamen, wenn sich die Typen unterscheiden. Das war schon beim letzten Mal ein Problem und tritt hier wieder bei m auf.
Eine klassische Variante zur Vermeidung ist das Voranstellen von 'p' für jeden *. So kann man relativ leicht erkennen, ob die „Referenzierungstiefe“ passt.
Hier wäre es also int **pp_m int *p_m.

2. Beachte den Unterschied zwischen dem Initialisieren eines Speicherblocks für alle Vektorspalten (oder Zeilen je nach Interpretation) und separaten Initialisieren.
Du hast oben separat Initialisiert so dass die Werte nicht nebeneinander liegen.
In matrix_init_mult gehst du aber davon aus, dass sie nebeneinander liegen!

=> Erstelle die Matrix mit nur einem einem Speicherblock. Anderenfalls kannst du nicht (ohne Tricks) alle Informationen an matrix_init_mult weitergeben.

3. Es fehlt noch ein Freigeben der verwendeten Matrix.

4. Wenn du mit calloc oder memset (Achtunf, setzt byte-Werte) kannst du das Array mit initialen Werten befüllen.
Dann siehst du schneller ob überhaupt Dinge in die Matrix geschrieben werden.

5. valgrind und z.B. nemiver helfen dir beim Debuggen.

6. Vim + syntastic-Plugin zeigen einem im Editorfenster gleich die Fehlermeldungen und Warnungen.

[Gobl]

Danke schon mal für deine Hilfe. Wir sollen aber unbedingt nur mit einem Texteditor programmieren

Ich hab jetzt weitergesucht und kam jetzt öfter auf diese Lösung: matrix = calloc(n, sizeof(int*)); Nur bei mir stürzt das Programm damit dann ab. Calloc braucht doch Anzahl Felder (n * n?) und die Größe der Felder (Hab ich auch int und int* probiert)

[Gobl]

Ich hab jetzt eine andere Lösung geschafft. Trotzdem würde es mich interessieren, wie man das mit calloc machen würde

Meine Lösung:

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

void matrix_init_mult(int *m, int n);

int main(void){
	int n, i, j;
	int *matrix;
	
	n = 5;
	
	matrix = malloc(n * n * sizeof(int*));

	
	matrix_init_mult(matrix, n);
	
	for(i = 0; i < n; i++){
		for(j = 0; j < n; j++){
			printf("%i ", *(matrix + i * n + j));
		}
		printf("\n");
	}
	
	return 0;
	
}

void matrix_init_mult(int *m, int n){
	int i, j;
	
	for(i = 1; i <= n; i++){
		for(j = 1; j <= n; j++){
			m[(i - 1) * n + j - 1] = i * j;
		}
	}
}

[Ramkhamhaeng]

	matrix = malloc(n * n * sizeof(int*));
        // Typ ist falsch, was bei sizeof(int) != sizeof(int*) problematisch wird
        // Die Alternative, calloc hat zwei Argumente…
	matrix = calloc(n * n, sizeof(int));

Für die ganzen C-Standard-Funktionen kannst du unter Linux/etc einfach in der Konsole 'man [funktionsname]' eingeben und bekommst die wichtigsten Infos zu den Headern.


Bei deinen For-Schleifen würde ich noch empfehlen sie immer von 0 bis n-1 laufen zu lassen, weil das zur Adressierung der Arrays passt.

[EpicFail]

Wenn ich in einem Spiel zeitabhängige Dinge wie zb Angriffs - oder Bewegungsgeschwindigkeit einbauen will, löse ich das dann am besten mit dem Einsatz von clock? Also ich starte einen Timer und dann in jeder Iteration des Loops wird noch ein zweiter Timer abgerufen, wenn die Differenz dann groß genug ist zwischen den Werten macht der Charakter dann etwas.

[[VK]]

Wenn ich in einem Spiel zeitabhängige Dinge wie zb Angriffs - oder Bewegungsgeschwindigkeit einbauen will, löse ich das dann am besten mit dem Einsatz von clock? Also ich starte einen Timer und dann in jeder Iteration des Loops wird noch ein zweiter Timer abgerufen, wenn die Differenz dann groß genug ist zwischen den Werten macht der Charakter dann etwas.

Also normal macht man dass so, dass man ein Delta übergibt. Delta = Zeit die vom letzten Frame vergangen ist. Dieses Delta nutzt du zum Updaten der Position...

x = x + (v(x) * delta)
y = y + (v(y) * delta)

Wenn da mehr Zeit vergeht, ist die Position weiter.
Problem ist, dass man so theoretisch durch Wände springen kann, wenn es lagt. Man kann daher das (v(*) * delta) ein Maximum geben.

[EpicFail]

Also für die Position geht sowas. Wenn ich jetzt aber erreichen will, dass ich zb nur alle X Sekunden angreife?

[[VK]]

Machst du das gleiche, nutzt halt einen counter. Wenn der bei null ist kannst du schießen.

[Harleen]

clock misst die benutzte Prozessorzeit und nicht die Realzeit und ist deshalb nicht wirklich zur Programmsteuerung geeignet. Wenn dein Programm gerade nichts macht (sleep oder warten auf Input, Mutex o.ä.) erhöht sich der Clock counter fast gar nicht. Andererseits läuft der Counter schneller als Realzeit, wenn du mehr als einen CPU-Kern benutzt.
Falls du C++11 benutzt, kannst du mit std::chrono einfach die Differenz der Systemzeit berechnen. Wichtig ist nur, dass du die steady_clock verwendest um keine Probleme bei Zeitsprüngen der Computeruhr zu bekommen.

[EpicFail]

Machst du das gleiche, nutzt halt einen counter. Wenn der bei null ist kannst du schießen.

Damit kann ich aber keine wirkliche Zeit messen oder Das wäre dann ja im Endeffekt davon abhängig wie schnell mein Loop wieder von vorne startet und wenn ich jetzt sage alle x counter soll was passieren, wäre die Zeit ja recht willkürlich (also zB wäre es dann alle 2,1s statt genau alle 2s.)

clock misst die benutzte Prozessorzeit und nicht die Realzeit und ist deshalb nicht wirklich zur Programmsteuerung geeignet. Wenn dein Programm gerade nichts macht (sleep oder warten auf Input, Mutex o.ä.) erhöht sich der Clock counter fast gar nicht. Andererseits läuft der Counter schneller als Realzeit, wenn du mehr als einen CPU-Kern benutzt.
Falls du C++11 benutzt, kannst du mit std::chrono einfach die Differenz der Systemzeit berechnen. Wichtig ist nur, dass du die steady_clock verwendest um keine Probleme bei Zeitsprüngen der Computeruhr zu bekommen.

Ah, ich denke das ist das, was ich gesucht habe

[[VK]]

Damit kann ich aber keine wirkliche Zeit messen oder Das wäre dann ja im Endeffekt davon abhängig wie schnell mein Loop wieder von vorne startet und wenn ich jetzt sage alle x counter soll was passieren, wäre die Zeit ja recht willkürlich (also zB wäre es dann alle 2,1s statt genau alle 2s.)

Dein Delta ist doch sowieso abhängig von der Zeit. Sagen wir mal du hast 60 FPS => Dein delta hat nen Wert von 0.01666

Wenn du alle 2s was machen willst, hast du dann halt folgendes:

if(c <= 0) {
doStuff()
c = 2; // 2 sekunden
} else {
c -= v * delta;
}

v ist halt ein modifikator mit dem du die Zeit beschleunigen/verlangsamen kannst...

Und es ist immer Willkürlich, weil du keine möglichkeit hast etwas genau passend zu machen. Wenn du etwas stärker annähern willst, brauchst du mehr Ticks...