ich habe mal wieder ein Frage und weiß dabei nicht wirklich weiter:

Und zwar habe ich sortier-Funktionen, die verschiedene Arrays sorteren sollen.
Es handelt sich um überlandene Funktionen die einmal ein int, double und char Array sortieren sollen.

Die Sortierfunktionen die nur sortieren sollen, sollen im Namensraum sortieren liegen, die Funktionen die noch einen bool Parameter mit übergeben, sollen im Namensraum sortieren_und_rechnen liegen.
Sortieren und Rechnen soll noch weiter Berechnungen durchführen bei int die Summe, bei bool das Produkt und bei char die ASCII Summe.

Jetzt möchte ich wissen, wie ich beim Aufruf der Funktion prüfen kann, ob ich die Funktionen aus dem Namensraum sortieren nutzen soll oder aus dem Namensraum sortieren_und_rechnen.

Je nach dem ob ein bool Parameter mitgeliefert wird oder nicht, standardmäßig soll der bool Parameter den default Wert false zugewiesen bekommen. Wo gebe ich den default Wert an?

Hier mal das Programm mit den Funktionen für den Namensraum sortieren:

#include <iostream>
using namespace std;

namespace sortieren {
          void sort (int x[], int y);
          void sort (double x[],int y,bool);
          void sort (char x[],int y, bool);
          }

/*namespace sortieren_und_rechnen {
          void sort (int x[], int y);
          void sort (double x[],int y,bool);
          void sort (char x[],int y,bool);
          } 
*/

int main() {

     int  a[] = {5,2,3,1,4};
     double b[] = {0.4, 0.5, 0.3, 0.2, 0.1};
     char c[] = {'x','b','a','r','t'};

     cout << "Datentyp int:" << endl;
     cout << "Original: " << a[0] <<" " <<a[1] << " " <<a[2] <<" " <<a[3] <<" " <<a[4] << endl;
     sortieren::sort (a,5);
     cout << "Original: " << a[0] <<" " <<a[1] << " " <<a[2] <<" " <<a[3] <<" " <<a[4] << endl;

     cout << "\n" << "Datentyp double: " <<endl;
     cout << "Original: " << b[0] <<" " <<b[1] << " " <<b[2] <<" " <<b[3] <<" " <<b[4] << endl;
     sortieren::sort (b,5, true);
     cout << "Sortiert: " << b[0] <<" " <<b[1] << " " <<b[2] <<" " <<b[3] <<" " <<b[4] << endl;

     cout << "\n" << "Datentype char: " <<endl;
     cout << "Original: " << c[0] <<" " <<c[1] << " " <<c[2] <<" " <<c[3] <<" " <<c[4] << endl;
     sortieren::sort (c,5, true);
     cout << "Sortiert: " << c[0] <<" " <<c[1] << " " <<c[2] <<" " <<c[3] <<" " <<c[4] << endl;

     return 0;
     }

namespace sortieren {
    void sort(int num[], int end) {
      int i,j,akt,start=0;

      for(j=start ; j<=end ; j++) {
        akt = num[j];
        i = j-1;
        while(i>=start && num[i]>akt) {
          num[i+1] = num[i];
          i--;
        }
        num[i+1] = akt;
      }
    }

    void sort(double num[], int end, bool) {
      int i,j,start=0;
      double akt;

      for(j=start ; j<=end ; j++) {
        akt = num[j];
        i = j-1;
        while(i>=start && num[i]>akt) {
          num[i+1] = num[i];
          i--;
        }
        num[i+1] = akt;
      }
    }

    void sort(char num[], int end, bool) {
      int i,j,start=0;
      char akt;

      for(j=start ; j<=end-1 ; j++) {
        akt = num[j];
        i = j-1;
        while(i>=start && num[i]>akt) {
          num[i+1] = num[i];
          i--;
        }
        num[i+1] = akt;
      }
    }
}

Die Sortierfunktionen die nur sortieren sollen, sollen im Namensraum sortieren liegen, die Funktionen die noch einen bool Parameter mit übergeben, sollen im Namensraum sortieren_und_rechnen liegen.

Dann musst du das so deklarieren. Das muss so aber nicht sein - ein zusätzlicher Parameter verändert schließlich die Signatur, also kannst du doch auch überladen. (Ich weiß aber nicht was du willst)

Jetzt möchte ich wissen, wie ich beim Aufruf der Funktion prüfen kann, ob ich die Funktionen aus dem Namensraum sortieren nutzen soll oder aus dem Namensraum sortieren_und_rechnen.

Wie wäre es mit einem if-Statement? Anders geht es mit gegebenem Code nicht: Overload-Resolution gibt es nicht.* Machst du alle Namespace-Member mit einer using-Direktive bekannt, haben sie die gleichen Signaturen. (Also die jeweiligen Paare, natürlich nicht die Funktionen in einem Namespace)

Irgendwie verstehe ich aber immer noch nicht was genau du willst. Zeig mal Beispielcode, wie du es im Endeffekt haben möchtest.

*~Wenn die Bedingungen zur Compile-Zeit bekannt sind, könntest du auch Overload-Resolution mit dem Int2Type-Idiom probieren. Mit einem zusätzlichen Parameter: entweder std::false_type oder std::true_type.~

Überladen wäre auch meine Idee gewesen, soll aber an der Stelle nicht verwendet werden. Die Funktionen sollen ja in verschiedenen Namensräumen liegen, oder geht das auch mit verschiedenen Namensräumen?

Wenn ich jetzt z.B. einen Funktionsaufruf mache mit:
sort (a,5) dann soll er die Funktion im Namensraum sortieren aufrufen, ist der Funktionsaufruf aber sort(a,5,true) soll er die Funktion im Namensraum sortieren_und_rechnen aufrufen.

Defaultmäßig soll die bool Abfrage immer auf false stehen wenn dort kein Parameter gesetzt wurde.

sort (a,5) dann soll er die Funktion im Namensraum sortieren aufrufen, ist der Funktionsaufruf aber sort(a,5,true) soll er die Funktion im Namensraum sortieren_und_rechnen aufrufen.

Dann mach eine globale Funktion sort, die dann - je nach bool-Parameter - entsprechend delegiert. Wenn die Bedingungen zur Compile-Zeit bekannt sind, nimm Template-Parameter und spezialisiere diese Funktion.

// Die Elipse ist Pseudo-Code!!
void sort( ..., bool b = false )
{
    if( b )
        sortieren_und_rechnen::sort(...);
    else
        sortieren::sort(...);
}

#include <iostream>

namespace sortieren_und_rechnen
{
  void sort(double[], int)
  {
    std::cout << "Sortieren und rechnen: double\n";
  }
  void sort(char[], int)
  {
    std::cout << "Sortieren und rechnen: char\n";
  }
  void sort(int[], int)
  {
    std::cout << "Sortieren und rechnen: int\n";
  }
}

namespace sortieren_ohne_rechnen
{
  void sort(double[], int)
  {
    std::cout << "Sortieren: double\n";
  }
  void sort(char[], int)
  {
    std::cout << "Sortieren: char\n";
  }
  void sort(int[], int)
  {
    std::cout << "Sortieren: int\n";
  }
}

namespace sortieren
{
  template <typename T> void sort(T t[], int y, bool b = false)
  {
    if (b)
      sortieren_und_rechnen::sort(t,y);
    else
      sortieren_ohne_rechnen::sort(t,y);
  }
}

int main()
{
  char c[3];
  double d[3];
  int i[3];

  sortieren::sort(c,3);
  sortieren::sort(d,3);
  sortieren::sort(i,3);
  sortieren::sort(c,3,true);
  sortieren::sort(d,3,true);
  sortieren::sort(i,3,true);
}

Aber: Die tausendmal bessere Variante:
Eine Funktion:

template<typename iterator> void sort(iterator begin, iterator end, bool b);

Oder vermutlich was du eigentlich möchtest:

#include<algorithm>
#include<numeric>

für
http://www.cplusplus.com/reference/algorithm/sort/
und
http://www.cplusplus.com/reference/numeric/accumulate/

Beachte, wie diese Funktionen eine Signatur haben, wie ich sie dir empfohlen habe (also mit Iterator und Template). Das ist einfach besser. Keine Nachteile, dafür universeller einsetzbar.

Ich habe es mal mit einem Template versucht, allerdings bekomme ich dann einen Compilerfehler. Nur ist mir nicht wirklich klar warum.

Eigentlich müsste die Funktion doch für die Typen ausgeprägt sein.

#include <iostream>
using namespace std;

//Funktionsprototype sortieren
namespace sortieren {
          void sort (int x[], int y);
          void sort (double x[],int y,bool);
          void sort (char x[],int y, bool);
          }

//Funktionsprototype sortieren_und_rechnen
namespace sortieren_und_rechnen {
          void sort (int x[], int y);
          void sort (double x[],int y);
          void sort (char x[],int y);
          } 

template <typename T> void sort(T x[], int y, bool b = false) 
  { 
    if (b) 
      sortieren_und_rechnen::sort(x,y); 
    else 
      sortieren::sort(x,y); 
  }

int main() {

     int  a[] = {5,2,3,1,4};
     double b[] = {0.4, 0.5, 0.3, 0.2, 0.1};
     char c[] = {'x','b','a','r','t'};

     cout << "Datentyp int:" << endl;
     cout << "Original: " << a[0] <<" " <<a[1] << " " <<a[2] <<" " <<a[3] <<" " <<a[4] << endl;
     sort (a,5);
     cout << "Sortiert: " << a[0] <<" " <<a[1] << " " <<a[2] <<" " <<a[3] <<" " <<a[4] << endl;

     cout << "\n" << "Datentyp double: " <<endl;
     cout << "Original: " << b[0] <<" " <<b[1] << " " <<b[2] <<" " <<b[3] <<" " <<b[4] << endl;
     sort (b,5, true);
     cout << "Sortiert: " << b[0] <<" " <<b[1] << " " <<b[2] <<" " <<b[3] <<" " <<b[4] << endl;

     cout << "\n" << "Datentype char: " <<endl;
     cout << "Original: " << c[0] <<" " <<c[1] << " " <<c[2] <<" " <<c[3] <<" " <<c[4] << endl;
     sort (c,5, true);
     cout << "Sortiert: " << c[0] <<" " <<c[1] << " " <<c[2] <<" " <<c[3] <<" " <<c[4] << endl;

     return 0;
     }

namespace sortieren {
    void sort(int num[], int end) {
      int i,j,akt,start=0;

      for(j=start ; j<=end ; j++) {
        akt = num[j];
        i = j-1;
        while(i>=start && num[i]>akt) {
          num[i+1] = num[i];
          i--;
        }
        num[i+1] = akt;
      }
    }

    void sort(double num[], int end) {
      int i,j,start=0;
      double akt;

      for(j=start ; j<=end ; j++) {
        akt = num[j];
        i = j-1;
        while(i>=start && num[i]>akt) {
          num[i+1] = num[i];
          i--;
        }
        num[i+1] = akt;
      }
    }

    void sort(char num[], int end) {
      int i,j,start=0;
      char akt;

      for(j=start ; j<=end-1 ; j++) {
        akt = num[j];
        i = j-1;
        while(i>=start && num[i]>akt) {
          num[i+1] = num[i];
          i--;
        }
        num[i+1] = akt;
      }
    }
}

namespace sortieren_und_rechnen {
    void sort(int num[], int end) {
      int i,j,akt,start=0;

      for(j=start ; j<=end ; j++) {
        akt = num[j];
        i = j-1;
        while(i>=start && num[i]>akt) {
          num[i+1] = num[i];
          i--;
        }
        num[i+1] = akt;
      }
    }

    void sort(double num[], int end, bool) {
      int i,j,start=0;
      double akt;

      for(j=start ; j<=end ; j++) {
        akt = num[j];
        i = j-1;
        while(i>=start && num[i]>akt) {
          num[i+1] = num[i];
          i--;
        }
        num[i+1] = akt;
      }
    }

    void sort(char num[], int end, bool) {
      int i,j,start=0;
      char akt;

      for(j=start ; j<=end-1 ; j++) {
        akt = num[j];
        i = j-1;
        while(i>=start && num[i]>akt) {
          num[i+1] = num[i];
          i--;
        }
        num[i+1] = akt;
      }
    }
}

Also die Bibliotheken kann ich leider nicht einbinden, bzw. darf ich net.

Und das hier?

#include <iostream>

Im Grunde genommen geht es hier um die Namensräume und den Zugriff darauf sowie die Überladung von Funktionen.

Ok, das ist ein guter Grund.

Ich habe es mal mit einem Template versucht, allerdings bekomme ich dann einen Compilerfehler. Nur ist mir nicht wirklich klar warum.

Welchen? Beschreib deine Probleme immer genau.

Die folgenden beiden Funktionen haben einen bool in der Signatur, die anderen vier nicht. Das ist das Problem.

namespace sortieren {
          void sort (double x[],int y,bool);
          void sort (char x[],int y, bool);
          }

Weiterhin passen einige deiner Funktionsdefinitionen nicht zu den Prototypen, andere fehlen ganz, andere sind im falschen Namensraum. Nochmal alles gründlich durchgehen und konsistent halten!

Danke nochmals.

#include <iostream>
using namespace std;

//Funktionsprototype sortieren
namespace sortieren {
          void sort (int x[], int y);
          void sort (double x[],int y);
          void sort (char x[],int y);
          }

//Funktionsprototype sortieren_und_rechnen
namespace sortieren_und_rechnen {
          void sort (int x[], int y);
          void sort (double x[],int y);
          void sort (char x[],int y);
          } 

template <typename T> void sort(T x[], int y, bool b = false) 
  { 
    if (b) 
      sortieren_und_rechnen::sort(x,y); 
    else 
      sortieren::sort(x,y); 
  }

int main() {

     int  a[] = {5,2,3,1,4};
     double b[] = {0.4, 0.5, 0.3, 0.2, 0.1};
     char c[] = {'x','b','a','r','t'};

     cout << "Datentyp int:" << endl;
     cout << "Original: " << a[0] <<" " <<a[1] << " " <<a[2] <<" " <<a[3] <<" " <<a[4] << endl;
     sort (a,5);

     cout << "\n" << "Datentyp double: " <<endl;
     cout << "Original: " << b[0] <<" " <<b[1] << " " <<b[2] <<" " <<b[3] <<" " <<b[4] << endl;
     sort (b,5, true);

     cout << "\n" << "Datentype char: " <<endl;
     cout << "Original: " << c[0] <<" " <<c[1] << " " <<c[2] <<" " <<c[3] <<" " <<c[4] << endl;
     sort (c,5, true);

     return 0;
     }

namespace sortieren {
    void sort(int num[], int end) {
      int i,j,akt,start=0;

      for(j=start ; j<=end ; j++) {
        akt = num[j];
        i = j-1;
        while(i>=start && num[i]>akt) {
          num[i+1] = num[i];
          i--;
        }
        num[i+1] = akt;
      }
      cout << "Sortiert: " << num[0] <<" " <<num[1] << " " <<num[2] <<" " <<num[3] <<" " <<num[4] << endl;
    }

    void sort(double num[], int end) {
      int i,j,start=0;
      double akt;

      for(j=start ; j<=end ; j++) {
        akt = num[j];
        i = j-1;
        while(i>=start && num[i]>akt) {
          num[i+1] = num[i];
          i--;
        }
        num[i+1] = akt;
      }
      cout << "Sortiert: " << num[0] <<" " <<num[1] << " " <<num[2] <<" " <<num[3] <<" " <<num[4] << endl;
    }

    void sort(char num[], int end) {
      int i,j,start=0;
      char akt;

      for(j=start ; j<=end-1 ; j++) {
        akt = num[j];
        i = j-1;
        while(i>=start && num[i]>akt) {
          num[i+1] = num[i];
          i--;
        }
        num[i+1] = akt;
      }
      cout << "Sortiert: " << num[0] <<" " <<num[1] << " " <<num[2] <<" " <<num[3] <<" " <<num[4] << endl;
    }
}

namespace sortieren_und_rechnen {
    void sort(int num[], int end) {
      int i,j,akt,start=0,summe=0;

      for(j=start ; j<=end ; j++) {
        akt = num[j];
        i = j-1;
        while(i>=start && num[i]>akt) {
          num[i+1] = num[i];
          i--;
        }
        num[i+1] = akt;
      }
      cout << "Sortiert: " << num[0] <<" " <<num[1] << " " <<num[2] <<" " <<num[3] <<" " <<num[4] << endl;
      summe = num[0] + num[1] + num[2] + num[3] + num[4];
      cout << "Summe: " << summe << endl;

    }

    void sort(double num[], int end) {
      int i,j,start=0;
      double akt, produkt=0;

      for(j=start ; j<=end ; j++) {
        akt = num[j];
        i = j-1;
        while(i>=start && num[i]>akt) {
          num[i+1] = num[i];
          i--;
        }
        num[i+1] = akt;
      }
      cout << "Sortiert: " << num[0] <<" " <<num[1] << " " <<num[2] <<" " <<num[3] <<" " <<num[4] << endl;
      produkt = num[0] * num[1] * num[2] * num[3] * num[4];
      cout << "Produkt: " << produkt << endl;
    }

    void sort(char num[], int end) {
      int i,j,start=0,summe=0;
      char akt;

      for(j=start ; j<=end-1 ; j++) {
        akt = num[j];
        i = j-1;
        while(i>=start && num[i]>akt) {
          num[i+1] = num[i];
          i--;
        }
        num[i+1] = akt;
      }
      cout << "Sortiert: " << num[0] <<" " <<num[1] << " " <<num[2] <<" " <<num[3] <<" " <<num[4] << endl;
      summe = num[0] + num[1] + num[2] + num[3] + num[4];
      cout << "Summe ASCII-Zeichen: " << summe << endl;
    }
}