int main()
{
    return 0;
}

3 frei

int main()
{
   return 0;
}

bool f(){
	return true;
}
int main(){
	if(f()){
		std::cout << "Hello World!" << std::endl;
	}
	return 0;
}

Und ich weiss nicht wieso,aber sowas:

int main()
{
	return 0;
}

finde ich ziemlich hässlig.

void TestFunktion ( int i, int j )
{
    TestFunktion ( i, j );
}

- Tab mit 4 Zeichen
- immer Extrazeile für geschweifte Klammern
- links und rechts ein Leerzeichen bei runden Klammern

- Tab mit 4 Zeichen
- immer Extrazeile für geschweifte Klammern
- links und rechts ein Leerzeichen bei runden Klammern

void TestFunktion ( int i, int j )
{
    TestFunktion ( i, j );
}

dito.

mfg,
julian

das rockt viel mehr ;P

bb

so is besser

void DoThis(int& x, float y)
{
    // .......
}

int main()
{
    int i;
    if (Condition)
        DoThis(i, 3.2f);
    else
        DoThat();
}

Bei den geschweiften Klammern finde ich die zeilenverschwendende Variante übersichtlicher und schöner.

Was die runden Klammern angeht, habe ich bisher keinen optimalen Stil gefunden.
Da gibt es:

if(!(x>0)){...
if( !(x>0) ){...
if (!(x>0)) {...
if ( !( x>0 ) ) {...

Keines gefällt mir richtig.

immer eins ausßer bei klammern

Zudem schreib ich meistens bei Funktionsdefinitionen (auch von Methoden) vorher eine Zeile Kommentar, die beschreibt, was die Funktion macht. Das sieht man dann schön im IntelliSense.

Bei Klassen rücke ich die Zugriffsspezifizierer auch ein, weil ich das übersichtlicher finde, und "zugriffsneutrale" Anweisungen wie Friend-Deklarationen auf der gleichen Zeile schreiben kann. Oft trenne ich Variablen und Methoden noch zusätzlich durch eine Zeile, bei vielen Methoden trenne ich diese auch nach Aufgabenbereichen.

bool TestExpr(bool Expression);

// Klasse für Demonstrationszwecke
class MyClass
{
    // Friend-Deklarationen
    friend bool TestExpr(bool Expr1, bool Expr2, bool Expr3);

    public:
        // Öffentliche Funktionen
        void DoThis(int& x, float y);

        // Statische Konstanten
        static const float Value;
        enum Type
        {
            T1,  // so ein Typ
            T2,  // ein anderer Typ
            T3   // ein ganz spezieller Typ
        };

    private:
        // Private Member
        int Var;
        double AnotherVar;

        // Private Methoden
        void DoSomethingInternally();
        bool VerySecretMethod();
};

// -- Hier beginnt normalerweise die CPP-Datei --

// Definition statische Variablen
const float MyClass::Value = 245.42f;

// Weist x den Member Var zu und macht mit y eine sinnlose Berechnung.
void MyClass::DoThis(int& x, float y)
{
    x = Var;
    static_cast<int>(x + 27*y)/x - 40;
}

// Überprüft die drei Bedingungen und gibt einen entsprechenden boolschen Ausdruck zurück.
bool TestExpr(bool Expr1, bool Expr2, bool Expr3)
{
    return (Expr1 || !(Expr2 && !Expr1) || (Expr3 != Expr1)) && Expr3;
    // ich weiss, das ist nicht logisch, es geht ja nur um die Darstellung.
    // Klammern setzte ich zur besseren Übersichtlichkeit, obwohl einige überflüssig sind.
}

int main()
{
    int Number;

    bool x = true;
    bool y = false;
    bool z = true;

    MyClass A;

    // Überprüft das Verhältnis von x, y, z und bearbeitet A dementsprechend.
    if (TestExpr(x, y, z))
    {
        A.DoThis(Number, 3.2f);
    }
    else
    {
        A.DoThis(Number, 4.6f);
        A.DoThat();
    }
}

int foo() {
  return 100;
}

P.S. Wer das anders macht ist vom Teufel besessen!

P.S. Wer das anders macht ist vom Teufel besessen!

wenn dem so ist, bin ich äusserst gerne vom teufel besessen

Meine geschweiften Klammern setze ich direkt hinter die Funktion/Klassendeklaration.

bool f(){
	return true;
}
int main(){
	if(f()){
		std::cout << "Hello World!" << std::endl;
	}
	return 0;
}

BRRRRRR GRRRRRR SDFJASDÖKLFJAÖSKLDF!
Boa ist das hässlich
Ehrlich, dann doch gleich so:

bool f(){
	return true; }
int main(){
	if(f()){
		std::cout << "Hello World!" << std::endl; }
	return 0; }

Noch unübersichtlicher! Juhu!
Jaja, so unterschiedlich sind wir
MfG

Ausnahme: Bei sehr kurzen Funktionen (evtl. inline) kann es legitim sein, obwoh ich das selber eigentlich nicht mache:

int Function() { return 21452; }

Was ich aber wirklich hässlich finde, ist das (einschliesslich den fehlenden Abständen bei Operationen):

int Function()
    {
    int x=2242;
    x*=2
    return x;
    }

#include <iostream>

bool foo() { return true; };

int main(int, char*)
{
  // Zwei Leerzeichen!

  if(foo())
  { std::cout << "hello" << std::endl; }

  return 0;
}

In der IDE:

#include <iostream>

bool foo() { return true; };

int main(int, char*)
{
    // Tabulator (welcher ich im Forum nicht darstellen kann ^^)

    if(foo())
    { std::cout << "Hello" << std::endl; }

    return 0;
}

In Java:

public class CMainClass {

    // Tabulator (welcher ich im Forum nicht darstellen kann ...)

    public static boolean foo() { return true; };

    public static void main(String[] Arguments) {

        if(foo())
        { System.println("Hello"); }
    }
}

Und ja, ich bin vom Teufel bessesen. Schaut ruhig in mein Profil:
Interessen: Computer, Programmierung, Drachen, Mystisches, Rollenspiel

Grüssli

bool foo() { return true; };

Wieso eigentlich das Semikolon am Schluss?

Deinen Stil finde ich übrigens gerade noch akzeptabel (obwohl ich es selber lieber übersichtlicher, sprich { und } auf eigenen Zeilen, habe, siehe oben)

Aber wieso schreiben eigentlich soviele return 0; und die main() -Parameter auf, wenn man sie gar nicht benötigt?