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

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

 
Hledat
Rozšířené hledání ›
Nejnovější témata ve fóru
09:02, .NET Testing Lab for Honey and Honey Products - FARE LABS Pvt.…
08:39, Python Výběr pixelu klikem v zoomované oblasti [prohlížeč obrázku]
14:30, Funkcionální progr… Dummy smart a Kunstinteligenz
14:46, Python Používáte SQLAlchemy nebo pandas? pymysql
11:30, Funkcionální progr… Promotic
09:34, Software KAPEKA - zadní dvířka do woken
Stavba Laser Arény
Laser Game Brno

›

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.–
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
~ Moderátor
+43
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
~ Moderátor
+43
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
~ Moderátor
+43
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
560 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.–
 ← Zpět na seznam vláken  ← Zpět do Fóra
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.
-
 Zdrojový kód  Vložit obrázek  Video  Smajlíci
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, 6 hostů

Podobná vlákna

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

.NET

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

C / C++

Operator[] ve tride — založil fnenks

C / C++

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

C / C++

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

C / C++

Moderátoři diskuze

Chci se stát moderátoremcrazy

 

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