Trida v tride... nefunguje – C / C++ – Fórum – Programujte.com
 x   TIP: Přetáhni ikonu na hlavní panel pro připnutí webu
Reklama
Reklama

Trida v tride... nefunguje – C / C++ – Fórum – Programujte.comTrida v tride... nefunguje – C / C++ – Fórum – Programujte.com

 

Hledá se programátor! Plat 1 800 € + bonusy (firma Boxmol.com)
Anonymní uživatel
~ Anonymní uživatel
0 příspěvků
23. 5. 2011   #1
-
0
-



#ifndef ARRAY_SORTED_ARRAY
#define ARRAY_SORTED_ARRAY

#include <iostream>
#include <algorithm>
#include "Error/Error.hpp"
#include "EArrayClass.hpp"
#include "EArray.hpp"
using namespace std;




namespace SortedArray_Exception
{
// class
};








enum OPEN_OR_CLOSE { OPEN = 13, CLOSE = 14 };
enum INDEX_LF { LEFT = 0, RIGHT = 1 };



template <typename T, typename K = int> // K e -0+
class SortedArray : public Error<SORTED_ARRAY>
{
public:
~SortedArray();
SortedArray(const SortedArray<T>& copy);
SortedArray();

void AddValue(const T& value);
void AddInterval(const T start, OPEN_OR_CLOSE op_1, const T end, OPEN_OR_CLOSE op_2);
void AddValues(const T* const values, K number);
void AddIntervals(const T* const intervals, OPEN_OR_CLOSE* op, K number);
K FindInterval(const T& value) const;
void FindInterval(const T& value, T* interval) const;
void FindInterval(const T& value, OPEN_OR_CLOSE* interval) const;

const EArray<T>* GetDataFromInterval(const K) const;
const OPEN_OR_CLOSE* GetOpenOrClose() const { return OpenOrClose; }
const T* GetInterval() const { return Interval; }
K GetNumberOfInterval() const { return NumberOfInterval; }

SortedArray<T,K>& operator=(const SortedArray<T,K>& right);
SortedArray<T,K> operator+(const SortedArray<T,K>& right);

class DataPointer
{
public:
~DataPointer() {}
DataPointer();
EArray<T>& operator*();
DataPointer operator++();
DataPointer operator++(int);
void operator()(K number_of_interval);

private:
EArray<T>* Pointer;
K AIndex;
};

protected:
OPEN_OR_CLOSE* OpenOrClose;
T* Interval;
K NumberOfInterval;


private:
EArrayClass<EArray<T> >* Data;

const EArrayClass<EArray<T> >* GetData() const { return Data; }

static const K DEFAULT_ERROR_NUMBER = (0);
};



template <typename T, typename K>
SortedArray<T,K>::~SortedArray()
{
delete Data;
delete[] OpenOrClose;
delete[] Interval;
}




template <typename T, typename K>
SortedArray<T,K>::SortedArray(const SortedArray<T>& copy):
NumberOfInterval(copy.GetNumberOfInterval())
{
OpenOrClose = new OPEN_OR_CLOSE[2*NumberOfInterval];
Interval = new T[2*NumberOfInterval];
Data = new EArrayClass<EArray<T> >(1);

(*Data) = (*copy.GetData());

const OPEN_OR_CLOSE* help_open = copy.GetOpenOrClose();
const T* help_interval = copy.GetInterval();

std::copy(help_open, &(help_open[2*NumberOfInterval - 1]), OpenOrClose);
std::copy(help_interval, &(help_interval[2*NumberOfInterval - 1]), Interval);
}




template <typename T, typename K>
SortedArray<T,K>::SortedArray():
NumberOfInterval(0)
{
OpenOrClose = new OPEN_OR_CLOSE[2*NumberOfInterval];
Interval = new T[2*NumberOfInterval];
Data = new EArrayClass<EArray<T> >(0);

/* (*Data) = (*copy.GetData());

const OPEN_OR_CLOSE* help_open = copy.GetOpenOrClose();
const T* help_interval = copy.GetInterval();*/
}



//******************************************************************************************************************
//********************************************Functions declaration*************************************************
//******************************************************************************************************************

//******************************************** public functions ****************************************************


template <typename T, typename K>
void SortedArray<T,K>::AddValue(const T& value)
{
K number_of_interval;
number_of_interval = FindInterval(value);
if(Error<SORTED_ARRAY>::ERROR() == true)
{
return;
}

((*Data)[number_of_interval - 1]).AddEnd(value);
}




template <typename T, typename K>
void SortedArray<T,K>::AddInterval(const T start, OPEN_OR_CLOSE op_1, const T end, OPEN_OR_CLOSE op_2)
{

T* help_interval = new T[2*NumberOfInterval + 2];
OPEN_OR_CLOSE* help_open = new OPEN_OR_CLOSE[2*NumberOfInterval + 2];

if(NumberOfInterval != 0)
{
K i;
for(i = 0; i < NumberOfInterval; i++)
{
help_interval[2*i + LEFT] = Interval[2*i + LEFT];
help_interval[2*i + RIGHT] = Interval[2*i + RIGHT];
help_open[2*i + LEFT] = OpenOrClose[2*i + LEFT];
help_open[2*i + RIGHT] = OpenOrClose[2*i + RIGHT];
}
}

help_interval[2*NumberOfInterval + LEFT] = start;
help_interval[2*NumberOfInterval + RIGHT] = end;
help_open[2*NumberOfInterval + LEFT] = op_1;
help_open[2*NumberOfInterval + RIGHT] = op_2;

delete[] Interval;
delete[] OpenOrClose;
Interval = help_interval;
OpenOrClose = help_open;
NumberOfInterval += 1;

EArray<T> help_array;
Data->AddEnd(help_array);
return;
}




template<typename T, typename K>
void SortedArray<T,K>::AddValues(const T* const values, K number)
{
K i;
for(i = 0; i < number; i++)
{
AddValue(values[i]);
}
}




template <typename T, typename K>
void SortedArray<T,K>::AddIntervals(const T* const intervals, OPEN_OR_CLOSE* op, K number)
{
K i;
for(i = 0; i < number; i++)
{
AddInterval(intervals[2*i + LEFT], op[2*i + LEFT], intervals[2*i + RIGHT], op[2*i + RIGHT]);
}
}




template <typename T, typename K>
K SortedArray<T,K>::FindInterval(const T& value) const
{
K i;
for(i = 0; i < NumberOfInterval; i++)
{
if((Interval[2*i + LEFT] < value && Interval[2*i + RIGHT] > value) || (Interval[2*i + RIGHT] > value && Interval[2*i + LEFT] < value))
{
return i+1;

} else if( (Interval[2*i + LEFT] == value && OpenOrClose[2*i + LEFT] == CLOSE) || (Interval[2*i+RIGHT] == value && OpenOrClose[2*i + RIGHT] == CLOSE))
{
return i+1;

}
}

SetError();
SetErrorValue(ANY_INTERVAL_FOUND);
return (DEFAULT_ERROR_NUMBER);
}




template <typename T, typename K>
void SortedArray<T,K>::FindInterval(const T& value, T* interval) const
{
K help_number_interval = FindInterval(value);
if(Error<SORTED_ARRAY>::ERROR() == true)
{
return;
}

interval[LEFT] = Interval[help_number_interval + LEFT];
interval[RIGHT] = Interval[help_number_interval + RIGHT];
}



template <typename T, typename K>
void SortedArray<T,K>::FindInterval(const T& value, OPEN_OR_CLOSE* interval) const
{
K help_number_interval = FindInterval(value);
if(Error<SORTED_ARRAY>::ERROR() == true)
{
return;
}

interval[LEFT] = Interval[help_number_interval + LEFT];
interval[RIGHT] = Interval[help_number_interval + RIGHT];
}



template <typename T, typename K>
const EArray<T>* SortedArray<T,K>::GetDataFromInterval(const K interval) const
{
return &((*Data)[interval - 1]);
}


//***************************************************************************************************
//**************************************************** DataInterval ********************************
//***************************************************************************************************

template <typename T, typename K>
SortedArray<T,K>::DataPointer::DataPointer():
AIndex(0)
{
Pointer = &((*Data)[0]);
}




template <typename T, typename K>
EArray<T>& SortedArray<T,K>::DataPointer::operator*()
{
return *Pointer;
}



template <typename T, typename K>
SortedArray<T,K>::DataPointer SortedArray<T,K>::DataPointer::operator++(int)
{
//
}



int main()
{
SortedArray<float> help;
float h[2];

help.AddInterval(10, CLOSE, 20, OPEN);
help.AddInterval(21, CLOSE, 30, CLOSE);
help.AddInterval(31, CLOSE, 40, OPEN);
help.AddValue(25);
help.FindInterval(12, h);
cout << h[0] << endl;
cout << h[1] << endl;
if(help.ERROR() == true)
{
cout << "ERROR" <<endl;
}
}

#endif

na radku 305 mi to zahlasi "SortedArray.cpp:305: error: expected constructor, destructor, or type conversion before ‘SortedArray’"
co delam spatne ?

Nahlásit jako SPAM
IP: 94.112.18.–
Reklama
Reklama
Anonymní uživatel
~ Anonymní uživatel
0 příspěvků
23. 5. 2011   #2
-
0
-

To Anonymní uživatel :
radek 306

Nahlásit jako SPAM
IP: 94.112.18.–
KIIV+42
God of flame
23. 5. 2011   #3
-
0
-

k cemu ze to trida ve tride?

vis o tom, ze se trida da nadefinovat i mimo a uvnitr jine se da dat deklarace typu?

Nahlásit jako SPAM
IP: 94.142.234.–
Program vždy dělá to co naprogramujete, ne to co chcete...
Anonymní uživatel
~ Anonymní uživatel
0 příspěvků
23. 5. 2011   #4
-
0
-

To KIIV :
nee ... ? ani nevim jak to myslis. Nemohl by jsi prosim napsat v kodu jak to myslis ?

Nahlásit jako SPAM
IP: 94.112.18.–
KIIV+42
God of flame
23. 5. 2011   #5
-
0
-

class trida1 {
...
};

class trida2 {
private:
trida1 promenna;
public:
...
}

Nahlásit jako SPAM
IP: 94.142.234.–
Program vždy dělá to co naprogramujete, ne to co chcete...
Anonymní uživatel
~ Anonymní uživatel
0 příspěvků
23. 5. 2011   #6
-
0
-

jooo ..to vim :) ... ja jsem jenom chtel zkusit, jeden figl pres strukturu v tride, ale pak jsem pomoci g++ prisel na to, ze muzu pristupovat jenom k statickym clenskym datum (je to tak ?)

Nahlásit jako SPAM
IP: 94.112.18.–
KIIV+42
God of flame
24. 5. 2011   #7
-
0
-

predpokladam ze to neco takoveho bude

Nahlásit jako SPAM
IP: 212.136.56.–
Program vždy dělá to co naprogramujete, ne to co chcete...
Grungy0
Super člen
24. 5. 2011   #8
-
0
-

To Anonymní uživatel : môžeš upresniť ako to myslíš k statickým?

Nahlásit jako SPAM
IP: 158.193.84.–
Prvý náznak hlúposti, je pocit geniality.
liborb
~ Redaktor
+18
Guru
24. 5. 2011   #9
-
0
-

Nejspíš tím myslí, že bez instance lze přistupovat pouze ke statickým metodám třídy.

Nahlásit jako SPAM
IP: 78.80.52.–
Grungy0
Super člen
24. 5. 2011   #10
-
0
-

a nešlo by to cez operátor prístupu?

napríklad SortedArray::DataPointer.AIndex
respektíve SortedArray<T,K>::DataPointer.AIndex (moc zo šablónami nerobím)

Nahlásit jako SPAM
IP: 158.193.84.–
Prvý náznak hlúposti, je pocit geniality.
liborb
~ Redaktor
+18
Guru
24. 5. 2011   #11
-
0
-

Tak operátor přístup musí použít tak jako tak a šablony do toho nemíchej, ty s tím nemají nic společného.

Nahlásit jako SPAM
IP: 78.80.52.–
tomas
~ Anonymní uživatel
511 příspěvků
24. 5. 2011   #12
-
0
-

Podobný problém som mal keď som robil Linked List s Iteratormi, stačí pridať kľúčove slovo typename tam kde SortedArray<T,K>::DataPointer je použité ako dátový typ (type)

template <typename T, typename K> 

typename SortedArray<T,K>::DataPointer SortedArray<T,K>::DataPointer::operator++(int)
{
//
}

http://www.cppreference.com/wiki/keywords/typename




class LinkedList
{
private:
struct _node ....
...
public:
...
class iterator // def v triede LinkedList (public)
{
private:
typename List<T>::_node * cur; // _node je struktura def v triede LinkedList (private)
public:
iterator();

typename List<T>::iterator& operator++(int);
bool operator==(typename List<T>::iterator& other)const;
T operator->();
};
...
template<typename T>
typename List<T>::iterator& List<T>::iterator::operator ++(int)
...
};

Nahlásit jako SPAM
IP: 46.150.222.–
Zjistit počet nových příspěvků

Přidej příspěvek

Toto téma je starší jak čtvrt roku – přidej svůj příspěvek jen tehdy, máš-li k tématu opravdu co říct!

Ano, opravdu chci reagovat → zobrazí formulář pro přidání příspěvku

×Vložení zdrojáku

×Vložení obrázku

Vložit URL obrázku Vybrat obrázek na disku
Vlož URL adresu obrázku:
Klikni a vyber obrázek z počítače:

×Vložení videa

Aktuálně jsou podporována videa ze serverů YouTube, Vimeo a Dailymotion.
×
 
Podporujeme Gravatara.
Zadej URL adresu Avatara (40 x 40 px) nebo emailovou adresu pro použití Gravatara.
Email nikam neukládáme, po získání Gravatara je zahozen.
-
Pravidla pro psaní příspěvků, používej diakritiku. ENTER pro nový odstavec, SHIFT + ENTER pro nový řádek.
Sledovat nové příspěvky (pouze pro přihlášené)
Sleduj vlákno a v případě přidání nového příspěvku o tom budeš vědět mezi prvními.
Reaguješ na příspěvek:

Uživatelé prohlížející si toto vlákno

Uživatelé on-line: 0 registrovaných, 80 hostů

Podobná vlákna

Třída ve třídě, C++ — založil Luu

String ve třídě — založil eidam1995

Funkce ve třídě — založil twigl

WinProc ve třídě — založil ingiraxo

Přístup ke třídě — založil Tom

Moderátoři diskuze

 

Hostujeme u Českého hostingu       ISSN 1801-1586       ⇡ Nahoru Webtea.cz logo © 20032016 Programujte.com
Zasadilo a pěstuje Webtea.cz, šéfredaktor Lukáš Churý