Meine Frage, wofür nehme ich static Methoden?(mal ein einfaches praktisches Beispiel nennen, und wieso man das da macht)!

Weil ich sie ohne objekt aufrufen kann? oder welchen Sinn hat das?

Und warum macht man sowas?

class Base
{
 public:
 virtual void funktion()
 {
 cout<<"eine funktion"<<endl;
 }
};

class Member:public Base
{
 public:
 void funktion()
 {
 cout<<"Auch eine funktion<<endl;
 }
};

void Funktion(Base& b)
{
b.funktion();
}

aufruf im prog:

Base b;
Member m;
Funktion(b);
Funktion(m);

m.funktion();  //haben diese beiden Varianten einen unterschied?
b.funktion();  //ist es nicht egal ob Funktion(b) oder b.funktion??

so das sind meine fragen...vielleicht kanns mir einer erklären

zum zweiten: schau dir in einem geeigneten buch mal die seiten über polymorphie an. eines der wichtigsten dinge in der opjektorientierten programmierung.
du kannst auch in den obig rechts zu findenen tutorials nachschaun.
so long

ja, aber wofür static methoden? (die variablen sind mit klar)!

z.b. um objekte der eigenen klasse anzulegen. wird z.b. bei design patterns (factory, singleton, etc) verwendet. (in java macht man das so. in c++ wird's wohl ähnlich sein)
beispiel von da: http://www.javacoffeebreak.com/articles/designpatterns/

public class SingletonObject
{
    private SingletonObject()
    {
        // no code req'd
    }

    public static SingletonObject getSingletonObject()
    {
      if (ref == null)
          // it's ok, we can call this constructor
          ref = new SingletonObject();
      return ref;
    }

    private static SingletonObject ref;
}

Meine Frage, wofür nehme ich static Methoden?(mal ein einfaches praktisches Beispiel nennen, und wieso man das da macht)!

Einsatzgebiete für statische Methoden gibts viele. Einfach mal die Augen offen halten. Das Singleton Pattern wurde ja schon genannt, es gibt aber noch mehr.

Ne Sache, die mir spontan einfällt, sind zB Policies. Diese kann man verwenden, um das Verhalten einer Klasse zu steuern. Bsp:

struct policy_add
{
    static int make_it_so(int lhs, int rhs)
    {
        return lhs + rhs;
    }
};

template <class Policy>
class foo
{
private:
    int a_;
    int b_;
public:
    int calculate() const
    {
        return Policy::make_it_so(a_, b_);
    }
    foo(int a, int b)
        : a_(a)
        , b_(b)
    {
    }
};

//...
foo<policy_add> a(50, 20);
int ergebnis = a.calculate();
// ergebnis ist jetzt 70

Wenn jetzt jemand will, dass nicht addiert sondern subtrahiert wird, definiert man sich einfach 'ne neue Policy und benutzt diese.

struct policy_sub
{
    static int make_it_so(int lhs, int rhs)
    {
        return lhs - rhs;
    }
};

//...
foo<policy_sub> a(50, 20);
int ergebnis = a.calculate();
// ergebnis ist jetzt 30