Also, nach einigem Stöbern und Suchenbin ich darauf gestoßen, dass man ein Array aus Referenzen auf eine Klasse so lösen kann:

CNeuron  (&inputs)[];

soweit so gut, dachte ich.... Jedoch: Mein Compiler frisst das nicht!
egal ob ich jetzt noch eine Größenangabe mache (z.b.

CNeuron  (&inputs)[20];

)

In einem anderen Thread wurde dies jedoch als Lösung angeführt.
Ich benutze Dev-C++ 4.9.7.0

Bitte helft mir, das ist ein dringendes Problem.
Ich möchte nämlich auch ein Konstrukt aus Zeiger auf Zeiger möglichst vermeiden. Das mit dem Array auf Referenzen schien mir eine sehr elegante Lösung zu sein, aber wenns mein Compiler nicht annimmt...

Oder:

Wisst Ihr vielleicht eine andere Lösung? Wie kann ich ein Array aus Referenzen basteln, und zwar Referenzen auf diese besagte CNeuron-Klasse

Danke für Eure Hilfe,

lernwilliger hiroki-kun

Das mit dem Array auf Referenzen schien mir eine sehr elegante Lösung zu sein, aber wenns mein Compiler nicht annimmt...

Standard-C++ erlaubt keine Arrays die Referenzen enthalten.

CNeuron (&inputs)[20];

Das ist kein Array von Referenzen sondern eine Referenz namens inputs auf ein Array von 20 CNeuron-Objekten.

Das dein Compiler das nicht frisst, liegt daran, dass du die Referenz nicht initialisierst.

CNeuron** inputs;

Hm, nun ja. eigentlich wollte ich dies ja vermeiden. Ich hab ja auch schon folgendes probiert:

CNeuron& inputs[];

Aber wie kann ich diese Variablen initialisieren??
Weil: Zum Zeitpunkt der deklaration habe ich noch nicht die werte, mit denen die initialisiert werden sollen... ach was: ich poste einfach den kompletten code, dann kann man mr vielleicht etwas besser weiterhelfen.. ach ja: es sind wohl laut meines compilers noch mehr fehler im code, aber ich möchte erst wissen wie ich dieses problem hier löse, denn sonst löse ich die anderen probleme, und darf dann nochmal von vorn alles abändern, weilsich das kontrukt (datentyp) geändert hat...

/*
 * 
 * Projekt     :  *** NEURONALE NETZE ***
 * 
 */

#include <stdlib.h>  // wegen: NULL
#include <vector>    // vielleicht vector<> statt ARRAYs

#ifndef __CNEURON_H
#define __CNEURON_H

// Datentyp, mit dem man angibt, welche Aktivierungsfunktion man wählt
typedef enum { linear = 1, quadr, cubic, cut, signum, sigmoid, gauss } TFunctions;
// Datentyp, mit dem man angibt, wie die Gewichtung festgelegt werden soll
typedef enum { standard = 1, constant, randomized } TOmegas;

// Klasse CNeuron
// - Die Klasse CNeuralNet benutzt CNeuron.
class CNeuron
{
    private:
    //
    double   output;          // Ausgang des Neurons
    double   omegas[];        // Gewichtungen der Eingaenge
    CNeuron  &inputs[];     // Array aus Zeigern auf die Outputs der Vorgaenger-Neuronen
    unsigned long numinputs;  // Anzahl der Eingaenge / Vorgaenger-Neuronen
    double   limit;           // Schwellwert
    double   (*f) ( double ); // Zeiger auf die Aktivierungsfunktion

    // Aktivierungsfunktionen
    double f_linear( double z ) { return z; }
    double f_quadr ( double z ) { return z*z; }
    double f_cubic ( double z ) { return z*z*z; }
    double f_cut   ( double z ) { return ( z >= limit ? 1.0 : 0.0 ); }

    public:
    // Konstruktoren
    // Standardkonstruktor ohne Parameter
    CNeuron()
    {
        output = 0.0;  // Output wird auf 0 gesetzt
        limit  = 0.5;  // Die Schwelle wird auf 1/2 festgesetzt als Standard
        inputs = NULL; // Mit keinen Eingaengen/Vorgaengern verknuepfen
        omegas = NULL; // Keine Gewichtungen festlegen
        numinputs = 0; // da keine Vorgaenger festgelegt sind, wird deren Anzahl auf 0 gesetzt
        f = f_linear;  // Standard-Aktivierungsfunktion ist linear
    }
    // Konstruktor, mit ganz vielen Parametern
    CNeuron( CNeuron (&in)[], double w[] = NULL, TFunctions func = linear, double sig = 0.5 )
    {
        // Zuerst wird der Standard-Konstruktor aufgerufen
        CNeuron();
        // Hier wird das Neuronen mit seinen Eingaengen/Vorgaengern verknuepft
        if( in != NULL )
        {
            // Anzahl der Eingaenge/Vorgaenger wird bestimmt und gespeichert
            numinputs = sizeof(in) / sizeof(in[0]);
            // Falls eine Gewichtung angegeben ist ...
            if( w != NULL )
                for( register unsigned long i = 0; i < numinputs; i++ )
                {
                     this->inputs[ i ] = in[ i ];
                     this->omegas[ i ] = w [ i ];
                }
            // Falls keine Gewichtung angegeben ist ...
            else
            {
                for( register unsigned long i = 0; i < numinputs; i++ )
                     this->inputs[ i ] = in[ i ];
                ;
            }
        }
        this->f     = func; // Legt die gewaehlte Aktivierungsfunktion fest
        this->limit = sig ; // Legt SIGMA fest ~ ~ ~
    }
    // Destruktor
    ~CNeuron()
    {
        delete[] inputs;
        /*
         * Löscht alle Vorgaenger-Neuronen. 
         * Dies wiederum bewirkt, dass diese Neuronen ihre Vorgaenger löschen, usw.
         * Ergibt eine "Kettenreaktion" von hinten nach vorne.
         * Evtl. Problem: Bereitsgelöschte Neuronen sollen nochmal gelösct werden ?
         */
    }

    // -----------------------------------------------------
    // ******************** FUNKTIONEN *********************
    // -----------------------------------------------------

    // Einstellungen

    void setInputs( CNeuron (&in)[] )
    {

    }

    void setOmegas( int om = 1, double w = 1.0 )
    {
         switch( om )
         {
           case standard   :     if( omegas != NULL )   delete[] omegas;
                                 omegas = new double[ numinputs ];
                                 w = 1.0 / numinputs;
                                 for( register unsigned long i = 0; i < numinputs; i++ )
                                 {
                                      omegas[ i ] = w;
                                 }
                                 break;
           case constant   :     if( omegas != NULL )   delete[] omegas;
                                 omegas = new double[ numinputs ];
                                 for( register unsigned long i = 0; i < numinputs; i++ )
                                 {
                                      omegas[ i ] = w;
                                 }
                                 break;
           case randomized :     if( omegas != NULL )   delete[] omegas;
                                 omegas = new double[ numinputs ];
                                 for( register unsigned long i = 0; i < numinputs; i++ )
                                 {
                                      omegas[ i ] = rand();
                                 }
                                 break;

           default:
         }
    }

    // Berechnungen

    double evaluate()
    {
        double sum = 0.0;
        for( register unsigned long i = 0; i < numinputs; i++ )
             sum += omegas[i] * inputs[i];
        return ( output = f( sum ) );
    }

};

#endif

danke nochmals,

immernoch neugieriger und lernwilliger hiroki-kun

vector< CNeuron& > inputs;

ginge das so?? is das richtig?

hiroki

mit referenzen geht nicht, weil du die ja nicht sofort initialisieren kannst und es keine null-referenzen gibt

is doch nur eine zeile quellcode!

danke

das geht so nicht nicht statische Methode mit Algorithmus verbinden Zeiger auf Member-Funktionen (es geht doch !)