Developing.ru

Есть ещё замечание по коду. Везде делать проверку if (Owner==nullptr) и кидать исключение, не нужно. Достаточно сделать эту проверку в конструкторе итератора, ведь дальше Owner нигде в коде не меняется.

WinMain писал(а):Вариант моего контейнера с исключениями находится в этой теме.

 class TItem
 {
  friend class TList;
  friend class Iterator;
  private:
   TItem *Next;
  public:
   int Data;
 };
 private:
  TItem *First;
  TItem *Last;
 public:
  TList()
  {
   First=nullptr;
   Last =nullptr;
  }
  ~TList()
  {
   TItem *Next;
   for (Next=First->Next; Next!=nullptr; First=Next, Next=First->Next)
   {
    delete First;
   }
   Last=nullptr;
  }
  Iterator Insert (const Iterator &After, const int &Data)
  {
   TItem *Item;
   if (After.Owner==nullptr)
   {
    throw std::u32string(U"Адресация элемента для вставки неинициированным итератором.");
   }
   if (After.Owner!=this)
   {
    throw std::u32string(U"Адресация элемента для вставки итератором другого контейнера.");
   }
   Item=new (std::nothrow) TItem;
   if (Item==nullptr)
   {
    throw std::u32string(U"Ошибка выделения памяти по указателю Item в функции-члене Iterator TList::Insert(const Iterator &After, const int &Data)).");
   }
   Item->Data=Data;
   if (After.Pointer==nullptr)
   {
    if (Last!=nullptr)
    {
     Last->Next=Item;
    }
    Last=Item;
    Item->Next=nullptr;
   }
   if (First==nullptr)
   {
    First=Item;
   }
   return Iterator(this, Item->Next);
  }
  Iterator Begin()
  {
   return Iterator(this, First);
  }
  Iterator End ()
  {
   return Iterator(this, nullptr);
  }
  Iterator Find(const int &Value)
  {
   TItem *Item;
   for (Item=First; Item!=nullptr; Item=Item->Next)
   {
    if ((Item->Data)==Value)
    {
     return Iterator(this, Item);
    }
   }
   return Iterator(this, nullptr);
  }
};

Romeo писал(а):ведь дальше Owner нигде в коде не меняется. И, кстати, этот факт можно подчеркнуть, объявив поле вот так:

Код: Выделить всё

TList *const Owner;

Сионист писал(а):А как быть с конструктором итератора по умолчанию?

Сионист писал(а):Так что ли?:

Сионист писал(а):Нельзя, так как он меняется при присваивании.

Romeo писал(а):А зачем ты его вообще сделал? Он нигде не используется.

int main()
{
 TList List;
 int   i;
 TList::Iterator Iterator;
 Iterator=List.Begin();
 List.Insert(Iterator, 2);
 List.Insert(Iterator, 21);
 List.Insert(Iterator, 3);
 List.Insert(Iterator, 4);
 List.Insert(Iterator, 8);
 List.Insert(Iterator, 5);
 List.Insert(Iterator, 1);
 List.Insert(Iterator, 6);
 List.Insert(Iterator, 3);
 List.Insert(Iterator, 4);
 for (Iterator=List.Begin(); Iterator!=List.End(); ++Iterator)
 {
  std::cout<<*Iterator<<'\t';
 }
 Iterator=List.Find(8);
 (*Iterator)=104;
 for (Iterator=List.Begin(); Iterator!=List.End(); ++Iterator)
 {
  std::cout<<*Iterator<<'\t';
 }
 for (Iterator=List.Find(4); Iterator!=List.End(); Iterator=List.Find(++Iterator,4))
 {
  (*Iterator)=74;
 }
 for (Iterator=List.Begin(); Iterator!=List.End(); ++Iterator)
 {
  std::cout<<*Iterator<<'\t';
 }
 std::cout<<std::endl;
 return 0;
}

Как только ты поймёшь разницу между инициализацией и присваиванием, ты сразу же совершишь гигантский качественный скачок.

Я бы всё-таки рекомендовал для проброски исключения использовать отдельный класс-исключение, вместо класса-строки.

Сионист писал(а):

Код: Выделить всё

 TList::Iterator Iterator;
 Iterator=List.Begin();

 TList::Iterator Iterator = List.Begin();

Сионист писал(а): Ну это то разницу я понял 20 лет назад. Качественный скачок? Ну да был: я смог начать программировать не только на бейсике.

Сионист писал(а): All complete. Расскажите, что именно бросать в каждом случае. Строки предлагал WinMain, вот я его и спросил, правильно ли я его понял. Расскажите свой вариант, исправлю.

Не самый лучший пример, так как здесь можно (и даже нужно) написать вот так:
Код :
TList::Iterator Iterator = List.Begin();
В чём отличие объяснять? Это как раз ещё один камень в огород "инициализации и присваивания".

int main()
{ 
 TList List;
 int   i;
 TList::Iterator Iterator;
 for (Iterator=List.Begin(), i=0; i<10; ++Iterator, ++i)
 {
  std::cin>>*Iterator;
 }
 Iterator=List.Find(8);
 (*Iterator)=104;
 for (Iterator=List.Begin(); Iterator!=List.End(); ++Iterator)
 {
  std::cout<<*Iterator<<'\t';
 }
 for (Iterator=List.Find(4); Iterator!=List.End(); Iterator=List.Find(++Iterator,4))
 {
  (*Iterator)=74;
 }
 for (Iterator=List.Begin(); Iterator!=List.End(); ++Iterator)
 {
  std::cout<<*Iterator<<'\t';
 }
 std::cout<<std::endl;
 return 0;
}

int main()
{
 TList List;
 int   i;
 TList::Iterator Iterator;
 ...
 Iterator=List.Begin();
 List.Insert(Iterator, 2);
 List.Insert(Iterator, 21);
 List.Insert(Iterator, 3);
 List.Insert(Iterator, 4);
 List.Insert(Iterator, 8);
 List.Insert(Iterator, 5);
 List.Insert(Iterator, 1);
 List.Insert(Iterator, 6);
 List.Insert(Iterator, 3);
 List.Insert(Iterator, 4);
 for (Iterator=List.Begin(); Iterator!=List.End(); ++Iterator)
 {
  std::cout<<*Iterator<<'\t';
 }
 Iterator=List.Find(8);
 (*Iterator)=104;
 for (Iterator=List.Begin(); Iterator!=List.End(); ++Iterator)
 {
  std::cout<<*Iterator<<'\t';
 }
 for (Iterator=List.Find(4); Iterator!=List.End(); Iterator=List.Find(++Iterator,4))
 {
  (*Iterator)=74;
 }
 for (Iterator=List.Begin(); Iterator!=List.End(); ++Iterator)
 {
  std::cout<<*Iterator<<'\t';
 }
 std::cout<<std::endl;
 return 0;
}

void Extrems(TList List; TList::Iterator &Min, TList::Iterator &Max)
{
 TList::Iterator Item;
 if (List::Begin==List::End())
 {
  Min=List::End;
  Max=List::End;
 }
 else
 {
  for (Min=List::Begin(), Max=List::Begin(), Item=List::Begin(); Item!=List::end(); ++Item)
  {
   if ((*Min)>(*Item))
   {
    Min=Item;
   }
   if ((*Max)<(*Item))
   {
    Max=Item;
   }
  }
 }
}

Поля в конструкторе List у тебя присваиваются, поля в конструкторе Iterator - тоже.

Romeo писал(а):Я предлагаю внутри класса List сделать класс Exception. Его можно либо отнаследовать от std::exception, либо, если наследоваться ни от чего не хочется, то просто разместить внутри какое-нибудь поле для хранения дополнительной информации об ошибке. Это должна быть либо строка, либо вообще какой-нибудь enum.

Сионист писал(а): А если...

Альтернатива - декларировать в заголовке цикла то, что имеет смысл во всей функции, так как в ней записан только линейно-циклический алгоритм многократного перебора контейнера по сути одним и тем же итератором, со вставкой из поиска и модификации по сути по тому же самому итератору, а это приведёт к лишему дублированию декларации, да ещё и появится двухстрочный блок на пустом месте. Вторая альтернатива - пустая первая позиция в заголовке цикла, что хорошо лишь в случае, когда один цикл продолжает перебор изменяемой в цикле переменной, уже перебранной в предыдущем цикле, а здесь этого нет.

Или? Декларация между операциями конечно читается, но со спотыканием и слишком рано инициировать конкретным значением тоже плохо. Потому и присваивание вместо инициализации. А если итератор - это вообще out-параметр функции, но не in-параметр? Например...

Сионист писал(а):

Код: Выделить всё

void Extrems(TList List; TList::Iterator &Min, TList::Iterator &Max)

Сионист писал(а):Потому что так удобнее

Сионист писал(а):... и ни чего не мешает так делать.

Сионист писал(а): Инициализация в конструкторе повторяет сие синтаксис явного вызова конструктора предка. А часто ли он вообще используется? Даже в сумме для инициализации полей и для передачи части параметров конструктора конструктору предка его класса? А присваивание часто. Частое применение даёт меньше шансов переврать синтакис, к тому же синтаксис присваивания проще.

Сионист писал(а):Что за поле? Как кодировать в нём инфу о месте и характере ошибки? Как бросать? Как выводить в лог при перехвате?

class List
{
...
class Exception
{
public:
   enum class Type : int { Deref, Common };

   Exception(Type type) : m_type(type) {}

   std::string GetDescription() const
   {
      switch (m_type)
      {
         case Type: :D eref:
            return "Error of dereferencing";
         case Type::Common:
            return "Common error";
      }

      assert(false);
      return "";
   }

private:
   Type m_type;
};
...
class Iterator
{
...
   if (!Pointer) throw Exception(Exception::Type: :D eref);
...
};
...
};

int main()
{
    List list;
    List::Iterator it;

    try
    {
      *it;
    }
    catch (const List::Exception& ex)
    {
      std::cout << ex.GetDescription() << std::endl;
      return 1;
    }

    return 0;
}

А вот за это нужно бить, причём нещадно. List - только константной ссылкой и никак иначе!

Инициализация вызывается в любом случае. Если ты её не прописываешь явно, то для поля вызывается дефолтный конструктор. Зачем вызывать дефолтный конструктор и затем вызывать оператор присваивания, если можно сразу проинициализировать поле нужным значением? Если поле - объект тяжёлого класса, то разница в скорости выполнения может быть существенной. Скажешь, что для встроенных типов, таких, как указатели, профит будет мизерным? Да соглашусь. Но зачем отказываться от мизерного профита, если его можно добиться совсем не тратя сил?

int main()
{
 int *p(nullptr);
}

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

enum class Type : int { Deref, Common };

Набор ошибок, конечно, нужно расширить.

Сионист писал(а): Как раз в том и заковыка. Применять префиксные, но не постфиксные инкремент/декремент везде, где не требуется перед икрементом/декрементом вернуть старое значение модифицируемой переменной - оптимизация, на которую ничего не тратится. А вспоминать весь синтаксис явного вызова конструктора предка - это нифига не нулевые усилия. Да ещё и каждый раз гуглить его на всякий случай. Там ведь не просто скобки поставить, это не
...
Только что погуглил, там надо прописать вызов конструктора до фигурных скобок, поставить двоеточие, разделить запятыми.

Iterator() : Pointer(nullptr), Owner(nullptr)
{
}

Iterator() 
{
   Pointer = nullptr;
   Owner = nullptr;
}

Сионист писал(а): На плюсах пишу с 2001-го года, за всё время вызов конструктора предка в принципе мог применить раза три и раз пятьсот инициализацию полей. Присваивание же применяется в большем количестве за неделю.

Сионист писал(а): Что это за синтаксис? Где можно о нём прочитать?

Сионист писал(а): Я и эти коды ошибок не понял.

У тебя здесь нет никакого базового класса. Не путай вызов базового класса и инициализацию полей.

Сделаю предположение, что скорее всего писал по мелочам, например, небольшие утилитки для прикладных вычислений.

На самом деле, это крайне грустная статистика. Она говорит о том, что достаточно сложные арихитектурные решения со сложной иерархией классов ты либо никогда не реализовывал, либо реализовывал крайне редко.

Сионист писал(а):Я и не путаю, речь только об идентичности синтаксиса. Остальные переменные инициируются другим синтаксисом.

Сионист писал(а):Утилитами не занимаюсь вообще и самое маленькое, что я написал, заняло 5 месяцев.

Сионист писал(а):Трёхмерная модель свободно-вынужденной темпломагнитоэлектрогидродинамики достаточно сложна, фёст альпина запросила за более простой двумерный проект два миллиона, но при этом какая либо иерархия классов вне пользовательского интерфейса была не нужна в принципе, да и вообще весь ООП был по сути ограничен пользовательским интерфейсом.