Array aus Referenzen?

hiroki

also heißt das, wenn ich so ein konstrukt haben will, bei dem ich ein array abe, das eben z.b. 20 CNeuron-Objekte referenziert, müsste ich unbedingt Zeiger verwenden?
also:

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

mit'n vector

hiroki

also praktisch:

vector< CNeuron& > inputs;

ginge das so?? is das richtig?

hiroki

ne mit zeiger

vector< CNeuron* > inputs;

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

hiroki

na. dann sagt doch bitte mal wie...

is doch nur eine zeile quellcode!

danke

hiroki

aaah. ok danke!

Gerard

class CNeuron
{
private:
    double   (*f) ( double ); // Zeiger auf die Aktivierungsfunktion

    // Aktivierungsfunktionen
    double f_linear( double z ) { return z; }

public:
    CNeuron()
    {
        f = f_linear;  // Standard-Aktivierungsfunktion ist linear
    }

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

deine aktivierungsfunktionen sind keine und eine lösch-kettenreaktion gibts auch keine

Jockelx

Ob er wohl 7 Jahre auf diese Antwort gewartet hat

Fellhuhn

Na endlich kann ich weiterarbeiten... Puh...