Привет всем. Я вот пытаюсь С++ изучить, написал следующий код, а он не работает, может кто поможет, буду очень благодарен.


#include <iostream>
#include <cstring>

class Katalog;
#pragma hdrstop
#pragma argsused
//---------------------------------------------------------------------------
class Katalog
{
int i = 0;
const int sz=10000;
string name_book[sz], name_autor[sz];
int summ_books[sz];
public:
void new_book()
{
std::cin>>name_book[i];
std::cin>>name_auror[i];
std::cin>>summ_books[i];
}
void console_books(string* book,string* autor,int* books,int* I)
{
for(int b=0; b<I;b++)
{
std::cout<<"Êíèãà: "<<name_book[i]<<" Àâòîð: "<<name_auror[i]<<" êîëè÷åñòâî ýêçåìïëÿðîâ: "<<summ_books[i];
}
}
}

int main(int argc, char* argv[])
{
Katalog kat = new Katalog();
if(std::cin=="Help")
{

}
elseif(std::cin=="New")
{
kat.new_book();
}
elseif(std::cin=="Window")
{
kat.console_books();
}
else
{
std::cout<<"Error? áëÿ-áëÿ-áëÿ-áëÿ";
}


return 0;
}

TAR>Привет всем. Я вот пытаюсь С++ изучить, написал следующий код, а он не работает, может кто поможет, буду очень благодарен.

TAR> elseif(std::cin=="New")

Не работает или не транслируется?

Здравствуйте, TARGRED, Вы писали:

TAR>Привет всем. Я вот пытаюсь С++ изучить, написал следующий код, а он не работает, может кто поможет, буду очень благодарен.

#include <iostream>
#include <cstring>

class Katalog;
#pragma hdrstop
#pragma argsused  //Компилятор Билдер? 
                       // а namespace std где?
//---------------------------------------------------------------------------
class Katalog
{
 int i = 0;    // нельзя
 const int sz=10000; //нельзя
 string name_book[sz], name_autor[sz]; //тем более нельзя
... // ну и дальше ошибок много

Не транслируется
Здесь показывает, что что-то не обьявленно.
class Katalog
{
int i = 0;
const int sz=10000;
string name_book[sz], name_autor[sz];
int summ_books[sz];

Hello, TARGRED!

T> Привет всем. Я вот пытаюсь С++ изучить, написал следующий код, а он не
T> работает, может кто поможет, буду очень благодарен.

Слишком много ошибок.

1. Используй теги форматирования
2. Уж постарайся, пости код без этих кракозяб
3. Переменная цикла b в самом цикле не используется
4. Никакого elseif в С++ нет.

и так далее и тому подобное...

Здравствуйте, TARGRED, Вы писали:

Ужасный у тебя стиль, однако...
TAR>Привет всем. Я вот пытаюсь С++ изучить, написал следующий код, а он не работает, может кто поможет, буду очень благодарен.

#include <iostream>
#include <cstring>
// Про namespace тебе написали уже... Здесь using namespace std; должно быть, чтобы ты ниже везде std:: не писал.
class Katalog;
#pragma hdrstop
#pragma argsused
//---------------------------------------------------------------------------
class Katalog
{
int i = 0; // Нельзя в классе объявлять ничего, кроме как статических констант
const int sz=10000; // Аналогично
string name_book[sz], name_autor[sz]; // Тем более
int summ_books[sz]; // Аналогично
/***********************
 *На твоем месте с массивами я бы сделал так:
 *...
 *enum { myEArrSize_ = 10000};
 *string name_book [myEArrSize_];
 *...
 ***********************/
public:
void new_book()
{
std::cin>>name_book[i];
std::cin>>name_auror[i];
std::cin>>summ_books[i];
}
void console_books(string* book,string* autor,int* books,int* I)
{
for(int b=0; b<I;b++)
{
std::cout<<"Êíèãà: "<<name_book[i]<<" Àâòîð: "<<name_auror[i]<<" êîëè÷åñòâî ýêçåìïëÿðîâ: "<<summ_books[i];
}
}
}

int main(int argc, char* argv[])
{
// Katalog kat = new Katalog(); // Неверно. Должно быть
Katalog* kat = new Katalog ();
if(std::cin=="Help")
{

}
elseif(std::cin=="New")
{
kat.new_book(); // kat у тебя указатель. Поэтому обращаешься не через "." к его членам, а через "->"
}
elseif(std::cin=="Window")
{
kat.console_books(); // аналогично
}
else
{
std::cout<<"Error? áëÿ-áëÿ-áëÿ-áëÿ";
}


return 0;
}

[ccode]
#include <iostream>
#include <cstring>

class Katalog;
#pragma hdrstop
#pragma argsused
//---------------------------------------------------------------------------
class Katalog
{
 int i = 0;
 const int sz=10000;
 string name_book[sz], name_autor[sz];
 int summ_books[sz];
 public:
   void new_book()
   {
       std::cin>>name_book[i];
       std::cin>>name_auror[i];
       std::cin>>summ_books[i];
   }
   void  console_books(string* book,string* autor,int* books,int* I)
   {
       for(int b=0; b<I;b++)
       {
           std::cout<<"Книга: "<<name_book[i]<<" Автор: "<<name_auror[b]<<" Количество экземпляров:"<<summ_books[b];
       }
   }
}

int main(int argc, char* argv[])
{
 Katalog kat = new Katalog();
 if(std::cin=="Help")
 {

 }
 else if(std::cin=="New")
 {
     kat.new_book();
 }
 else if(std::cin=="Window")
 {
      kat.console_books();
 }
 else
 {
      std::cout<<"Error";
 }


     return 0;
}
//---------------------------------------------------------------------------

[/ccode]

Компилятор билдер.
Что такое? // а namespace std где?

Почему так нельзя и как надо?
class Katalog
{
int i = 0;
const int sz=10000;
string name_book[sz], name_autor[sz];
int summ_books[sz];

Такие переменные надо в конструкторе инициализировать.

#include <iostream>
#include <cstring>

class Katalog;
#pragma hdrstop
#pragma argsused
//---------------------------------------------------------------------------
class Katalog
{
 public:
   Katalog()
   {
      int i = 0;
      enum { sz = 10000};
      string name_book[sz];
      string name_autor[sz];
      int summ_books[sz];
   }
   void Katalog::new_book()
   {
       std::cin>>name_book[i];
       std::cin>>name_auror[i];
       std::cin>>summ_books[i];
   }
   void  Katalog::console_books()
   {
       for(int b=0; b<I;b++)
       {
           std::cout<<"Êíèãà: "<<name_book[i]<<" Àâòîð: "<<name_auror[b]<<" Êîëè÷åñòâî ýêçåìïëÿðîâ:"<<summ_books[b];
       }
   }
}

int main(int argc, char* argv[])
{
 Katalog*     kat = new Katalog();
 if(std::cin=="Help")
 {

 }
 else if(std::cin=="New")
 {
     kat-> new_book();
 }
 else if(std::cin=="Window")
 {
      kat->console_books();
 }
 else
 {
      std::cout<<"Error ";
 }


     return 0;
}

Все равно не хочет работать. Вчем дело?

Hello, TARGRED!

T> Компилятор билдер.
T> Что такое? // а namespace std где?

T> Почему так нельзя и как надо?
T> class Katalog
T> {
T> int i = 0;
T> const int sz=10000;
T> string name_book[sz], name_autor[sz];
T> int summ_books[sz];

Можно я баналную вещь скажу? Купи книжку. Причем не по билдеру ни разу а простую человеческую по С++ — тут на сайте есть рецензии к книжкам. А искать ошибки в таком коде можно только из спортивного интереса — кто больше найдет. И не пиши сразу весь код. написал маленький кусок, убедился что компилируется, отладил, следующая итерация.

Здравствуйте, TARGRED, Вы писали:

Я ж говорю — нельзя прямо внутри объявления класса ничего объявлять, кроме как статических констант! Ты не можешь в классе написать "int i = 0;". Ты можешь так написать только в конструкторе!
И где у тебя еще ошибки? Хоть указал бы какие...

Здравствуйте, KHeLeKRoN, Вы писали:

KHL>Здравствуйте, TARGRED, Вы писали:

KHL>Я ж говорю — нельзя прямо внутри объявления класса ничего объявлять, кроме как статических констант! Ты не можешь в классе написать "int i = 0;". Ты можешь так написать только в конструкторе!
KHL>И где у тебя еще ошибки? Хоть указал бы какие...


Я ведь в конструкторе обьявил переменгные

class Katalog
{
 public:
   Katalog()  //это разве не конструктор?
   {
      int i = 0;
      enum { sz = 10000}; // здесь пишит error
      string name_book[sz];
      string name_autor[sz];
      int summ_books[sz];
   }

Звиняй, не увидел, что это конструктор... Но, в конструкторе их надо ИНИЦИАЛИЗИРОВАТЬ (присваивать значения, в этом духе). А в описании класса их надо объявлять. Вот реальный тебе пример, сейчас над ним работаю.
Длинноват, но ничего.

typedef void (*typeSortFuncPointer)    (int* arr, const int size);
typedef void (*typeFillFuncPointer)    (int* arr, const int size, int n);

#include "JournalItem.h"
#include "LogItem.h"
class CBencher
{
protected:
    unsigned int        myNTries_;
    int            myLastPrecision_;
    unsigned long long int*    myAverageIterationsArray_;
    unsigned long long int*    myAverageSwapsArray_;
    unsigned int*        myMaxIterationsArray_;
    unsigned int*        myMaxSwapsArray_;
    unsigned int*        myMinIterationsArray_;
    unsigned int*        myMinSwapsArray_;
    unsigned int        mySwaps_;
    unsigned int        myIterations_;
    CJournalItem*        myJournal_;
    int            myCurrentJournalSize_;
    int            myMaxJournalSize_;
    CLogItem*        myLog_;
    int            myCurrentLogSize_;
    int            myMaxLogSize_;
    
    typeFillFuncPointer    myFillFunction_;
    typeSortFuncPointer    mySortFunction_;

    void eraseArrays (void);
public:
    CBencher (void);
    typeSortFuncPointer        setSortFunction     (typeSortFuncPointer p);
    typeFillFuncPointer        setFillFunction     (typeFillFuncPointer p);
    void                bench             (const int maxsize, const int numGradations, const int precision);
    const unsigned long long int*    getAverageSwaps        (void)                        const;
    const unsigned long long int*    getAverageIterations    (void)                        const;
    const unsigned int*        getMaxSwaps        (void)                        const;
    const unsigned int*        getMaxIterations    (void)                        const;
    const unsigned int*        getMinSwaps        (void)                        const;
    const unsigned int*        getMinIterations    (void)                        const;
    CJournalItem&            getJournalItem        (const unsigned int nTr)            const;
    CLogItem&            getLogItem        (const unsigned int nTr)            const;
    inline void            increaseSwaps ()    { mySwaps_++; }
    inline void            increaseIterations ()    { myIterations_++; }
    virtual                ~CBencher (void);
};
CBencher currentBencher;

#include "Strng.h"
#include "ArrFillers.h"

CBencher :: CBencher ()
{
    myMaxLogSize_ = myCurrentLogSize_ = myMaxJournalSize_ = myCurrentJournalSize_ = 0;
    myLog_                = new CLogItem [0];
    myJournal_            = new CJournalItem [0];
    myNTries_            = 0;
    myLastPrecision_        = 0;
    mySortFunction_            = CK :: optimizedBInsertSort;
    myFillFunction_            = randomFill;
    myAverageIterationsArray_    = NULL;
    myAverageSwapsArray_        = NULL;
    myMaxIterationsArray_        = NULL;
    myMaxSwapsArray_        = NULL;
    myMinIterationsArray_        = NULL;
    myMinSwapsArray_        = NULL;
    mySwaps_            = 0;
    myIterations_            = 0;
}

CBencher :: ~CBencher ()
{
    eraseArrays ();
}

inline void CBencher :: eraseArrays ()
{
    delete [] myAverageIterationsArray_;
    delete [] myAverageSwapsArray_;
    delete [] myMaxIterationsArray_;
    delete [] myMaxSwapsArray_;
    delete [] myMinIterationsArray_;
    delete [] myMinSwapsArray_;
}

inline typeFillFuncPointer CBencher :: setFillFunction (typeFillFuncPointer p)
{
    typeFillFuncPointer t = myFillFunction_;
    myFillFunction_ = p;
    return t;
}

inline typeSortFuncPointer CBencher :: setSortFunction (typeSortFuncPointer p)
{
    typeSortFuncPointer t = mySortFunction_;
    mySortFunction_ = p;
    return t;
}

void CBencher :: bench (const int maxsize, const int numGradations, const int precision)
{
    srand (static_cast<unsigned int>(time (NULL)));
    if (!numGradations) throw "CBencher::bench (): Second parameter is zero.";
    int mn = maxsize/numGradations;
    int* arrayForSadizm = new int [maxsize];

    eraseArrays ();

    myAverageIterationsArray_    = new unsigned long long int [numGradations];
    myAverageSwapsArray_        = new unsigned long long int [numGradations];
    myMaxIterationsArray_        = new unsigned int [numGradations];
    myMaxSwapsArray_        = new unsigned int [numGradations];
    myMinIterationsArray_        = new unsigned int [numGradations];
    myMinSwapsArray_        = new unsigned int [numGradations];
    
    myFillFunction_ (arrayForSadizm, maxsize, 0);

    for (int i = 0, currentSize = mn; i < numGradations; i++, currentSize += mn)
    {
        myMaxSwapsArray_ [i] = myMaxIterationsArray_ [i] = 0;
        myMinSwapsArray_ [i] = myMinIterationsArray_ [i] = 32500;
        myAverageIterationsArray_ [i] = myAverageSwapsArray_ [i] = 0;
        for (int j = 0; j <    precision; j++)
        {
            mySortFunction_ (arrayForSadizm, currentSize);
            cout << ".";
            myFillFunction_ (arrayForSadizm, maxsize, 0);
            cout << ".";
            myAverageIterationsArray_ [i]    += myIterations_;
            myAverageSwapsArray_ [i]    += mySwaps_;

            myMaxSwapsArray_ [i]        > mySwaps_    ? NULL : myMaxSwapsArray_ [i]        = mySwaps_;
            myMaxIterationsArray_ [i]    > myIterations_ ? NULL : myMaxIterationsArray_ [i] = myIterations_;

            myMinSwapsArray_ [i]        < mySwaps_    ? NULL : myMinSwapsArray_ [i]        = mySwaps_;
            myMinIterationsArray_ [i]    < myIterations_ ? NULL : myMinIterationsArray_ [i] = myIterations_;
            
            mySwaps_ = myIterations_ = 0;
        }
        myAverageIterationsArray_ [i]    /= precision;
        myAverageSwapsArray_ [i]    /= precision;
    }
    if (myMaxLogSize_ == myNTries_)
    {
        CLogItem* buf = new CLogItem [myCurrentLogSize_];
        for (int i = 0; i < myCurrentLogSize_; i++)
            buf [i] = myLog_ [i];
        delete [] myLog_;
        myMaxLogSize_ = myCurrentLogSize_ + myCurrentLogSize_;
        myLog_ = new CLogItem [myMaxLogSize_];
        for (int i = 0; i < myCurrentLogSize_; i++)
            myLog_ [i] = buf [i];
        delete [] buf;
    }
    CLogItem tObject (myAverageSwapsArray_,    myAverageIterationsArray_,
                      myMinSwapsArray_,        myMinIterationsArray_,
                      myMaxSwapsArray_,        myMaxIterationsArray_,
                      numGradations);
    myLog_ [myCurrentLogSize_++] = tObject;
    cout << endl;
    delete [] arrayForSadizm;
    myLastPrecision_ = precision;
    myNTries_++;
}

inline const unsigned long long int* CBencher :: getAverageSwaps () const
{
    if (!myAverageSwapsArray_) throw "CBencher::getAverageSwaps (): Return of null pointer. Possible error.";
    return myAverageSwapsArray_;
}

inline const unsigned long long int* CBencher :: getAverageIterations () const
{
    if (!myAverageIterationsArray_) throw "CBencher::getAverageIterations (): Return of null pointer. Possible error.";
    return myAverageIterationsArray_;
}

inline const unsigned int* CBencher :: getMaxSwaps (void) const
{
    if (!myMaxSwapsArray_) throw "CBencher::getMaxSwaps (): Return of null pointer. Possible error.";
    return myMaxSwapsArray_;
}

inline const unsigned int* CBencher :: getMaxIterations (void) const
{
    if (!myMaxIterationsArray_) throw "CBencher::getMaxIterations (): Return of null pointer. Possible error.";
    return myMaxIterationsArray_;
}

inline const unsigned int* CBencher :: getMinSwaps (void) const
{
    if (!myMinSwapsArray_) throw "CBencher::getMinSwaps (): Return of null pointer. Possible error.";
    return myMinSwapsArray_;
}

inline const unsigned int* CBencher :: getMinIterations (void) const
{
    if (!myMinIterationsArray_) throw "CBencher::getMinIterations (): Return of null pointer. Possible error.";
    return myMinIterationsArray_;
}

inline CJournalItem& CBencher :: getJournalItem (const unsigned int nTry) const
{
    if (nTry > myNTries_) throw "CBnecher::getJournalItem (): Index out of bounds.";
    static CJournalItem tObject = myJournal_ [nTry];
    return tObject;
}

inline CLogItem& CBencher :: getLogItem (const unsigned int nTry) const
{
    if (nTry > myNTries_) throw "CBencehr::getLogItem (): Index out of bounds.";
    static CLogItem tObject = myLog_ [nTry];
    return tObject;
}

Понял?

Н>

Н> const int sz=10000; //нельзя
//Но можно 
static const int sz=10000;
Н>

PS там внизу в двух последних функциях недоработки.

Здравствуйте, KHeLeKRoN, Вы писали:

KHL>PS там внизу в двух последних функциях недоработки.

это я понял щютка

#include <iostream>
#include <cstring>

class Katalog;
#pragma hdrstop
#pragma argsused
//---------------------------------------------------------------------------
class Katalog
{
  int i,sz;
  int* name_book;
  int* name_autor;
  int* summ_books;
 public:
   Katalog()
   {
      i = 0;
      sz = 10000;
      name_book = new int[sz];
      name_autor = new int[sz];
      summ_books = new int[sz];
   }
   void Katalog::new_book()
   {

       std::cin>>name_book[i];
       std::cin>>name_autor[i];
       std::cin>>summ_books[i];

   }
   void  Katalog::console_books()
   {
       for(int b=0; b<i;b++)
       {
           std::cout<<"Êíèãà: "<<name_book[i]<<" Àâòîð: "<<name_autor[b]<<" Êîëè÷åñòâî ýêçåìïëÿðîâ:"<<summ_books[b];
       }
   }
}

int main(int argc, char* argv[])
{
 Katalog*     kat = new Katalog();
 if(std::cin=="Help")
 {

 }
 else if(std::cin=="New")
 {
     kat-> new_book();
 }
 else if(std::cin=="Window")
 {
      kat->console_books();
 }
 else
 {
      std::cout<<"Error ";
 }


     return 0;
}

Показывает, что слишком много типов указано и выдает ERROR
КАК БЫТЬ?

Здравствуйте, TARGRED, Вы писали:


TAR>

TAR>#include <iostream>
TAR>#include <cstring>

TAR>class Katalog;
TAR>#pragma hdrstop
TAR>#pragma argsused
TAR>//---------------------------------------------------------------------------
TAR>class Katalog
TAR>{
TAR>  int i,sz;
TAR>  int* name_book;
TAR>  int* name_autor;
TAR>  int* summ_books;
TAR> public:
TAR>   Katalog()
TAR>   {
TAR>      i = 0;
TAR>      sz = 10000;
TAR>      name_book = new int[sz];
TAR>      name_autor = new int[sz];
TAR>      summ_books = new int[sz];
TAR>   }
А в деструкторе ты эти динамические массивы удаляешь?
TAR>   void Katalog::new_book()
TAR>   {

TAR>       std::cin>>name_book[i];
TAR>       std::cin>>name_autor[i];
TAR>       std::cin>>summ_books[i];

TAR>   }
TAR>   void  Katalog::console_books()
TAR>   {
TAR>       for(int b=0; b<i;b++)
TAR>       {
TAR>           std::cout<<"Êíèãà: "<<name_book[i]<<" Àâòîð: "<<name_autor[b]<<" Êîëè÷åñòâî ýêçåìïëÿðîâ:"<<summ_books[b];
TAR>       }
TAR>   }
TAR>}

TAR>int main(int argc, char* argv[])
TAR>{
TAR> Katalog*     kat = new Katalog();
TAR> if(std::cin=="Help")
Если ты ввел тут New, то сравнение не прошло и перескакивается на следующий else if, но в очереди клавиатуры "New" уже нету, поэтому придется вводить New второй раз. А это - нихт гут.
TAR> {

TAR> }
TAR> else if(std::cin=="New")
TAR> {
     kat->> new_book();
TAR> }
TAR> else if(std::cin=="Window")
TAR> {
      kat->>console_books();
TAR> }
TAR> else
TAR> {
TAR>      std::cout<<"Error ";
TAR> }


TAR>     return 0;
TAR>}

TAR>

TAR>Показывает, что слишком много типов указано и выдает ERROR
TAR>КАК БЫТЬ?

#include <iostream>
#include <cstring>

class Katalog;
#pragma hdrstop
#pragma argsused
//---------------------------------------------------------------------------
class Katalog
{
  int i,sz;
  int* name_book;
  int* name_autor;
  int* summ_books;
 public:
   Katalog()
   {
      i = 0;
      sz = 1000;
      name_book = new int[sz];
      name_autor = new int[sz];
      summ_books = new int[sz];
   }

   Katalog ::   ~Katalog()
{
    eraseArrays ();
}

inline void Katalog :: eraseArrays ()
{
    delete [] name_book;
    delete [] name_autor;
    delete [] summ_books;

}

   void Katalog::new_book()
   {

       std::cin>>name_book[i];
       std::cin>>name_autor[i];
       std::cin>>summ_books[i];

   }
   void  Katalog::console_books()
   {
       for(int b=0; b<i;b++)
       {
           std::cout<<"Êíèãà: "<<name_book[i]<<" Àâòîð: "<<name_autor[b]<<" Êîëè÷åñòâî ýêçåìïëÿðîâ:"<<summ_books[b];
       }
   }
}

int main(int argc, char* argv[])
{
 Katalog*     kat = new Katalog();
 if(std::cin=="Help")
 {

 }
 else if(std::cin=="New")
 {
     kat-> new_book();
 }
 else if(std::cin=="Window")
 {
      kat->console_books();
 }
 else
 {
      std::cout<<"Error ";
 }


     return 0;
}

Все равно, таже ошибка вылазит.

Может так чего у билдера?