3. Wie breit sollte Quellcode sein?

Wie breit sollte Quellcode sein?

  • D

    Hi.

    Ich habe vor einer Weile angefangen, mich näher mit C++ zu beschäftigen, und der Editor den ich dazu verwende, macht nach 80 Zeichen standardmäßig einen Zeilenumbruch. Ich vermute mal, dass das ein Überbleibsel der DOS-Konsole (oder was noch früherem) ist - auf den Bildschirm passen weit mehr Zeichen.

    Was ich eigentlich wissen wollte ist, wie breit macht ihr euren Quellcode?
    Ich komme zwar meistens selber nicht auf 80 Zeichen, aber ein längeres if-Konstrukt o. ä. überschreitet das dann doch manchmal - es aufzutrennen wirkt unschön.

    Auf der einen Seite bin ich im Internet schon auf Leute gestoßen, die sich ziemlich darüber aufgeregt haben, dass der Code teilweise länger ist, auf der anderen Seite kommt mir das ganze wie ein Anachronismus vor...

    Drangon

    0
  • S

    ich schreibe den code immer so breit wie es passt.

    normalerweise arbeite ich mit etwa 120 zeichen pro zeile, wobei das nur selten erreicht wird.

    ich halte die zeilen naemlich dadurch kurz, indem ich sie da teile, wo es sinn macht. bsp:

    function escape($str){
		return str_replace(
			array("\n", "\r", "\t", "\f", "\0"),
			array('\n', '\r', '\t', '\f', 'NUL'),
			$str
		);
	}

    statt

    function escape($str){
		return str_replace(array("\n", "\r", "\t", "\f", "\0"), array('\n', '\r', '\t', '\f', 'NUL'), $str);
	}

    denn diese aufteilung macht den code klarer - die laenge ist mir egal, es geht um die lesbarkeit.

    0
  • V

    Drangon schrieb:

    Was ich eigentlich wissen wollte ist, wie breit macht ihr euren Quellcode?

    80 zeichen.

    Ich komme zwar meistens selber nicht auf 80 Zeichen, aber ein längeres if-Konstrukt o. ä. überschreitet das dann doch manchmal - es aufzutrennen wirkt unschön.

    glaub ich net.

    0
  • ?

    100

    0
  • N

    Ich schreib sowit wie platz ist eine Anweisung. Wenn das nicht reicht, mach ich nach Zeilenumbruch eingerückt weiter.

    0
  • A

    Ich hab es auf 120 Zeichen pro Zeile eingestellt. 80 ist zu wenig und selbst bei 1024x786 Pixel zu geizig. Alles was mehr als 120 Zeichen hat, wird schon wieder unleserlich.

    0
  • V

    Artchi schrieb:

    80 ist zu wenig

    warum?

    0
  • ?

    80 sind butterweich. In ganz seltenen Fällen mach ich bis 83, darüber nie. 80 sind auf jeden Fall das, was ich anstrebe. Und immer wenn ich Platz-Probleme hab, kann ich bestimmt irgendwas noch schöner schreiben.

    0
  • G

    volkard schrieb:

    Artchi schrieb:

    80 ist zu wenig

    warum?

    die frage ist doch wieso sollte man 80 zeichen verwenden, wenn man bei 1024 schon 120 schreiben kann ohne horizontal scrollenzu müssen?
    man kann ja die funktion-sollte-nicht-über-einen-bildschirm-gehen-regel gegen eine funktion-sollte-nicht-über-1/3-des-bildschirm-gehen anpassen

    0
  • D

    Also ich hab manchmal if-Kontrukte mit bis zu 200 Zeichen in einer Zeile stehen.
    Wird aber meist beim nächsten Durchgang geändert, weil das ja kein Mensch lesen kann.

    0
  • ?

    die frage ist doch wieso sollte man 80 zeichen verwenden, wenn man bei 1024 schon 120 schreiben kann ohne horizontal scrollenzu müssen?

    Hängt doch von der IDE ab. Ich kann auch links oder rechts ne fette Klassen-Übersicht haben. Oder ne größere Schriftgröße. Ich komm bei 1024 nicht über 80 raus. Hab zwar 1280, aber 80 sind wahrscheinlich ein gutes Maß. Bei der Süddeutschen schreiben sie auch nicht über die 1,5m Breite sondern machen Spalten. Ist manchmal einfach lesbarer, wenn man sein Auge nicht von ganz links nach ganz rechts rollen muss.

    0
  • V

    Optimizer schrieb:

    Und immer wenn ich Platz-Probleme hab, kann ich bestimmt irgendwas noch schöner schreiben.

    das gefällt mir 🙂

    0
  • V

    Gerard schrieb:

    man kann ja die funktion-sollte-nicht-über-einen-bildschirm-gehen-regel gegen eine funktion-sollte-nicht-über-1/3-des-bildschirm-gehen anpassen

    ein if sollte nicht mehr als ein && oder || haben. wein while sollte gar keins haben. for sollte nur die laufvariable behandlen und nur innen anhand der daten break oder continue machen, falls das nötig ist. funktionen sollten nicht 5 parameter brauchen. und schwupps, ist der code schmal. oder?

    0
  • ?

    wenn man vernünftige variablennamen nimmt ist es schwer mit 80 zeichen auszukommen.

    0
  • V

    nope. schrieb:

    wenn man vernünftige variablennamen nimmt ist es schwer mit 80 zeichen auszukommen.

    eigentlich fürchte ich mich nicht vor langen bezeichnern.
    wenn man was langes auszudrücken hat damit, muss der name auch lang sein.

    bool isPrime(u32 p);
u32 nextPrime(u32 last);
u32 nextPrimeTwin(u32 last);

////////////////////////////////////////////////////////////////////////////////
//Ab hier privat

inline bool isPrimeCheckBelow32(u32 p)
{//bei p<=6 einfach nachschauen. 
	//Das Bitmuster ersetzt ein ArrayOfBool.
	// 3         2         1         0
	//10987654321098765432109876543210
	//10100000100010100010100010101100
	return getBit(0xa08a28ac,p);//Nur die Bits 2,3,5 sind gesetzt.
};

inline bool isPrimeCheckFactorsBelow6(u32 p)
{//Teiler 2,3 und 5 mit einer Division testen
	return getBit(0x208A2882,p%30);//Nur die Bits 1,7,11... sind gesetzt.
};

inline bool isPrime(u32 p)
{
	bool isPrimeCheckFactorsAbove5(u32 p);
	if(p<32) return isPrimeCheckBelow32(p);
	if(!isPrimeCheckFactorsBelow6(p)) return false;
	return isPrimeCheckFactorsAbove5(p);
};

u32 powMod(u32 base,u32 exp,u32 modul)
{//rechnet 'base hoch exp mod modul'
	u32 a1=base,z1=exp,x=1,m=modul;
	while(z1!=0)
	{
		while((z1%2)==0)
		{
			z1/=2;
			a1=mulMod(a1,a1,m);
		};
		--z1;
		x=mulMod(x,a1,m);
	};
	return x;
}

bool isSPRP(u32 n,u32 a)
{
// Zitat: "One way to make the Fermat probable primality test more 
//	accurate is to write n-1=2sd where d is odd and s is nonnegative. 
//	Then n is a strong probable-prime base a (an a-SPRP) if either 
//	ad = 1 (mod n) or (ad)2r = -1 (mod n) for some nonnegative r 
//	less than s."
//	Quelle: http://www.utm.edu/research/primes/glossary/StrongPRP.html 
//	
//	Zitat: "Millers Test: Assume the generalized Riemann hypothesis 
//	is true. If n is an a-SPRP for all integers a with 
//	1 < a < 2(log n)2, then n is prime.
//	Quelle: http://www.utm.edu/research/primes/glossary/MillersTest.html
	u32 o=n-1;
	u32 e=findFirstBitTrue(o);
	o>>=e;
	u32 x=powMod(a,o,n);
	if(x==1) return true;
	if(x==n-1) return true;
	for(u32 i=0;i<e;++i)
	{
		x=mulMod(x,x,n);
		if(x==n-1) return true;
	};
	return false;
}

bool isPrimeCheckFactorsAbove5BySPRPCheck(u32 p)
{
// If n < 4,759,123,141 is a 2, 7, and 61-SPRP, then n is prime.
//	Quelle: http://www.utm.edu/research/primes/glossary/StrongPRP.html
//
//	Diese drei Tests reichen also, um alle Zahlen im Bereich bis 
//	2^32 zu testen. Besser sind die folgenden Zahlen, weil bis 
//	n<45559729 nur zwei Tests ben®tigt werden. 
//	Die Zahlen habe ich mit einem eigens daf¬r geschriebenen Programm 
//	gesucht. 
	if(!isSPRP(p,7252)) return false;//die 7252 deckt ab hier den gr®+ten Bereich Fehlerfrei ab
	if(p<13747) return true;//bis p<13747 ist das Ergebnis sicher
	if(!isSPRP(p,1607438)) return false;//die 1607438 deckt ab hier den gr®+ten Bereich Fehlerfrei ab
	if(p<45559729) return true;//bis p<45559729 ist das Ergebnis sicher
	if(!isSPRP(p,9786)) return false;//die 9786 deckt den Rest bis 2^32 ab
	return true;
}

namespace
{
	u32 primes[]={0,7,7*7,11,11*11,13,13*13,17,17*17,19,19*19,23,23*23,29,29*29,31,u32(-1)};
}

bool isPrimeCheckFactorsAbove5(u32 p)
{
	{//Zuerst die kleinen Teiler checken
		u32 *t=primes;
		do
		{
			if(p%*++t==0) return false;//teilt, also keine Primzahl
		}
		while(*++t<=p);
		if(*t!=-1) return true;
	}
	return isPrimeCheckFactorsAbove5BySPRPCheck(p);
};

//Zitat: "Rather than divide by just the primes, it is sometimes 
//more practical to divide by 2, 3 and 5; then by all the numbers 
//congruent to 1, 7, 11, 13, 17, 19, 23, and 29 modulo 30--again 
//stopping when you reach the square root. This type of factorization 
//is sometimes called wheel factorization. Look in most any elementary 
//text on number theory for information about these tests. 
//Quelle: http://www.utm.edu/research/primes/prove/prove2.html

//Die Idee, da+ Primzahlen-Kandidaten p nur dann ¬berhaupt als 
//Primzahlen in Frage kommen, wenn p mod 30 nicht durch 2,3,5 
//teilbar ist, wird in den folgenden Verfahren ®fters zur Anwendung 
//kommen. Bitte behalten Sie diesen Satz stehts im Ged║chtnis!

//Position der nºchsten Primzahl
u32 firstPrimeNext[11]={2,2,3,5,5,7,7,11,11,11,11};

//Offset zur n║chstm®glichen Primzahlenposition
u32 diffPrime[30]={1,6,5,4,3,2,1,4,3,2,1,2,1,4,3,2,1,2,1,4,3,2,1,6,5,4,3,2,1,2};
//Selber Offset zyklisch in Z30 erspart: if(m>30)m-=30
//Zweck: Sprªnge sind auf modernen Prozessoren zu teuer.
u32 diffPrimeM[30]={1,6,5,4,3,2,1,4,3,2,1,2,1,4,3,2,1,2,1,4,3,2,1,6,5,4,3,2,1,u32(2-30)};

u32 nextPrime(u32 last)
{
	if(last<11) return firstPrimeNext[last];
	u32 p=last;
	u32 mp=p%30;
	do
	{
		p+=diffPrime[mp];
		mp+=diffPrimeM[mp];
	}while(!isPrimeCheckFactorsAbove5(p));
	return p;
};

//Offset zur nºchstm©glichen Primzahlenzwillings-Position
u32 diffPrimeTwin[30]={11,10,9,8,7,6,5,4,3,2,1,6,5,4,3,2,1,12,11,10,9,8,7,6,5,4,3,2,1,12};
//Selber Offset zyklisch in Z30 erspart: if(m>30)m-=30
//Zweck: Sprªnge sind auf modernen Prozessoren zu teuer.
u32 diffPrimeTwinM[30]={11,10,9,8,7,6,5,4,3,2,1,6,5,4,3,2,1,12,11,10,9,8,7,6,5,4,3,2,1,u32(12-30)};
//Position des n║chsten Primzahlenzwillings
u32 firstPrimeNextTwin[11]={3,3,3,5,5,11,11,11,11,11,11};

u32 nextPrimeTwin(u32 last)
{
	if(last<11)
		return firstPrimeNextTwin[last];
	u32 p=last;
	u32 mp=p%30;
	do
	{
		p+=diffPrimeTwin[mp];
		mp+=diffPrimeTwinM[mp];
	}while(!isPrimeCheckFactorsAbove5(p)||!isPrimeCheckFactorsAbove5(p+2));
	return p;
}

    naja, hab die 80 zeichen überschritten bei

    if(!isSPRP(p,7252)) return false;//die 7252 deckt ab hier den gr®+ten Bereich Fehlerfrei ab

    aber ist nicht so tragisch, der code blieb ja einfach und es war nur ein langweiliger kommentar.

    bei der tabelle

    u32 primes[]={0,7,7*7,11,11*11,13,13*13,17,17*17,19,19*19,23,23*23,29,29*29,31,u32(-1)};

    und lang wurde es bei

    }while(!isPrimeCheckFactorsAbove5(p)||!isPrimeCheckFactorsAbove5(p+2));

    zeig mir am besten, wo es unumgänglich ist, dauernd über 80 zechen zu gehen, weil du lange bezeichner verwendest. so ohne beispiel halte ich deine aussage für nicht so glaubwürdig.

    0
  • D

    Danke erstmal für die ganazen Antworten.

    volkard schrieb:

    Ich komme zwar meistens selber nicht auf 80 Zeichen, aber ein längeres if-Konstrukt o. ä. überschreitet das dann doch manchmal - es aufzutrennen wirkt unschön.

    glaub ich net.

    Dass das if-Konstrukt so lang wird oder dass es unschön wirkt es aufzutrennen?

    Aus meinem aktuellen Übungsprojeket:

    if ((Value > BestMoveValue) || ((Value == BestMoveValue) && (rand() > RAND_MAX / 2)))
        {
            BestMove = i;
            BestMoveValue = Value;
        }

    Natürlich kann man das jetzt vor/nach dem OR sinnvoll auftrennen, aber IMHO sieht es dann irgendwie hässlich aus. Ich habe meinen Editor jetzt auf 120 Zeichen umgestellt, da passt das dann auch mit Einrückung - außerdem ist für die Kommentare mehr platz ;-).

    Vielleicht ist es auch eine von diesen Wenn-man-Probleme-damit-hat-sollte-man-seinen-Code-überdenken-Sachen, von denen ich hier in der kurzen Zeit schon ein paar gesehen habe...

    EDIT: *Hand-vor-den-Kopf-Schlag* Jetzt habe ich doch tatsächlich die komplette zweite Seite des Threads übersehen...

    0
  • ?

    volkart du hast ja end die scheiss variablen namen.

    0
  • B

    was spricht dagegen auch während einer if-anweisung zeilenumbrüche zu machen?

    if(field[x+drc[i][0]*distance][y+drc[i][1]*distance] == BISHOP ||
   field[x+drc[i][0]*distance][y+drc[i][1]*distance] == QUEEN)
  return true;

    da seh ich keine möglichkeit es zu verkürzen.
    oder nehmen wir:

    if(!isThreatened(4, 0, whiteMove) &&
   !isThreatened(5, 0, whiteMove) &&
   !isThreatened(6, 0, whiteMove))

    gut da könnt ich vielleicht noch eine zusätzliche funktion schreiben

    bool checkCastling(bool whiteMove)
{
  return (!isThreatened(4, 0, whiteMove) &&
          !isThreatened(5, 0, whiteMove) &&
          !isThreatened(6, 0, whiteMove));
}

//und dann
if(checkCastling(whiteMove))

    aber ist das denn sinnvoll? ich brauchs nur einmal.

    wichtig ist nur das man nicht horizontal scrollen muss. und damit andere die den code lesen auch nicht horizontal scrollen müssen sollte man sich imo an die 80 zeichen halten.

    0
  • ?

    Ja, ist auch sinnvoll, wenn du es nur einmal brauchst. Zeilenumbrüche mach ich auch manchmal in nem if. Aber wenns zu wild wird, dann lieber ne Funktion.

    da seh ich keine möglichkeit es zu verkürzen.

    In diesem Fall sollte man IMHO den Wert von field[x+drc[i][0]*distance][y+drc[i][1]*distance] cachen. Wenn ich das if lese interessiert mich nicht, welches Feld ich da betrachte, sondern mich interessiert, dass hier auf Bishop und Queen getestet wird.

    0
  • V
     

    if((Value>BestMoveValue)||((Value==BestMoveValue)&&(rand()>RAND_MAX/2))){
	BestMove = i;
	BestMoveValue = Value;
}

//mal alternativen überlegen

for(;;){
	if(Value<BestMoveValue)
		break;
	if(Value==BestMoveValue)&&(rand()>RAND_MAX/2)
		break;
	BestMove = i;
	BestMoveValue = Value;
	break;
}

//nee, sindt nicht ideal aus. 

inline bool fiftyFifty(){
	return rand()%2;
}

if((Value>BestMoveValue)||((Value==BestMoveValue)&&fiftyFifty())){
	BestMove = i;
	BestMoveValue = Value;
}

//besser. 

if(Value+VIEL*fiftyFifty()>bestMoveValue){
	BestMove = i;
	BestMoveValue = Value;
}

//versteht das noch einer?

if(Value+(rand()&1024)>bestMoveValue){
	BestMove = i;
	BestMoveValue = Value;
}

//langsamer und unverständlicher als die erste version. 
//langsamer, weil rand() immer aufgerufen wird.

//also nochmal eine von oben kopieren

inline bool better(int MoveA,int MoveB){
	if(MoveA>MoveB) return true;
	if(MobeA<MoveB) return false;
	return fiftyFifty();
}

if(better(Value,BestMoveValue)){
	BestMove = i;
	BestMoveValue = Value;
}

//sehe keinenb guten trick. und vermutlich auch keinen, wenn ich die ganze 
//schleife sehen dürfte.
    0
Anmelden zum Antworten