Template – C / C++ – Fórum – Programujte.com

Ahoj, potřeboval bych zvládnout jednu obludu jménem Template, nevíte jak to vyřešit?

#pragma once

#include <stdio.h>
#include <stdlib.h>

//namespace Neuron_Class {
	template <class Data, class NEURON>	
	class VECTOROFNEURON
	{
	public:
		VECTOROFNEURON ();
		~VECTOROFNEURON ();
		bool GetNext ();
		NEURON *GetSynapse ();
		VECTOROFNEURON *GetNext (int num,int i);
		VECTOROFNEURON<Data,NEURON> *GetNext (NEURON *);
		VECTOROFNEURON *GetLast ();
		VECTOROFNEURON *GetThis ();
		VECTOROFNEURON *ConstructNext ();
		int GetIncrease (int);
	private:
		NEURON *NEURON;
		Data *data;
		VECTOROFNEURON *next;
	};

	class INPUTOFNEURON
	{
	public:
		INPUTOFNEURON ();
		~INPUTOFNEURON ();
	private:
		int *input;
		float *w;
	};
	class OUTPUTOFNEURON
	{
	public:
		OUTPUTOFNEURON ();
		~OUTPUTOFNEURON ();
	private:
	};

	class NEURON
	{
		public:
			NEURON ();
			~NEURON ();
			VECTOROFNEURON<INPUTOFNEURON, NEURON> *GetFirstInput ();
			VECTOROFNEURON<INPUTOFNEURON, NEURON> *GetInput (int);
			VECTOROFNEURON<INPUTOFNEURON, NEURON> *GetInput (NEURON *);
/*			VECTOROFNEURON<INPUTOFNEURON, NEURON> *GetLastInput ();
			int GetCountInput ();
			void ConstructInput ();
			void ConstructNewSynapse(NEURON &);
			void ConstructOutput ();*/
		private:
			int *output;
			float *p;
			VECTOROFNEURON<INPUTOFNEURON, NEURON> *thisInput;
			VECTOROFNEURON<OUTPUTOFNEURON, NEURON> *thisOutput;
	};
	
	NEURON::NEURON ()
	{
		output = new int;
		p = new float;
		*output = 0;
		*p = 0;
	};

	NEURON::~NEURON ()
	{
		delete output;
		delete p;
	};

	VECTOROFNEURON<INPUTOFNEURON, NEURON> *NEURON::GetFirstInput ()
	{
		if (thisInput)
			return this->thisInput;
		else
			return 0;
	};

	VECTOROFNEURON<INPUTOFNEURON, NEURON> *NEURON::GetInput (int num)
	{
		int i = 0;
		if (this->GetFirstInput ())
		{
			if (num == i)
			{
				return this->thisInput;
			}
			else
			{
				++i;
				return thisInput->GetNext (num, i);
			}
		}
		else
		{
			return 0;
		}
	};

	VECTOROFNEURON<INPUTOFNEURON, NEURON> *NEURON::GetInput (NEURON *rightSide)
	{
		if (this->GetFirstInput ())
		{
			if (rightSide == thisInput->GetSynapse ())
			{
				return this->thisInput;
			}
			else
			{
				return thisInput->GetNext (rightSide);
			}
		}
		else
		{
			return 0;
		}
	};

	/*
	
	int NEURON::GetCountInput ()
	{
		int i = 0;
		if (this->GetFirstInput ())
		{
			thisInput->GetIncreaseInput (i);
		}
		return i;
	};


	void NEURON::ConstructInput ()
	{
		if (this->GetFirstInput ())
		{
			thisInput->ConstructNextInput ();
		}
		else
		{
			thisInput = new INPUTOFNEURON;
		}
	};

/*	void NEURON::ConstructNewSynapse(NEURON *)
	{

	};*/

	template <class Data, class NEURON>
	VECTOROFNEURON<Data, NEURON>::VECTOROFNEURON ()
	{
		data = new data;
	};

	template <class Data, class NEURON>
	VECTOROFNEURON<Data, NEURON>::~VECTOROFNEURON ()
	{
		delete data;
	};

	template <class Data, class NEURON>
	bool VECTOROFNEURON<Data,NEURON>::GetNext ()
	{
		if (next)
			return true;
		else
			return false;
	};
	
	template <class Data, class NEURON>
	NEURON *GetSynapse ()
	{
		return this->NEURON;
	};

	template <class Data, class NEURON>
	VECTOROFNEURON<Data,NEURON> *VECTOROFNEURON<Data,NEURON>::GetNext(int num, int i)
	{
		if (next->GetNext ())
		{
			if (num = i)
			{
				return next;
			}
			else
			{
				++i;
				return this->GetNext (num, i);
			}
			return this;
		}
		else
		{
			return 0;
		}
	};

	template <class Data, class NEURON>
	VECTOROFNEURON<Data,NEURON> *VECTOROFNEURON<Data,NEURON>::GetNext (NEURON *rightSide)
	{
		
		/*if (rightSide)
		{
			return this;
		}
		else
		{
			if (this->GetNext ())
			{
				return next->GetNext (rightSide);
			}
			else
			{
				return 0;
			}
		}*/
	};

	
	template <class Data, class NEURON>
	VECTOROFNEURON<Data,NEURON> *VECTOROFNEURON<Data,NEURON>::GetLast ()
	{
		if (this->GetNext ())
		{
			return next->GetLast ();
		}
		else
		{
			return this;
		}
	};
	
	template <class Data, class NEURON>
	VECTOROFNEURON<Data,NEURON> *VECTOROFNEURON<Data,NEURON>::GetThis ()
	{
		return this;
	};

	template <class Data, class NEURON>
	VECTOROFNEURON<Data,NEURON> *VECTOROFNEURON<Data,NEURON>::ConstructNext ()
	{
		return this
	};
	
	template <class Data, class NEURON>
	int VECTOROFNEURON<Data,NEURON>::GetIncrease (int i)
	{
		i;
		if (this->GetNext ())
		{
			++i;
			next->GetIncrease (i);
		}
		return i;
	};

	INPUTOFNEURON::INPUTOFNEURON ()
	{
		input = new int;
		w = new float;
		*input = 0;
		*w = rand() % 100 + 0;
		*w = *w/100;
	};
	
	INPUTOFNEURON::~INPUTOFNEURON ()
	{
		delete input;
		delete w;
	};
//};

Nemyslím vyřešit tento program, chtěl bych vytvořit šablonu, do který bych mohl vložit typ už existující třídy.

já nějak nerozumim otázce... jak vložit typ už existující třídy? však ta třída VECTOROFNEURON už je šablona pro 2 typy, kam si můžeš vložit typ existující třídy

nechceš spíš napsat ukázku jak si to představuješ?

1>------ Rebuild All started: Project: Neural_Network, Configuration: Debug Win32 ------
1>  stdafx.cpp
1>c:\users\verewolf2\desktop\neural_network\neural_network\Neuron.h(206): error C2065: 'rightSide' : undeclared identifier
1>c:\users\verewolf2\desktop\neural_network\neural_network\Neuron.h(206): error C2597: illegal reference to non-static member 'VECTOROFNEURON<Data,NEURON>::NEURON'
1>c:\users\verewolf2\desktop\neural_network\neural_network\Neuron.h(206): error C3867: 'VECTOROFNEURON<Data,NEURON>::NEURON': function call missing argument list; use '&VECTOROFNEURON<Data,NEURON>::NEURON' to create a pointer to member
1>c:\users\verewolf2\desktop\neural_network\neural_network\Neuron.h(206): warning C4346: 'VECTOROFNEURON<Data,NEURON>::GetNext' : dependent name is not a type
1>          prefix with 'typename' to indicate a type
1>c:\users\verewolf2\desktop\neural_network\neural_network\Neuron.h(206): error C2350: 'VECTOROFNEURON<Data,NEURON>::GetNext' is not a static member
========== Rebuild All: 0 succeeded, 1 failed, 0 skipped ==========

No prostě to chci udělat tak, aby mě to neházelo chybu.

#5 MiCizek

Je tam 1 metoda ktoru si zabudol priradit do VECTOROFNEURONS, je tam jedno priradenie v podmienke if( x = y)  miesto if( x==y) a zopar premennych ktore maju rovnake nazvy ako typy.

Díky. Snad mám ty nejzávažnější chyby opraveny. Některých věcí jsem si nevšiml. Pokud se vám zdál jeden z předchozích příspěvků nejasných, tak s šablonama teprve začínám a ani jsem nevěděl, jak ten problém pojmenovat. Až budu mít zase čas budu pokračovat. :-)

#pragma once

#include <stdio.h>
#include <stdlib.h>

//namespace Neuron_Class {
	template <class Data, class Synapse>	
	class VECTOROFNEURON
	{
	public:
		VECTOROFNEURON ();
		~VECTOROFNEURON ();
		bool GetNext ();
		bool IsSynapse (Synapse *);
		int GetIncrease (int);
		Synapse *GetSynapse ();
		VECTOROFNEURON<Data,Synapse> *GetTo (int num,int i);
		VECTOROFNEURON<Data,Synapse> *GetTo (Synapse *);
		VECTOROFNEURON<Data,Synapse> *GetLast ();
		VECTOROFNEURON<Data,Synapse> *GetThis ();
		VECTOROFNEURON<Data,Synapse> *ConstructNext ();
		void SetSynapse (Synapse *);
	private:
		Synapse *synapse;
		Data *data;
		VECTOROFNEURON<Data,Synapse> *next;
	};

	class INPUTOFNEURON
	{
	public:
		INPUTOFNEURON ();
		~INPUTOFNEURON ();
	private:
		int *input;
		float *w;
	};
	class OUTPUTOFNEURON
	{
	public:
		OUTPUTOFNEURON ();
		~OUTPUTOFNEURON ();
	private:
	};

	class NEURON
	{
		public:
			NEURON ();
			~NEURON ();
			bool ConstructNewSynapse(NEURON *);
			bool IsSynapse (NEURON *);
			bool SetSynapse(NEURON *, int);
			int GetCountInput ();
			VECTOROFNEURON<INPUTOFNEURON, NEURON> *ConstructInput ();
			VECTOROFNEURON<INPUTOFNEURON, NEURON> *GetFirstInput ();
			VECTOROFNEURON<INPUTOFNEURON, NEURON> *GetInput (int);
			VECTOROFNEURON<INPUTOFNEURON, NEURON> *GetInput (NEURON *);
			VECTOROFNEURON<INPUTOFNEURON, NEURON> *GetLastInput ();

/*			void ConstructOutput ();*/
		private:
			int *output;
			float *p;
			VECTOROFNEURON<INPUTOFNEURON, NEURON> *thisInput;
			VECTOROFNEURON<OUTPUTOFNEURON, NEURON> *thisOutput;
	};
	
	NEURON::NEURON ()
	{
		output = new int;
		p = new float;
		*output = 0;
		*p = 0;
	};

	NEURON::~NEURON ()
	{
		delete output;
		delete p;
	};

	bool NEURON::ConstructNewSynapse(NEURON * rightSide)
	{
		VECTOROFNEURON<INPUTOFNEURON, NEURON> * i;
		i = this->GetInput (rightSide);
		if (i->GetSynapse ())
		{
			return false;
		}
		else
		{
			VECTOROFNEURON<INPUTOFNEURON, NEURON> *j;
			j = this->ConstructInput ();
			j->SetSynapse (j->GetSynapse ());
			return true;
		}

	};
	
	bool NEURON::IsSynapse (NEURON * rightSide)
	{
		if (this->GetFirstInput ())
		{
			if(rightSide == thisInput->GetSynapse ())
			{
				return true;
			}
			else
			{
				return this->IsSynapse (rightSide);
			}
		}
		else
		{
			return false;
		}
	};

	bool NEURON::SetSynapse(NEURON * rightSide, int i)
	{
		
			VECTOROFNEURON<INPUTOFNEURON, NEURON> *j;
			j = this->GetInput (i);
			if (j)
			{
				j->SetSynapse (rightSide);
				return true;
			}
			else
			{
				return false;
			}

	};

	int NEURON::GetCountInput ()
	{
		int i = 0;
		if (this->GetFirstInput ())
		{
			return thisInput->GetIncrease (i);
		}
		return i;
	};

	VECTOROFNEURON<INPUTOFNEURON, NEURON> *NEURON::GetFirstInput ()
	{
		if (thisInput)
			return this->thisInput;
		else
			return 0;
	};

	VECTOROFNEURON<INPUTOFNEURON, NEURON> *NEURON::GetInput (int num)
	{
		int i = 0;
		if (this->GetFirstInput ())
		{
			if (num == i)
			{
				return this->thisInput;
			}
			else
			{
				++i;
				return thisInput->GetTo (num, i);
			}
		}
		else
		{
			return 0;
		}
	};

	VECTOROFNEURON<INPUTOFNEURON, NEURON> *NEURON::GetInput (NEURON *rightSide)
	{
		if (this->GetFirstInput ())
		{
			if (rightSide == thisInput->GetSynapse ())
			{
				return this->thisInput;
			}
			else
			{
				return thisInput->GetTo (rightSide);
			}
		}
		else
		{
			return 0;
		}
	};

	VECTOROFNEURON<INPUTOFNEURON, NEURON> *NEURON::GetLastInput ()
	{
		if (this->GetFirstInput ())
			return thisInput->GetLast ();
		else
			return 0;
	};

	VECTOROFNEURON<INPUTOFNEURON, NEURON> *NEURON::ConstructInput ()
	{
		if (this->GetFirstInput ())
		{
			return thisInput->ConstructNext ();
		}
		else
		{
			thisInput = new VECTOROFNEURON<INPUTOFNEURON, NEURON>;
			return thisInput;
		}
	};

	template <class Data, class Synapse>
	VECTOROFNEURON<Data, Synapse>::VECTOROFNEURON ()
	{
		data = new Data;
	};

	template <class Data, class Synapse>
	VECTOROFNEURON<Data, Synapse>::~VECTOROFNEURON ()
	{
		delete data;
	};

	template <class Data, class Synapse>
	bool VECTOROFNEURON<Data,Synapse>::GetNext ()
	{
		if (next)
			return true;
		else
			return false;
	};

	template <class Data, class Synapse>
	bool VECTOROFNEURON<Data,Synapse>::IsSynapse (Synapse *rightSide)
	{
		if (this->GetFirstInput ())
		{
			if(rightSide == thisInput->GetSynapse ())
			{
				return true;
			}
			else
			{
				return next->IsSynapse (rightSide);
			}
		}
		else
		{
			return false;
		}
	};

	template <class Data, class Synapse>
	int VECTOROFNEURON<Data,Synapse>::GetIncrease (int i)
	{
		if (this->GetNext ())
		{
			++i;
			return next->GetIncrease (i);
		}
		return i;
	};
	
	template <class Data, class Synapse>
	Synapse *VECTOROFNEURON<Data,Synapse>::GetSynapse ()
	{
		return this->synapse;
	};

	template <class Data, class Synapse>
	VECTOROFNEURON<Data,Synapse> *VECTOROFNEURON<Data,Synapse>::ConstructNext ()
	{
		if (this->GetNext ())
		{
			return next->ConstructNext ();
		}
		else
		{
			next = new VECTOROFNEURON<INPUTOFNEURON, NEURON>;
			return next;
		}
	};

	template <class Data, class Synapse>
	VECTOROFNEURON<Data,Synapse> *VECTOROFNEURON<Data,Synapse>::GetTo(int num, int i)
	{
		if (next->GetNext ())
		{
			if (num == i)
			{
				return next;
			}
			else
			{
				++i;
				return this->GetTo (num, i);
			}
			return this;
		}
		else
		{
			return 0;
		}
	};

	template <class Data, class Synapse>
	VECTOROFNEURON<Data,Synapse> *VECTOROFNEURON<Data,Synapse>::GetTo (Synapse *rightSide)
	{
		
		if (rightSide)
		{
			return this;
		}
		else
		{
			if (this->GetNext ())
			{
				return next->GetTo (rightSide);
			}
			else
			{
				return 0;
			}
		}
	};

	
	template <class Data, class Synapse>
	VECTOROFNEURON<Data,Synapse> *VECTOROFNEURON<Data,Synapse>::GetLast ()
	{
		if (this->GetNext ())
		{
			return next->GetLast ();
		}
		else
		{
			return this;
		}
	};
	
	template <class Data, class Synapse>
	VECTOROFNEURON<Data,Synapse> *VECTOROFNEURON<Data,Synapse>::GetThis ()
	{
		return this;
	};

	template <class Data, class Synapse>
	void VECTOROFNEURON<Data,Synapse>::SetSynapse (Synapse * rightSide)
	{
		synapse = rightSide;
	};


	INPUTOFNEURON::INPUTOFNEURON ()
	{
		input = new int;
		w = new float;
		*input = 0;
		*w = rand() % 100 + 0;
		*w = *w/100;
	};
	
	INPUTOFNEURON::~INPUTOFNEURON ()
	{
		delete input;
		delete w;
	};
//};

Ahoj, když chcu zvětšit vektor, tak mě to vyhodí chybu. Potřeboval bych poradit.

#pragma once

#include <stdio.h>
#include <stdlib.h>

//namespace Neuron_Class {
	template <class DATA, class SYNAPSE>	
	class VECTOROFNEURON
	{
	public:
		VECTOROFNEURON ();
		~VECTOROFNEURON ();
		VECTOROFNEURON<DATA,SYNAPSE> *GetNext ();
		VECTOROFNEURON<DATA,SYNAPSE> *GetPrev ();
		void Construct ();
		void Destruct ();
		void SetSynapse (SYNAPSE *itsSynapse) {synapse = itsSynapse;}
		SYNAPSE *GetSynapse () const {return synapse;}
	private:
		SYNAPSE *synapse;
		DATA *data;
		VECTOROFNEURON<DATA,SYNAPSE> *next;
		VECTOROFNEURON<DATA,SYNAPSE> *prev;
	};

	class INPUTOFNEURON
	{
	public:
		INPUTOFNEURON ();
		~INPUTOFNEURON ();
	private:
		int *input;
		float *w;
	};
	class OUTPUTOFNEURON
	{
	public:
		OUTPUTOFNEURON ();
		~OUTPUTOFNEURON ();
	private:
	};

	class NEURON
	{
		public:
			NEURON ();
			~NEURON ();
			NEURON &operator++ ();
			NEURON &operator-- ();
			bool SetNextInput ();
			bool SetNextOutput ();
			bool SetNumInput (int);
			bool SetNumOutput (int);
			bool SetSynapseInput (NEURON*);
			bool SetSynapseOutput (NEURON*);
			VECTOROFNEURON<INPUTOFNEURON, NEURON> *GetThisInput ();
			VECTOROFNEURON<OUTPUTOFNEURON, NEURON> *GetThisOutput ();
			void ConstructInput ();
			void ConstructOutput ();
			void ConstructSynapse (NEURON*);
			void DestructInput (int i);
			void DestructOutput (int i);
			void DestructSynapse (NEURON*);
			void SetLastInput ();
			void SetLastOutput ();
		private:
			float *P;
			VECTOROFNEURON<INPUTOFNEURON, NEURON> *input;
			VECTOROFNEURON<INPUTOFNEURON, NEURON> *startInput;
			VECTOROFNEURON<OUTPUTOFNEURON, NEURON> *startOutput;
			VECTOROFNEURON<OUTPUTOFNEURON, NEURON> *output;
	};
	
	NEURON::NEURON ()
	{
		P = new float;
		*P = 0;
	};

	NEURON::~NEURON ()
	{
		delete P;
	};

	NEURON &NEURON::operator++ ()
	{
		input = input->GetNext ()->GetNext ();
		output = output->GetNext ()->GetNext ();
		return *this;
	};
	
	NEURON &NEURON::operator-- ()
	{
		input = input->GetNext ()->GetPrev ();
		output = output->GetNext ()->GetPrev ();
		return *this;
	};

	bool NEURON::SetNextInput ()
	{
		input = startInput;
		VECTOROFNEURON<INPUTOFNEURON, NEURON> *i;
		i = input;
		++input;
		if (input)
		{
			return true;
		}
		else
		{
			input = i;
			return false;
		}
		
	};

	bool NEURON::SetNextOutput ()
	{
		output = startOutput;
		VECTOROFNEURON<OUTPUTOFNEURON, NEURON> *i;
		i = output;
		++output;
		if (output)
		{
			return true;
		}
		else
		{
			output = i;
			return false;
		}
		
	};
	bool NEURON::SetNumInput (int i)
	{
		input = startInput;
		VECTOROFNEURON<INPUTOFNEURON, NEURON> *j;
		j = input;
		for (int k = 0; k < i; ++k)
		{
			++input;
		}
		if (input)
		{
			return true;
		}
		else
		{
			input = j;
			return false;
		}
		
	};

	bool NEURON::SetNumOutput (int i)
	{
		output = startOutput;
		VECTOROFNEURON<OUTPUTOFNEURON, NEURON> *j;
		j = output;
		for (int k = 0; k < i; ++k)
		{
			++output;
		}
		if (output)
		{
			return true;
		}
		else
		{
			output = j;
			return false;
		}
		
	};
	
	bool NEURON::SetSynapseInput (NEURON *i)
	{
		input = startInput;
		bool j;
		while (input->GetSynapse () != i)
		{
			j = SetNextInput ();
		}
		return j;
	};

	bool NEURON::SetSynapseOutput (NEURON *i)
	{
		output = startOutput;
		bool j;
		while (output->GetSynapse () != i)
		{
			j = SetNextOutput ();
		}
		return j;
	};

	VECTOROFNEURON<INPUTOFNEURON, NEURON> *NEURON::GetThisInput ()
	{
		if (input)
		{
			return input;
		}
		else
		{
			return 0;
		}
	};
	
	VECTOROFNEURON<OUTPUTOFNEURON, NEURON> *NEURON::GetThisOutput ()
	{
		if (output)
		{
			return output;
		}
		else
		{
			return 0;
		}
	};

	void NEURON::ConstructInput ()
	{
		if (startInput)
		{
			SetLastInput ();
			input->Construct ();
		}
		else
		{
			startInput = new VECTOROFNEURON<INPUTOFNEURON, NEURON>;
		}
		SetLastInput ();

	};

	void NEURON::DestructInput (int i)
	{
		SetNumInput (i);
		input->Destruct ();

	};

	void NEURON::ConstructOutput ()
	{
		if (startOutput)
		{
			SetLastOutput ();
			output->Construct ();
		}
		else
		{
			startOutput = new VECTOROFNEURON<OUTPUTOFNEURON, NEURON>;
		}
		SetLastOutput ();
	};
	
	void NEURON::ConstructSynapse (NEURON *i)
	{
		this->ConstructOutput ();
		i->ConstructInput ();
		this->output->SetSynapse (i);
		i->input->SetSynapse (this);
	};

	void NEURON::DestructOutput (int i)
	{
		SetNumOutput (i);
		output->Destruct ();

	};

	void NEURON::DestructSynapse (NEURON *i)
	{
		this->SetSynapseOutput (i);
		i->SetSynapseInput (this);
		this->output->Destruct ();
		i->input->Destruct ();
	};
	
	void NEURON::SetLastInput ()
	{
		input = startInput;
		VECTOROFNEURON<INPUTOFNEURON, NEURON> *i;
		while (input)
		{
			i =input;
			++input;
		}
		input = i;
	};

	void NEURON::SetLastOutput ()
	{
		output = startOutput;
		VECTOROFNEURON<OUTPUTOFNEURON, NEURON> *i;
		while (output)
		{
			i = output;
			++output;
		}
		output = i;
	};

	template <class DATA, class SYNAPSE>
	VECTOROFNEURON<DATA, SYNAPSE>::VECTOROFNEURON ()
	{
		data = new DATA;
	};

	template <class DATA, class SYNAPSE>
	VECTOROFNEURON<DATA, SYNAPSE>::~VECTOROFNEURON ()
	{
		delete data;
	};

	template <class DATA, class SYNAPSE>
	VECTOROFNEURON<DATA,SYNAPSE> *VECTOROFNEURON<DATA,SYNAPSE>::GetNext ()
	{
		if (next)
			return next;
		else
			return 0;
	};
	
	template <class DATA, class SYNAPSE>
	VECTOROFNEURON<DATA,SYNAPSE> *VECTOROFNEURON<DATA,SYNAPSE>::GetPrev ()
	{
		if (prev)
			return prev;
		else
			return 0;
	};
	
	template <class DATA, class SYNAPSE>
	void VECTOROFNEURON<DATA,SYNAPSE>::Construct ()
	{
		this->next = new VECTOROFNEURON<DATA,SYNAPSE>;
		next->prev = this;
	};
	
	template <class DATA, class SYNAPSE>
	void VECTOROFNEURON<DATA,SYNAPSE>::Destruct ()
	{
		prev->next = next;
		next->prev = prev;
		delete this;
	};

	INPUTOFNEURON::INPUTOFNEURON ()
	{
		input = new int;
		w = new float;
		*input = 0;
		*w = rand() % 100 + 0;
		*w = *w/100;
	};
	
	INPUTOFNEURON::~INPUTOFNEURON ()
	{
		delete input;
		delete w;
	};

	
	OUTPUTOFNEURON::OUTPUTOFNEURON () {};
	OUTPUTOFNEURON::~OUTPUTOFNEURON () {};
//};

// Neural_Network.cpp : main project file.

#include "stdafx.h"
#include "Neuron_Class.h"
#include <iostream>
#include <vector>

using namespace System;

int main(array<System::String ^> ^args)
{
	bool a = true;
	int b = 0;
	int c;
	
		std::vector<NEURON> neuron(b);
	while (a)
	{
		std::cout << "Write numer" << std::endl<< "if 0 so programm is ending." << std::endl<< "If 1 so insert one Neutron. " << std::endl << "if 2 so look all neutrons." /*<< std::endl<< "Write numer" << std::endl<< "Write numer" << std::endl<< "Write numer"*/ << std::endl;
		std::cin >> c;
		switch (c)
		{
			case 0:
				a = false;
				break;
			case 1:
				b = b + 1;
				neuron.resize (b);
				std::cout << b << std::endl;
				break;
			case 2:
				for (int i = 0; i < b; ++i)
				{
					std::cout << "Neuron n. "<< b << " "<< &neuron[i] << std::endl;
				}
				break;
			default:
				std::cout << "Error" << std::endl;
				break;
		}

	}

    return 0;
}

nebolo by lepsie pouzit na pridanie neuronu do vektora bush_back() alebo emplace_back() miesto resize() ?

Když mám dva a více neuronů a použiju, jakoukoliv funkci na zvětšení, tak program prostě v příkazové řádce spadne. Když třeba ze začátku použijů vektor s 1000 prvky, tak je to v pohodě, když nezvyšuji jejich počet.

Pri zvecseni vektora sa musi realokovat oblast pameti, cize sa moze obsah celeho vektora presunut do inej pameti a tym padom vsetky ukazatele a iteratory ktore ukazovaly na povodne prvky ukazuju do zlej pamete.

Po zběžném pohledu: Máš tam třídu VECTOROFNEURON, která obsahuje ukazatele. Nemáš v ní ale copy konstruktor ani operátor přiřazení. Možná nejsou potřeba, ale v takovém případě si je aspoň nadeklaruj (bez implementace) jako privátní. Pak hned uvidíš, jestli potřebné jsou (nepřloží se to) nebo ne. Pokud takovou třídu strkáš do nějakého STL kontejneru, tak potřebné nejspíš budou. A pokud potřebné jsou, tak v současné implementaci ti chybí deep copy instance (nebo nějaký jiný mechanismus).

To samé se může týkat i dalších tříd, ty jsem ale neprocházel.

#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <iostream>

//namespace Neuron_Class {
	template <class DATA, class SYNAPSE>	
	class VECTOROFNEURON
	{
	public:
		VECTOROFNEURON ();
		~VECTOROFNEURON ();
		VECTOROFNEURON (SYNAPSE*, DATA*, VECTOROFNEURON*, VECTOROFNEURON*);
		VECTOROFNEURON (VECTOROFNEURON*, VECTOROFNEURON*);
		VECTOROFNEURON<DATA,SYNAPSE> *GetNext ();
		VECTOROFNEURON<DATA,SYNAPSE> *GetPrev ();
		void Construct ();
		void Destruct ();
		void SetSynapse (SYNAPSE*);
		SYNAPSE *GetSynapse () const {return synapse;}
	private:
		SYNAPSE *synapse;
		DATA *data;
		VECTOROFNEURON<DATA,SYNAPSE> *next;
		VECTOROFNEURON<DATA,SYNAPSE> *prev;
	};

	class INPUTOFNEURON
	{
	public:
		INPUTOFNEURON ();
		~INPUTOFNEURON ();
	private:
		int *input;
		float *w;
	};
	class OUTPUTOFNEURON
	{
	public:
		OUTPUTOFNEURON ();
		~OUTPUTOFNEURON ();
	private:
	};

	class NEURON
	{
		public:
			NEURON ();
			~NEURON ();
			bool SetNextInput ();
			bool SetNextOutput ();
			bool SetNumInput (int);
			bool SetNumOutput (int);
			bool SetStartInput ();
			bool SetStartOutput ();
			VECTOROFNEURON<INPUTOFNEURON, NEURON> *GetThisInput ();
			VECTOROFNEURON<OUTPUTOFNEURON, NEURON> *GetThisOutput ();
			void ConstructInput ();
			void ConstructOutput ();
			void ConstructSynapse (NEURON*);
			void DestructInput (int i);
			void DestructOutput (int i);
			void DestructSynapse (NEURON*);
			void SetLastInput ();
			void SetLastOutput ();
			void SetSynapseInput (NEURON*);
			void SetSynapseOutput (NEURON*);
		private:
			float *P;
			VECTOROFNEURON<INPUTOFNEURON, NEURON> *input;
			VECTOROFNEURON<INPUTOFNEURON, NEURON> *startInput;
			VECTOROFNEURON<OUTPUTOFNEURON, NEURON> *startOutput;
			VECTOROFNEURON<OUTPUTOFNEURON, NEURON> *output;
	};
	
	NEURON::NEURON ()
	{
		P = new float;
		*P = 0;
	};

	NEURON::~NEURON ()
	{
		delete P;
	};

	bool NEURON::SetNextInput ()
	{
		VECTOROFNEURON<INPUTOFNEURON, NEURON> *i;
		i = input;
		input = input->GetNext ();
		if (input)
		{
			return true;
		}
		else
		{
			input = i;
			return false;
		}
		
	};

	bool NEURON::SetNextOutput ()
	{
		VECTOROFNEURON<OUTPUTOFNEURON, NEURON> *i;
		i = output;
		output = output->GetNext ();
		if (output)
		{
			return true;
		}
		else
		{
			output = i;
			return false;
		}
		
	};

	bool NEURON::SetNumInput (int i)
	{
		VECTOROFNEURON<INPUTOFNEURON, NEURON> *j;
		j = input;
		for (int k = 0; k < i; ++k)
		{
			input = input->GetNext ();
		}
		if (input)
		{
			return true;
		}
		else
		{
			input = j;
			return false;
		}
		
	};

	bool NEURON::SetNumOutput (int i)
	{
		VECTOROFNEURON<OUTPUTOFNEURON, NEURON> *j;
		j = output;
		for (int k = 0; k < i; ++k)
		{
			output = output->GetNext ();
		}
		if (output)
		{
			return true;
		}
		else
		{
			output = j;
			return false;
		}
		
	};

	bool NEURON::SetStartInput ()
	{
		if (startInput)
		{
			input = startInput;
			return true;
		}
		else
		{
			return false;
		}
	};

	bool NEURON::SetStartOutput ()
	{
		if (startOutput)
		{
			output = startOutput;
			return true;
		}
		else
		{
			return false;
		}
	};

	VECTOROFNEURON<INPUTOFNEURON, NEURON> *NEURON::GetThisInput ()
	{
		if (input)
		{
			return input;
		}
		else
		{
			return 0;
		}
	};
	
	VECTOROFNEURON<OUTPUTOFNEURON, NEURON> *NEURON::GetThisOutput ()
	{
		if (output)
		{
			return output;
		}
		else
		{
			return 0;
		}
	};

	void NEURON::ConstructInput ()
	{
		if (startInput)
		{
			input = startInput;
			SetLastInput ();
			input->Construct ();
		}
		else
		{
			startInput = new VECTOROFNEURON<INPUTOFNEURON, NEURON>;
		}
		input = input->GetNext ();
	};

	void NEURON::DestructInput (int i)
	{
		SetNumInput (i);
		input->Destruct ();

	};

	void NEURON::ConstructOutput ()
	{
		if (startOutput)
		{
			output = startOutput;
			SetLastOutput ();
			output->Construct ();
		}
		else
		{
			startOutput = new VECTOROFNEURON<OUTPUTOFNEURON, NEURON>;
		}
		output = output->GetNext ();
	};
	
	void NEURON::ConstructSynapse (NEURON *i)
	{
		std::cout << this << "a11" << std::endl;
		this->SetSynapseOutput (i);
		std::cout << i << "b22" << std::endl;
		i->SetSynapseInput (this);
		std::cout << "c33" << std::endl;
	};

	void NEURON::DestructOutput (int i)
	{
		SetNumOutput (i);
		output->Destruct ();

	};

	void NEURON::DestructSynapse (NEURON *i)
	{
		this->SetSynapseOutput (i);
		i->SetSynapseInput (this);
		this->output->Destruct ();
		i->input->Destruct ();
	};
	
	void NEURON::SetLastInput ()
	{
		while (input->GetNext ())
		{
			input = input->GetNext ();
		}
	};

	void NEURON::SetLastOutput ()
	{
		while (output->GetNext ())
		{
			output = output->GetNext ();
		}
	};
	
	
	void NEURON::SetSynapseInput (NEURON *i)
	{
		this->SetStartInput ();
		this->ConstructInput();
		this->SetNextInput ();
		input->VECTOROFNEURON<INPUTOFNEURON, NEURON>::SetSynapse (i);
	};

	void NEURON::SetSynapseOutput (NEURON *i)
	{
		std::cout << this << "det1" << std::endl;
		this->SetStartOutput ();
		std::cout << this << "det2" << std::endl;
		this->ConstructOutput();
		std::cout << this << "det3" << std::endl;
		this->SetNextOutput ();
		std::cout << this << "det4" << std::endl;
		output->VECTOROFNEURON<OUTPUTOFNEURON, NEURON>::SetSynapse (i);
		std::cout << this << "det5" << std::endl;
	};

	template <class DATA, class SYNAPSE>
	VECTOROFNEURON<DATA, SYNAPSE>::VECTOROFNEURON ()
	{
		synapse = new SYNAPSE;
		data = new DATA;
		next = 0;
		prev = 0;
	};

	template <class DATA, class SYNAPSE>
	VECTOROFNEURON<DATA, SYNAPSE>::~VECTOROFNEURON ()
	{
		delete synapse;
		delete data;
	};

	template <class DATA, class SYNAPSE>
	VECTOROFNEURON<DATA, SYNAPSE>::VECTOROFNEURON (SYNAPSE* sy = NULL, DATA* it = NULL, VECTOROFNEURON* pNext = NULL, VECTOROFNEURON* pPrev = NULL)
	{
		synapse = sy;
		data = it;
		next = pNext;
		prev = pPrev;
	};
	
	template <class DATA, class SYNAPSE>
	VECTOROFNEURON<DATA, SYNAPSE>::VECTOROFNEURON (VECTOROFNEURON* pNext = NULL, VECTOROFNEURON* pPrev = NULL)
	{
		next = pNext;
		prev = pPrev;
	};

	template <class DATA, class SYNAPSE>
	VECTOROFNEURON<DATA,SYNAPSE> *VECTOROFNEURON<DATA,SYNAPSE>::GetNext ()
	{
		if (next)
		{
			return next;
		}
		else
		{
			return 0;
		}
	};
	
	template <class DATA, class SYNAPSE>
	VECTOROFNEURON<DATA,SYNAPSE> *VECTOROFNEURON<DATA,SYNAPSE>::GetPrev ()
	{
		if (prev)
			return prev;
		else
			return 0;
	};
	
	template <class DATA, class SYNAPSE>
	void VECTOROFNEURON<DATA,SYNAPSE>::Construct ()
	{
		this->next = new VECTOROFNEURON<DATA,SYNAPSE>;
		next->prev = this;
	};
	
	template <class DATA, class SYNAPSE>
	void VECTOROFNEURON<DATA,SYNAPSE>::Destruct ()
	{
		prev->next = next;
		next->prev = prev;
		delete this;
	};

	template <class DATA, class SYNAPSE>
	void VECTOROFNEURON<DATA,SYNAPSE>::SetSynapse (SYNAPSE *itsSynapse)
	{
		synapse = itsSynapse;
	};

	INPUTOFNEURON::INPUTOFNEURON ()
	{
		input = new int;
		w = new float;
		*input = 0;
		*w = rand() % 100 + 0;
		*w = *w/100;
	};
	
	INPUTOFNEURON::~INPUTOFNEURON ()
	{
		delete input;
		delete w;
	};

	
	OUTPUTOFNEURON::OUTPUTOFNEURON () {};
	OUTPUTOFNEURON::~OUTPUTOFNEURON () {};
//};

// Neural_Network.cpp : main project file.

#include "stdafx.h"
#include "Neuron_Class.h"
#include <iostream>
#include <vector>

using namespace System;

int main(array<System::String ^> ^args)
{
	bool a = true;
	int b = 15;
	int c;
	NEURON d;
	bool e;
	int f;
	int g;
	NEURON *h;
	std::vector<NEURON> neuron(b);
	while (a)
	{
		std::cout << "Write numer" << std::endl<< "if 0 so programm is ending." << std::endl<< "If 1 so insert one Neutron. " << std::endl << "if 2 so look all neutrons." << std::endl<< "If 3 so insert input." << std::endl<< "If 4 so Construct new synapse" /*<< std::endl<< "Write numer"*/ << std::endl;
		std::cin >> c;
		switch (c)
		{
			case 0:
				a = false;
				break;
			case 1:/*
				++b;
				neuron.emplace_back (d);
				std::cout << b << std::endl;*/
				break;
			case 2:
				for (int i = 0; i < b; ++i)
				{
					std::cout << "Neuron n. "<< b << " "<< &neuron[i] << std::endl;
					e = true;
					std::cout << "			input: " << std::endl;
					if (neuron[i].SetStartInput ())
					{
						while (e)
						{
							std::cout << "				" << neuron[i].GetThisInput () << std::endl;
							e = neuron[i].SetNextInput ();
						}
					}
					e = true;
					std::cout << "			output: " << std::endl;
					if (neuron[i].SetStartOutput ())
					{
						while (e)
						{
							std::cout << "				" << neuron[i].GetThisOutput () << std::endl;
							e = neuron[i].SetNextOutput ();
						}
					}
				}
				break;
			case 3:
				std::cout << "Chose Neuron n. ";
				std::cin >> f;
				std:: cout << std::endl;
				std::cout << "How many insert input? ";
				std::cin >> g;
				std:: cout << std::endl;
				for (int i = 0; i < g; ++i)
				{
					neuron[f].SetStartInput ();
					neuron[f].ConstructInput ();
				}
				break;
			case 4:
				int e;
				int f;
				std::cout << "Chose Neuron n. of output";
				std::cin >> e;
				std:: cout << std::endl;
				std::cout << "Chose Neuron n. of input";
				std::cin >> f;
				std:: cout << std::endl;
				h = &neuron[f];
				neuron[e].SetStartInput ();
				neuron[e].ConstructSynapse (h);
				break;
			default:
				std::cout << "Error" << std::endl;
				break;
		}
	}

    return 0;
}

Ahoj, když použiju metodu void SetSynapse (SYNAPSE *), tak program spadne. Jinak to stále padá, když zvětším vektor. Nemám použít spíše spojitý seznam?

omylem jsem použil constructor "new" a destructor "delete" na proměnou synapse, když má ukazovat na již existující třídu. Ale to stejně neřeší můj problém.

Ten tvoj kod sa strasne zle cita, vsetky typy s velkymi pismanami kde nejde rozlisit viacslovne nazvy...

Co vlastne ma ten program robit?

edit:

Tie templaty su celkovo dake divne, dalej VECTOROFNEURON nie je vector ale skor je to prvok listu (preco si nepouzil std::list? ), preco dynamicky alokujes int a float typy?

#15 vitamin
sorry, je to vlastně můj druhej program ano je to prvek spojitýho seznamu. Za názvy se omlouvám, proto sem píšu, abych si věci ujasnil a aby mě někdo poradil nebo dal tip.  Tento program dělám z hlavy jen s obecnýma znalostma, jak by takový spojitý seznam měl vypadat a u třídy neuron (ano má se v budoucnu jednat o neuronovou síť) znám taky jen teorií a pár vzorečků a obecnou představu, jak by měl fungovat..

Jinak se omlouvám i za názvy. Česky to psát nechci a v angličtině nejsem zas až tak dobrej. A navíc je docela obtížný vymýšlet smysluplná jména metod. A navíc jak vidíte mám bordel i ve stylu a některých názvů. Jako třeba, že jsem linked list zaměnil za vektor.

Nevým, jak hodně je inteligentní v konstructoru inicializovat ukazatele na nulu a v další metodě jim inicializovat adresu. Ale nedokázal jsem si poradit s adresou CDCDCDCD. Možná převíst podmínku na if (next != CDCDCDCD). Vím, že je to šestnáckové číslo a že na to by měl existovat převodní příkaz HEX. Ale zatím jsem nezkoušel. Jestly máte rady i ohledně tohoto.

Mas v cestine velice zajimavej zpusob vyjadrovani.. az to odvadi uplne od puvodniho problemu :)

Nevim co znamena napriklad "nevym" a "jestly" ale budiz... zajimavy je i mixovani k a c .. konstructor... konstruktor nebo constructor vyber si jedno z toho :D

A abych nezapomel: hexa cisla se zapisuji  0xABCD01

Adresu inicializovat muzes na NULL a pak zmenit na nejakou platnou (samozrejme hlidat abys nepristupoval k NULL)

+ Vektor ani moc nevadi.. velkej linked list je pro velky mnozstvi dat horsi jak presuny dat, pokud neco vlozis do vektoru...

A na to, jak psat nazvy je dobre proletet nejaky coding standardy.. ale lisi se to skoro v kazdem co a jak..

Obvykle VELKEJMA se oznacujou makra, konstanty pomoci #define a tak...

Bezva, zdá se, že metody, které zatím mám fungují. Poprvé jsem musel kouknout na list do manuálu. Zvětšování počtů neuronů stále nefunguje. Jestly je moje vyjadřování horší než minule, tak se omlouvám, jsem dost nachcípanej. Používání poloanglických výrazů je můj blbej zvyk.

#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <iostream>

//namespace Neuron_Class {
	template <class Data, class Synapse>	
	class ListOfNeuron
	{
	public:
		ListOfNeuron ();
		ListOfNeuron (ListOfNeuron&);
		~ListOfNeuron ();
		ListOfNeuron (Synapse*, Data*, ListOfNeuron*, ListOfNeuron*);
		ListOfNeuron (Synapse*, ListOfNeuron*, ListOfNeuron*);
		ListOfNeuron<Data,Synapse> *Construct ();
		ListOfNeuron<Data,Synapse> *GetNext ();
		ListOfNeuron<Data,Synapse> *GetPrev ();
		void Destruct ();
		void DestructFirst ();
		void DestructLast ();
		void SetSynapse (Synapse*);
		Synapse *GetSynapse () const {return synapse;}
	private:
		Synapse *synapse;
		Data *data;
		ListOfNeuron<Data,Synapse> *next;
		ListOfNeuron<Data,Synapse> *prev;
	};

	class InputOfNeuron
	{
	public:
		InputOfNeuron ();
		~InputOfNeuron ();
	private:
		int *input;
		float *w;
	};
	class OutputOfNeuron
	{
	public:
		OutputOfNeuron ();
		~OutputOfNeuron ();
	private:
	};

	class Neuron
	{
		public:
			Neuron ();
			~Neuron ();
			bool SetNextInput ();
			bool SetNextOutput ();
			bool SetNumInput (int);
			bool SetNumOutput (int);
			bool SetStartInput ();
			bool SetStartOutput ();
			ListOfNeuron<InputOfNeuron, Neuron> *GetThisInput ();
			ListOfNeuron<OutputOfNeuron, Neuron> *GetThisOutput ();
			void ConstructInput ();
			void ConstructOutput ();
			void ConstructSynapse (Neuron*);
			void DestructInput (int i);
			void DestructOutput (int i);
			void DestructSynapse (Neuron*);
			void SetLastInput ();
			void SetLastOutput ();
			void SetSynapseInput (Neuron*);
			void SetSynapseOutput (Neuron*);
		private:
			float *P;
			ListOfNeuron<InputOfNeuron, Neuron> *lastInput;
			ListOfNeuron<OutputOfNeuron, Neuron> *lastOutput;
			ListOfNeuron<InputOfNeuron, Neuron> *input;
			ListOfNeuron<InputOfNeuron, Neuron> *startInput;
			ListOfNeuron<OutputOfNeuron, Neuron> *startOutput;
			ListOfNeuron<OutputOfNeuron, Neuron> *output;
	};
	
	Neuron::Neuron ()
	{
		P = new float;
		*P = 0;
		lastInput = 0;
		lastOutput = 0;
		input = 0;
		startInput = 0;
		startOutput = 0;
		output = 0;
	};

	Neuron::~Neuron ()
	{
		delete P;
	};

	bool Neuron::SetNextInput ()
	{
		if (input != lastInput)
		{
			input = input->GetNext ();
			return true;
		}
		else
		{
			return false;
		}
		
	};

	bool Neuron::SetNextOutput ()
	{
		if (output != lastOutput)
		{
			output = output->GetNext ();
			return true;
		}
		else
		{
			return false;
		}
		
	};

	bool Neuron::SetNumInput (int i)
	{
		SetStartInput ();
		for (int k = 0; k < i; ++k)
		{
			if (input != lastInput)
			{
				input->GetNext ();
			}
			else
			{
				return false;
			}
		}
		return true;
		
	};

	bool Neuron::SetNumOutput (int i)
	{
		SetStartOutput ();
		for (int k = 0; k < i; ++k)
		{
			if (output != lastOutput)
			{
				output->GetNext ();
			}
			else
			{
				return false;
			}
		}
		return true;
		
	};

	bool Neuron::SetStartInput ()
	{
		if (startInput)
		{
			input = startInput;
			return true;
		}
		else
		{
			return false;
		}
	};

	bool Neuron::SetStartOutput ()
	{
		if (startOutput)
		{
			output = startOutput;
			return true;
		}
		else
		{
			return false;
		}
	};

	ListOfNeuron<InputOfNeuron, Neuron> *Neuron::GetThisInput ()
	{
		if (input)
		{
			return input;
		}
		else
		{
			return 0;
		}
	};
	
	ListOfNeuron<OutputOfNeuron, Neuron> *Neuron::GetThisOutput ()
	{
		if (output)
		{
			return output;
		}
		else
		{
			return 0;
		}
	};

	void Neuron::ConstructInput ()
	{
		if (lastInput)
		{
			input = lastInput;
			lastInput = input->Construct ();
		}
		else
		{
			startInput = new ListOfNeuron<InputOfNeuron, Neuron>;
			lastInput = startInput;
		}
	};

	void Neuron::DestructInput (int i)
	{
		SetNumInput (i);
		if (input == startInput)
		{
		input->DestructFirst ();
		}
		if (input == lastInput)
		{
			input->DestructLast ();
		}
		if (input != startInput && input != lastInput)
		{
		input->Destruct ();
		}

	};

	void Neuron::ConstructOutput ()
	{
		if (lastOutput)
		{
			output = lastOutput;
			lastOutput = output->Construct ();
			std::cout << "output	" << output << "	lastOutput	" << lastOutput << std::endl; 
		}
		else
		{
			startOutput = new ListOfNeuron<OutputOfNeuron, Neuron>;
			lastOutput = startOutput;
		}
	};
	
	void Neuron::ConstructSynapse (Neuron *i)
	{
		this->SetSynapseOutput (i);
		i->SetSynapseInput (this);
	};

	void Neuron::DestructOutput (int i)
	{
		SetNumOutput (i);
		if (output == startOutput)
		{
		output->DestructFirst ();
		}
		if (output == lastOutput)
		{
			output->DestructLast ();
		}
		if (output != startOutput && output != lastOutput)
		{
		output->Destruct ();
		}

	};

	void Neuron::DestructSynapse (Neuron *i)
	{
		this->SetSynapseOutput (i);
		i->SetSynapseInput (this);
		this->output->Destruct ();
		i->input->Destruct ();
	};
	
	void Neuron::SetLastInput ()
	{
		input = lastInput;
	};

	void Neuron::SetLastOutput ()
	{
		output = lastOutput;
	};
	
	
	void Neuron::SetSynapseInput (Neuron *i)
	{
		this->ConstructInput();
		lastInput->ListOfNeuron<InputOfNeuron, Neuron>::SetSynapse (i);
	};

	void Neuron::SetSynapseOutput (Neuron *i)
	{
		this->ConstructOutput();
		lastOutput->ListOfNeuron<OutputOfNeuron, Neuron>::SetSynapse (i);
	};

	template <class Data, class Synapse>
	ListOfNeuron<Data, Synapse>::ListOfNeuron ()
	{
		synapse = 0;
		data = new Data;
		next = 0;
		prev = 0;
	};

	template <class Data, class Synapse>
	ListOfNeuron<Data, Synapse>::ListOfNeuron (ListOfNeuron&)
	{
		synapse = 0;
		data = new Data;
		next = 0;
		prev = 0;
	};

	template <class Data, class Synapse>
	ListOfNeuron<Data, Synapse>::~ListOfNeuron ()
	{
		delete data;
	};

	template <class Data, class Synapse>
	ListOfNeuron<Data, Synapse>::ListOfNeuron (Synapse* sy, Data* it, ListOfNeuron* pNext, ListOfNeuron* pPrev)
	{
		synapse = sy;
		data = it;
		next = pNext;
		prev = pPrev;
	};
	
	template <class Data, class Synapse>
	ListOfNeuron<Data, Synapse>::ListOfNeuron (Synapse* sy = NULL, ListOfNeuron* pNext = NULL, ListOfNeuron* pPrev = NULL)
	{
		synapse = sy;
		next = pNext;
		prev = pPrev;
	};
	
	template <class Data, class Synapse>
	ListOfNeuron<Data,Synapse> *ListOfNeuron<Data,Synapse>::Construct ()
	{
		this->next = new ListOfNeuron<Data,Synapse>;
		next->prev = this;
		return next;
	};

	template <class Data, class Synapse>
	ListOfNeuron<Data,Synapse> *ListOfNeuron<Data,Synapse>::GetNext ()
	{
		if (next)
		{
			return next;
		}
		else
		{
			return 0;
		}
	};
	
	template <class Data, class Synapse>
	ListOfNeuron<Data,Synapse> *ListOfNeuron<Data,Synapse>::GetPrev ()
	{
		if (prev)
			return prev;
		else
			return 0;
	};
	
	template <class Data, class Synapse>
	void ListOfNeuron<Data,Synapse>::Destruct ()
	{
		prev->next = next;
		next->prev = prev;
		delete this;
	};
	
	template <class Data, class Synapse>
	void ListOfNeuron<Data,Synapse>::DestructFirst ()
	{
		next->prev = prev;
		delete this;
	};
	
	template <class Data, class Synapse>
	void ListOfNeuron<Data,Synapse>::DestructLast ()
	{
		prev->next = next;
		delete this;
	};

	template <class Data, class Synapse>
	void ListOfNeuron<Data,Synapse>::SetSynapse (Synapse *itsSynapse)
	{
		synapse = itsSynapse;
	};

	InputOfNeuron::InputOfNeuron ()
	{
		input = new int;
		w = new float;
		*input = 0;
		*w = rand() % 100 + 0;
		*w = *w/100;
	};
	
	InputOfNeuron::~InputOfNeuron ()
	{
		delete input;
		delete w;
	};

	
	OutputOfNeuron::OutputOfNeuron () {};
	OutputOfNeuron::~OutputOfNeuron () {};
//};

// Neural_Network.cpp : main project file.

#include "stdafx.h"
#include "Neuron_Class.h"
#include <iostream>
#include <vector>

using namespace System;

int main(array<System::String ^> ^args)
{
	bool a = true;
	int b = 15;
	int c;
	Neuron d;
	bool e;
	int f;
	int g;
	Neuron *h;
	ListOfNeuron<InputOfNeuron, Neuron> *in;
	ListOfNeuron<OutputOfNeuron, Neuron> *on;
	std::vector<Neuron> neuron(b);
	while (a)
	{
		std::cout << "Write numer" << std::endl<< "if 0 so programm is ending." << std::endl<< "If 1 so insert one Neutron. " << std::endl << "if 2 so look all neutrons." << std::endl<< "If 3 so insert input." << std::endl<< "If 4 so Construct new synapse" /*<< std::endl<< "Write numer"*/ << std::endl;
		std::cin >> c;
		switch (c)
		{
			case 0:
				a = false;
				break;
			case 1:
				++b;
				neuron.emplace_back (d);
				std::cout << b << std::endl;
				break;
			case 2:
				for (int i = 0; i < b; ++i)
				{
					std::cout << "Neuron n. "<< i << " "<< &neuron[i] << std::endl;
					e = true;
					std::cout << "			input: " << std::endl;
					if (neuron[i].SetStartInput ())
					{
						int j = 0;
						while (e)
						{
							in = neuron[i].GetThisInput ();
							std::cout << "				" << j << " " << in << "		" ;
							if (in->GetSynapse ())
							{
								std::cout << in->GetSynapse () <<std::endl;
							}
							else
							{
								std::cout << std::endl;
							}
							e = neuron[i].SetNextInput ();
							++j;
						}
					}
					e = true;
					std::cout << "			output: " << std::endl;
					if (neuron[i].SetStartOutput ())
					{
						int j = 0;
						while (e)
						{
							on = neuron[i].GetThisOutput ();
							std::cout << "				" << j << " " << on << "		";
							if (on->GetSynapse ())
							{
								std::cout << on->GetSynapse () << std::endl;
							}
							else
							{
								std::cout << std::endl;
							}
							e = neuron[i].SetNextOutput ();
							++j;
						}
					}
				}
				break;
			case 3:
				std::cout << "Chose Neuron n. ";
				std::cin >> f;
				std:: cout << std::endl;
				std::cout << "How many insert input? ";
				std::cin >> g;
				std:: cout << std::endl;
				for (int i = 0; i < g; ++i)
				{
					neuron[f].SetStartInput ();
					neuron[f].ConstructInput ();
				}
				break;
			case 4:
				int e;
				int f;
				std::cout << "Chose Neuron n. of output";
				std::cin >> e;
				std:: cout << std::endl;
				std::cout << "Chose Neuron n. of input";
				std::cin >> f;
				std:: cout << std::endl;
				h = &neuron[f];
				neuron[e].SetStartInput ();
				neuron[e].ConstructSynapse (h);
				break;
			default:
				std::cout << "Error" << std::endl;
				break;
		}
	}

    return 0;
}

Je to uz davno co som mal neuronove siet, takze toto nemusi byt dobre, ale mozno ti to pomoze:

#include <iostream>
#include <vector>

using namespace std;

template <class Data>
class Neuron{
		/*
		 * ako data mozes pouzit triedu ktora bude mat uciace metody atd
		 */
		Data data;
		vector<Neuron*>	out;
	public:
		void AddOutput(Neuron* n){out.push_back(n);}
	
		Neuron(){}
		Neuron(Data &d):data(d){}
};

template <class Data>
class Siet {
	public:	
		typedef Neuron<Data> neuron_t;
		typedef vector<neuron_t> vrstva_t;
		
	private:
		vector<vrstva_t>	vrstvy;
	
	public:	
		vrstva_t& GetInput(){return vrstvy.first();}
		vrstva_t& GetOutput(){return vrstvy.back();}
		vrstva_t& AddVrstva(size_t pocet_neuronov = 0){
			vrstvy.emplace_back(pocet_neuronov);
			return vrstvy.back();
		}
		void PospajatVrstvy(){
			//pospaja medzi sebou neurony z dvoch pri sebe leziacych vrstiev (vytvara doprednu siet, nie rekurentnu)
			for(auto i = vrstvy.begin(); i != vrstvy.end() && (i+1) != vrstvy.end(); ++i)
				for(auto& l : *i)
					for(auto& r : *(i+1)){
						l.AddOutput(&r);
					}
		}
		/*
		 * sem dorobit funkcie ktore pospajaju vrstvy podla inych algoritmov
		 */
		
};

int main(){
	Siet<float> siet;
	
	siet.AddVrstva(2);	//vstupy
	siet.AddVrstva(5);
	siet.AddVrstva(1);	//vystupy
	
	siet.PospajatVrstvy();
}

Z tochto by mala byt takato siet:

http://upload.wikimedia.org/…lnetwork.png

Díky. :-)

Chybaju tam samozrejme vahy spojov, tie si budes musiet dorobyt, ale je to jednoduche :)

Jasně, zatím to nebylo zas tak těžké, problém byla hlavně zkušenost.

Ahoj, můžu v kopírovácím konstructoru prohodiť adresy těch dvou objektů?