ist mein Code Standardkonform

DrGreenthumb

Stammtischler schrieb:

DrGreenthumb schrieb:

Vertexwahn schrieb:

if(abs(dx)-abs(dy)>=0)
		{
			da = abs(dx);
			db = abs(dy);
			Z = true;
		}
		else
		{
			da = abs(dy);
			db = abs(dx);
			Z = false;
		}

das würde ich so schreiben:

int da = abs(dx), db = abs(dy);
    if(z = da - db >= 0)
        swap(da, db);

int da = abs(dx), db = abs(dy);
    if(Z = da - db < 0)
        swap(da, db);

so ists richtig!

äh, bin ich jetzt blöd Im Originalcode wird Z auf true gesetzt, wenn die Bedingung da - db >= 0 zutrifft.
Also: Z = da - db >= 0

@Ponto
ah, thx

camper

edit: müll

borg

#include <iostream>

int main( )
{
    bool a = true;
    bool b = false;
    std::cout << (a?4:0) << std::endl;
    std::cout << a*4 << std::endl;
    std::cout << (a?2:0) << std::endl;
    std::cout << a*2 << std::endl;
    std::cout << (b?4:0) << std::endl;
    std::cout << b*4 << std::endl;
    std::cout << (b?2:0) << std::endl;
    std::cout << b*2 << std::endl;

    std::cout << std::endl << (int)a << std::endl;
    std::cout << (int)b << std::endl;
}

ausgabe schrieb:

4
4
2
2
0
0
0
0

1
0

mit gcc und vc++. was mache ich falsch?

jede beliebige zahl ungleich 0 gecastet als bool ist true, true zum int gecastet ist 1. wenn das nicht so ist, sind in ganz vielen programmen von mir fehler

DrGreenthumb

DrGreenthumb schrieb:

Stammtischler schrieb:
DrGreenthumb schrieb:
das würde ich so schreiben:
int da = abs(dx), db = abs(dy);
    if(z = da - db >= 0)
        swap(da, db);
int da = abs(dx), db = abs(dy);
    if(Z = da - db < 0)
        swap(da, db);
so ists richtig!
äh, bin ich jetzt blöd Im Originalcode wird Z auf true gesetzt, wenn die Bedingung da - db >= 0 zutrifft.
Also: Z = da - db >= 0

ah, jetzt seh ich's. swap wird falsch aufgerufen. Wenn ichs jetzt nicht wieder verpeile, müsste es dann aber so aussehen:

int da = abs(dx), db = abs(dy);
    if(!(Z = da - db >= 0))
        swap(da, db);

sonst hat Z den falschen Wert.

Vertexwahn

> Man kann es also nur für unsigned Typen annehmen.

so ein scheiß - in meinem C++ Kompendium steht das eine einfache Linksverschiebung bzw. einfache Rechtverschiebung für einen int (der ja signed ist) gleichbedeutent mit einer Multiplikation bzw. Division durch/mit 2 ist

mmh entweder ich nehm jetzt unsigned int her oder ich multipliziere doch mit 2 und schiebe die arbeit auf den compiler - mmh...

DrGreenthumb

Vertexwahn schrieb:

mmh entweder ich nehm jetzt unsigned int her oder ich multipliziere doch mit 2 und schiebe die arbeit auf den compiler - mmh...

argh, natürlich multiplizierst du einfach mit 2! Das macht den Code leserlicher und kommt aufs selbe raus.

Vertexwahn

> argh

tschuldigung - ok ich sehs ja ein

Michael E.

camper: Bashar: Danke für die Richtigstellung

Vertexwahn

Momentaner Stand

/*
	Beschreibung zum Algorithmus:
	http://turing.fh-landshut.de/~jamann/Bresenham.doc

	Autor: Julian Amann
	Kontakt: vertexwahn@gmx.de
	Erstellt am: 19.02.2005

	Ich setzte ein kartesisches Rechsthaendiges Koordinatensystem und eine SetPixel Funktion voraus.
*/

void Bresenham(int d1x, int d1y, int d2x, int d2y) 
{    
	bool Z = true;     // zur Bestimmung der Bewegunsrichtung 
	int *m;            // Bewegungsrichtung/Vektoren 

	// delta a, delta b und Bewegungsrichtung bestimmen 
	int dx = abs(d2x) - abs(d1x); 
	int dy = abs(d2y) - abs(d1y); 

	int da = abs(dx), db = abs(dy); 

	if(da-db<0)
	{
		int tmp = da;
		da = db;
		db = tmp;
		Z = false;
	}

	bool X = (dx >= 0); 
    bool Y = (dy >= 0); 

    int array[8][4] = 
    { 
		{ 0,-1,-1,-1 },        
        { 0,-1,1,-1 },        
        { 0,1,-1,1 },        
        { 0,1,1,1 },        
        { -1,0,-1,-1 },        
        { 1,0,1,-1 },        
        { -1,0,-1,1 },        
        { 1,0,1,1 },        
    }; 

    m = array[(X?1:0) + (Y?2:0) + (Z?4:0)]; 

    int gradient = 2 * db - da; 
    int x = d1x; 
    int y = d1y; 

    SetPixel(x, y); 

    for(int i = 0; i < da; i++) 
    { 
		if(gradient >= 0) 
        { 
			x = x + m[2]; 
            y = y + m[3]; 
            gradient = gradient + 2 * db - 2 * da; 
        } 
        else 
        { 
            x = x + m[0]; 
            y = y + m[1]; 
            gradient = gradient + 2 * db;
        } 

        SetPixel(x, y); 
    } 
}

camper

wenn du sparen willst, lässt du X,Y,Z weg and benutzt die bedingungen direkt um m zu initialisieren, ausserdem würd ich array static const und m const machen.

static const int array[8][4] =
    {
        { 0,-1,-1,-1 },        
        { 0,-1,1,-1 },        
        { 0,1,-1,1 },        
        { 0,1,1,1 },        
        { -1,0,-1,-1 },        
        { 1,0,1,-1 },        
        { -1,0,-1,1 },        
        { 1,0,1,1 },        
    };

    const int* const m = array[(dx>=0?1:0) + (dy>=0?2:0) + (da>=db?4:0)];
    if(da<db) swap(da,db);