Разочарование

[For read only]

Когда писала махонькие школьные проги, всё получалось. Когда писала сортировку двусвязного списка - кайфовала от процесса. Но как только начались классы...У меня мозг отторгает всякую литературу :'( :'( :'(Скажите, может я зря связалась с программированием?
Подскажите пожалуйста книгу простую по С++. Только не Страуструпа!
Спасибо заранее.

[Алексей++]

For read only, нет, не зря. Тоже, кстати, себя похоже чувтствовал, когдас++стал изучать )))

Задавай вопросы - что непонятно ?

[For read only]

Алексей, спасибо) Не понятно много чего...

вот например, у меня прога такого вида:

Код:

struct List
{	string inf;
	List* next;
	List* prev;
};

void Read(List *&head,List *&tail,int n)
{
...
}

void Print (List *head)
{
...
}

void Sort (List *&head, List *&tail, int n)
{
...
}
void main()
{
...
}

если я буду делать класс "Список", то у меня будет примерно так:

Код:

class List 
{
        string inf;
	List* next;
	List* prev;
void Read(List *&head,List *&tail,int n)

...
void Print (List *head)
...

void Sort (List *&head, List *&tail, int n)
...
}

я права?

[For read only]

а точнее, вот так:

Код:

class List 
{
        public:string inf;
	public:List* next;
	public:List* prev;
public:void Read(List *&head,List *&tail,int n)

...
public:void Print (List *head)
...

public:void Sort (List *&head, List *&tail, int n)
...
};
void main()
{
	List* head = NULL;
	List* tail = NULL;
	List*A;
	int n;
cin>>n;
A=new (List);
A->Read (head,tail,n);
A->Sort(head,tail,n);
A->Print(head);
}

это работает. но чует моё сердце, очень криво)))
там наверное нужно после себя удалять, я же кучу памяти выделяла по ходу выполнения, так?
я дописала public, только потому что компилятор ругался.эти все public/private/protected... это типо локальных-глобальных переменных, да? откуда-то видно, откуда-то нет?

[Алексей++]

полагаю, имелось в виду следующее

Код:

class List 
{
	string inf;
	List* next;
	List* prev;
public:
	void Read(List *&head,List *&tail,int n)
	{
		...
	}

	void Print (List *head)
	{
		...
	}

	public:void Sort (List *&head, List *&tail, int n)
	{
		...
	}
};

void main()
{
	List* head = NULL;
	List* tail = NULL;
	List*A;
	int n;
	cin>>n;

	//выделение памяти из кучи
	A=new List[n];

	A->Read(head,tail,n);
	A->Sort(head,tail,n);
	A->Print(head);

	//удаляем выделенную память обратно в кучу!!!
	delete [] A;
	A=0;
}

но как это всё работает, действительно загадка

Начинаешь использовать классы, пользуйся их преимуществами.

Где у тебя, скажем, конструктор ? Деструктр ?

[For read only]

я хз, что это такое...но щас разберусь)

[Алексей++]

давай, разберись ) Полезная штука

[Finch]

Страуструп это не учебник, а скорее справочник по языку. Я лично изучал язык по книге Х.М. Дейтел П. Дж. Дейтел "Как программировать на С++". Но это только язык. Примерно как, чтобы выучить английский, недостаточно выучить словарный запас слов, нужно также учить и структуру языка, как эти слова связывать, как из них строить предложения, выражать свои мысли. Приучать свои уши распозновать речь других людей. Так же и в программировании, недостаточно изучить сам язык, нужно также изучать алгоритмы, стандартные методы решения стандартных задач (паттерны программирования), библиотеки и так далее. И уверяю тебя, что конечной точки в этом пути не видно. Готова ли к постоянному изучению, или при первом же припятствии ты готова все бросить с криком "Это слишком сложно для меня"?

[RXL]

Думаю, что это не совсем корректная попытка перевода из C и C++. Прежде всего, отпадает нужда в параметре head - следует использовать указатель this. В остальном логика не меняется.

[For read only]

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

[Finch]

Offtopic:

Ну жизнь вредна, от этого умирают.

Поставлю в угол.

А если серьёзно, то для изучения тебе нужно наверно найти опытного наставника. Который будет тебя вести через терни к звездам. Ну и конечно начать писать код. Стараться приучить себя писать его по правилам.

[For read only]

Ну код я пишу, и он даже работает) В алгоритмах проблем не возникает. Проблемы начались, с тех пор как перешла с Паскаля на Си. 
Вот например, что правильнее использовать - потоки или scanf/printf? Чёрт его знает, все говорят по разному. Глаза разбегаются...

[Finch]

Что удобнее для тебя в данный момент .  scanf/printf это наследство от С. ׁПотоки это уже С++. И в принципе на этом не должно быть больших заморочек. Язык С/С++ очень богат в формовыражении и я лично до сих пор до конца не знаю всех тонкостей языка и иногда меня ставит в тупик, та или иная конструкция. Но это лично для меня не повод для разочерования

[For read only]

Я вообще не отличаю где С, а где С++...такая каша в голове))

[Finch]

Ну основное отличие С от С++ это классы и шаблоны. Ну и ешё несколько облегчен синтаксис языка. В стандарт добавлены новые библиотеки. Но на данном этапе в принципе на этом не стоит заморачиваться. Просто изучай и закрепляй синтаксис языка. Наслаждайся. Когда достигнеш некоторого уровня знаний, тогда по желанию можеш посмотреть и различия в языках. Не все сразу. Постепенно, шаг за шагом.

[Dimka]

Но как только начались классы...У меня мозг отторгает всякую литературу :'( :'( :'(Скажите, может я зря связалась с программированием?
Подскажите пожалуйста книгу простую по С++. Только не Страуструпа!

C++ тут ни при чём. Читать нужно книжки по ООП с элементами C++, а не книжки по C++ с элементами ООП. Потому что это иная парадигма программирования, соответственно, другое мышление.

На какой специальность училась/учишься? (Насколько основательна подготовка в программировании?)

Я своих студентов обучаю ООП в следующем учебно-методическом порядке, но он основан на том, что предварительно студенты хорошо разобрались с алгоритмическим структурным программированием:

1) Алгоритмы и исполнители алгоритмов. Модальная разница между обычным текстом (описывающим) и текстом алгоритма (предписывающим). Структура предложения языка (подлежащее, сказуемое, определения и т.д.) и структура выражения на языке программирования (исполнитель = подлежащее, операция = сказуемое, определения = параметры). Отсутствие подлежащего в языках структурного программирования, где исполнителем алгоритма является компьютер. Возможность построения таких языков программирования, в которых до написания алгоритмов описывают "удобных" исполнителей.

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

3) Системы объектов, структурные отношения (ассоциации, агрегации, композиции). Решение задач как распределение ответственности между исполнителями, CRC-карточки и средства UML, значение инкапсуляции. Состояние системы, логическое и фактическое состояния, транзакции. Приёмы программирования на языках программирования.

4) Абстрактное и конкретное в жизни и в программировании. Проблемы абстракций в строго типизированных языках. Порождающие типы (шаблоны) и параметризированные классы - способы решения задач. Обобщение классов, наследование и делегирование, полиморфизм - способы решения задач. Влияние на полиморфизм того, что классы являются АТД: раннее и позднее связывание, виртуальные методы. Множественное наследование и его недостатки. Абстрактные методы, абстрактные классы, интерфейсы. Интерфейсы как контракты объекта по отношению к другим объектам. Интерфейсы как роли объектов в ассоциациях, агрегациях, композициях.

5) Методология. Методология инженерной деятельности. Методологии в программировании. Методики ОО анализа и проектирования, логический порядок работы. UML. Шаблоны проектирования.

Советую изучать ООП в этом порядке.

[Джон]

100% Согласен с Димкой. С++ просто один из представителей, кстати не самый яркий, языков с поддержкой ООП парадигмы.

For read only, может для тебя будет немного проще понять проблематику и необходимость ввода объектов на каком-нить примере? Без непосредственной реализации в коде?
Представь, что тебе требуется сделать программу рисования и редактирования графических фигур (треугольник, круг, прямоугольник, линия). Какое решение возможно без ООП? И как это можно решить в ООП, связав данные и методы их обработки в один тип (класс, объект ...)? На этом же примере можно хорошо рассмотреть преимущества, которые даёт, например, наследование.

[Dimka]

Джон, да можно и со списком.

For read only,
1) Рассматриваем список вообще как нечто целое. Нам пока не важно, как он устроен, нам важно понять, как им пользоваться. Зачем он вообще нужен в программе.

Дальше надо обратить внимание на разницу между структурным программированием и ООП. Для структурного программирования список - лишь "пассивная" структура данных. Мы себя спрашиваем: "Как мы будем обрабатывать список?" - т.е. какие процедуры обработки списка нам нужно написать.

В ООП несколько другой подход. Мы себя спрашиваем: "Какие задачи/функции обработки мы ПОРУЧИМ решать списку?" - т.е. список в ООП представляет собой активный, самостоятельно что-то делающий объект, которому мы можем поручить решать какие-то задачи (тогда у объекта появятся методы решения этих задач).

Судя по приведённому перечню, это задачи: загрузки данных с клавиатуры (Read), вывода данных на экран (Print), сортировки (Sort).

2) Далее надо подумать о том, свойственно ли списку как сущности чтение с клавиатуры и вывод на экран? Что вообще такое список? Список - это хранитель последовательных единиц данных - элементов списка. Функция хранения данных и функции ввода/вывода - это разные функции. Для списка ввод представляет собой добавление новых элементов списка. Вывод - это последовательный обход элементов списка. Сортировка - это переупорядочивание элементов списка.

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

Пока вернёмся к операциям со списком.

Ввод - операция добавления единицы хранения в список.

В структурном программировании мы бы записали операцию:

Код: (C++)

addDataToList(myString, list);

Читается как "Добавить мою строчку в список". Но тут мы не обсуждаем, КТО будет добавлять - понятно, что это всё делает компьютер как исполнитель нашего алгоритма. Тут у нас есть сказуемое - операция, и дополнения - параметры, но нет подлежащего.

В ООП мы должны поручить списку добавить новую единицу хранения в список. На языке программирования это будет выглядеть как:

Код: (C++)

list.addData(myString);

Читается буквально как: "Список, добавь мою строчку". Здесь "список" - подлежащее, тот исполнитель, которому мы поручаем выполнить операцию, наш объект "list"; "добавь" - операция, которую, с одной стороны, может выполнить исполнитель, и которую, с другой стороны, мы поручаем выполнить исполнитею (элемент интерфейса исполнителя), это метод "addData"; операция выполняется по отношению к единице хранения - строчке, которая является в предложении - дополнением, в коде - параметром операции, строчка "myString".

Тогда в программе операция чтения данных и сохранения их в списке будет выглядеть, например, как:

Код: (C++)

string myString = "";
do
 {
  getline(cin, myString);
  if(myString != "")
   {
    list.addData(myString);
   }
 }
while(myString != "")

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

Код: (C++)

list.beginIteration();
string myString = "";
while(list.getNextData(myString))
 {
  cout << myString << endl;
 }

Здесь у списка есть операция "getNextData", которая помещает в переданную по ссылке переменную myString очередной элемент данных, а в качестве результата возвращает true, если есть следующий элемент данных, и false, если больше ничего нет. Для того, чтобы можно было воспользоваться этим способом несколько раз, добавлена операция "beginIteration", которая поручает списку "забыть", где он остановился, соответственно, следующая операция получения данных начнётся с начала списка.

Итого у нас получился объект "список", обладающий следующим интерфейсом (видимым пользователю набором операций):

Код: (C++)

class List
 {
  public:
   List();
   ~List();
   // Ввод
   void addData(string &data);
   // Вывод
   void beginIteration();
   bool getNextData(string &data);
   // Сортировка
   void sort();
 };

Обрати внимание, что нигде в этих операциях нет ссылок на элементы списка, указатели "следующий" и "предыдущий" и т.д. Т.е., вообще говоря, мы можем вместо "List" (список), написать "BinaryTree" (бинарное дерево), и ничего не изменится (разве что, операция сортировки будет не нужна). Вот это вот свойство сокрытия особенностей внутреннего устройства (реализации) называется инкапсуляцией.

3) Элемент списка - это хранитель одной единицы данных, а также вспомогательной информации, позволяющей встроить элемент в список. Вспомогательная информация - это ссылки на следующий и предыдущий по списку элементы списка. Получаем класс со следующим интерфейсом:

Код: (C++)

class ListItem
 {
  public:
   ListItem();
   // Операции с указателями
   ListItem *getNextItem();
   ListItem *getPreviousItem();
   void setNextItem(ListItem *item);
   void setPreviousItem(ListItem *item);
   // Операции с данными
   string &getData();
   void setData(string &data);
 };

4) Ну и теперь остаётся всё это наполнить "особенностями реализации" - получаем:

Код: (C++)

class ListItem
 {
  private:
   string data;
   ListItem *nextItem;
   ListItem *previousItem;
  public:
   ListItem():
     data(""), nextItem(NULL), previousItem(NULL)
    {}
   // Операции с указателями
   ListItem *getNextItem() { return this->nextItem; }
   ListItem *getPreviousItem() { return this->preivousItem; }
   void setNextItem(ListItem *item) { this->nextItem = item; }
   void setPreviousItem(ListItem *item) { this->previousItem = item; }
   // Операции с данными
   string &getData() { return this->data; }
   void setData(string &data) { this->data = data; }
 };

class List
 {
  private:
   ListItem *head;
   ListItem *tail;
   ListItem *current;
  public:
   List():
     head(NULL), tail(NULL), current(NULL)
    {}
   ~List()
     {
      while(this->head != NULL)
       {
        ListItem *item = this->head;
        this->head = this->head->getNextItem();
        delete item;
       }
     }
   // Ввод
   void addData(string &data)
    {
     ListItem *item = new ListItem();
     item->setData(data);
     item->setPreviousItem(this->tail);
     if(this->tail != NULL)
      {
       this->tail->setNextItem(item);
      }
     this->tail = item;
     if(this->head == NULL)
      {
       this->head = item;
      }
    }
   // Вывод
   void beginIteration()
    {
     this->current = this->head;
    }
   bool getNextData(string &data)
    {
     if(this->current == NULL)
      {
       return false;
      }
     else
      {
       data = this->current->getData();
       this->current = this->current->getNextItem();
       return this->current != NULL;
      }
    }
   // Сортировка
   void sort()
    {
     // Алгоритм сортировки списка.
    }
 };

Остаётся реализовать сортировку, основную программу и вышеописанные функции чтения с клавиатуры и вывода на экран.

[For read only]

Спасибо огромное, я даже не ожидала, что кто-то откликнется!)

собсно, я накропала такой код:

Код:

#include <iostream>
#include <conio.h>
#include <string>
#include <cstring>
using namespace std;
class List 
{private:
    string inf;
	List* next;
	List* prev;
public:
void InitList (List *&Head,List *&Tail,List *&a) 
{
Head=Tail=NULL;
	a=new List;
}
//---------------------------------------------//
void Read(List *&head,List *&tail,int n) 
{List* ptrLast = NULL;
string item;
int i;
cout<<"Vvedite elementy"<<endl;
for (i=1;i<=n;i++)
{
cin>>item;
List* ptr=new List;
ptr->inf=item;
ptr->next=NULL;
tail=ptr;
   if (head==NULL)
       {
         head=ptr;
         ptr->prev=NULL;
         ptrLast=ptr;
       }
  else
       {
         ptr->prev=ptrLast;
         ptrLast->next=ptr;
         ptrLast=ptr;
       }
  }
}
//---------------------------------------------//
void Print (List *head)
{
	List* ptr=new List;
cout<<endl;
	if (head == NULL)
	{cout<<"СПИСОК ПУСТ !!";}
			
ptr = head;
	while (1)
	{
	cout<<ptr->inf<<" ";
	if (ptr->next == NULL) break;
	ptr = ptr->next;
	}
	}
//---------------------------------------------//
void Sort (List *&head, List *&tail, int n)//сортирока простым пузырьком
{
List*  D=new List;
List* U=new List;
List* ptr=new List;
int t,j;
if (n>2)
{
for (t=n;t>1;t--)
{
U=head;
    for (j=1;j<t;j++)
      {
		      ptr=U->next;
           if (U->inf>ptr->inf)
                {
			                ptr=U;
                   if (j==1)
                     {
                   	   D=ptr->next;
					   D->next->prev=ptr;
					   ptr->next=ptr->next->next;
					   D->next=ptr;
					   D->prev=NULL;
					   ptr->prev=D;
						   head=D;
                      }
                   else 
                   if (j==n-1)
                     {
                   	   D=ptr->next;
					   ptr->next=NULL;
					   ptr->prev->next=D;
					   D->prev=ptr->prev;
					   ptr->prev=D;
					   D->next=ptr;
					   tail=ptr;
                      }
                   else 
                     {
					  D=ptr;
                       ptr->prev->next=ptr->next;
					   ptr->next->prev=ptr->prev;
					   ptr=ptr->next;
					   ptr->next->prev=D;
					   D->next=ptr->next;
					   D->prev=ptr;
					   ptr->next=D;
				   }
				   U=U->prev;
 }
     U=U->next;
      }
}
}
else
if (n==2)
{
	head->next=NULL;
	head->prev=tail;
	tail->next=head;
	tail->prev=NULL;
	D=head;
	head=tail;
	tail=D;
}
}
};
//---------------------------------------------//
void main()
{
	List* head,*tail,*A;
	int n;
cout<<"Vvedite N"<<endl;
cin>>n;
A->InitList(head,tail,A);
A->Read (head,tail,n);
A->Sort(head,tail,n);
A->Print(head);
cout<<endl<<"press any key"<<endl;
getch();
}	

и у меня сразу появились вопросы.
1)а зачем там конструктор? зачем он вообще, он же вроде есть по дефолту
2) почему Visual Studio разрешает делать void main, a под линуксом нельзя?
3) почему когда я делаю в каждой функции в конце delete ptr, он некорректно работает? или не надо вообще их трогать?
и
4) не совсем поняла про список и отдельный элемент списка...почему нельзя сделать как у меня?


Блин, я даже вопросы корректно сформулировать не могу)

[For read only]

Кажется поняла насчёт п.4 !
тогда и конструктор оказывается к месту. попробую переписать...
Но всё равно хочу услышать разъяснения)

1) Алгоритмы и исполнители алгоритмов. Модальная разница между обычным текстом (описывающим) и текстом алгоритма (предписывающим). Структура предложения языка (подлежащее, сказуемое, определения и т.д.) и структура выражения на языке программирования (исполнитель = подлежащее, операция = сказуемое, определения = параметры). Отсутствие подлежащего в языках структурного программирования, где исполнителем алгоритма является компьютер. Возможность построения таких языков программирования, в которых до написания алгоритмов описывают "удобных" исполнителей.

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

3) Системы объектов, структурные отношения (ассоциации, агрегации, композиции). Решение задач как распределение ответственности между исполнителями, CRC-карточки и средства UML, значение инкапсуляции. Состояние системы, логическое и фактическое состояния, транзакции. Приёмы программирования на языках программирования.

4) Абстрактное и конкретное в жизни и в программировании. Проблемы абстракций в строго типизированных языках. Порождающие типы (шаблоны) и параметризированные классы - способы решения задач. Обобщение классов, наследование и делегирование, полиморфизм - способы решения задач. Влияние на полиморфизм того, что классы являются АТД: раннее и позднее связывание, виртуальные методы. Множественное наследование и его недостатки. Абстрактные методы, абстрактные классы, интерфейсы. Интерфейсы как контракты объекта по отношению к другим объектам. Интерфейсы как роли объектов в ассоциациях, агрегациях, композициях.

5) Методология. Методология инженерной деятельности. Методологии в программировании. Методики ОО анализа и проектирования, логический порядок работы. UML. Шаблоны проектирования.

Советую изучать ООП в этом порядке.

Сколько страшных слоооов '(

[Dimka]

4) не совсем поняла про список и отдельный элемент списка...почему нельзя сделать как у меня?

Почему нельзя? Если ты седелала, и это работает.

Но твоё решение реализовано в духе структурного программирования. Класс там так - "раз попросили, то сделали", ООП там нет. И нет его там потому, что ты не знаешь, что это такое, не понимаешь, зачем это и как этим пользоваться.

Но этому ты, вроде бы, и собираешься научиться?

[4y4z]

Подскажите пожалуйста книгу простую по С++. Только не Страуструпа!

Найти аналог учебника от Кернигана и Ричи для приплюснутого Си нелегко, но можно попробовать с книги Давыдова "Программирование и основы алгоритмизации". Несмотря на то, что многое покажется повторением уже пройденного, но с учетом акцента сделанного на использование именно С++, материал будет полезен не только для новичков.

[For read only]

так лучше? =)

Код:

#include <iostream>
#include <string>
#include <cstring>
using namespace std;

class List_Item;

class List
{
	List_Item *head;
	List_Item *tail;
	int N;
public:
	List()
	{
		head=tail=0;
		N=0;
	}
	void Add_item_to_head(string item);
	void Print_list();
	void Sort_list();
	void Swap_with_prev(List_Item *&c);
};

class List_Item
{
	List_Item *next;
	List_Item *prev;
	string inf;
	friend class List;

public:
	List_Item(string i)
	{
		prev=next=0;
		inf=i;
	}

	List_Item()
	{
		prev=next=0;
	}
};

void List::Add_item_to_head(string item)
{
	List_Item *r=new List_Item; // где удаляется этот объект?
	r->inf=item;
	if(head)
	{
		head->next=r;
		r->prev=head;
		head=r;
	}
	else
	{
		head=r;
		tail=r;
	}
	N++;
}

void List::Print_list()
{
	List_Item *r=new List_Item; // где удаляется этот объект?
	r=tail;
	while(r)
	{
		cout<<r->inf<<' ';
		r=r->next;
	}
	cout<<endl;
}

void List::Swap_with_prev(List_Item *&c)
{
	if (c->prev)
	{
		List_Item *d=new List_Item; // где удаляется этот объект?
		d=c->next;
		c->next=c->prev;
		c->prev=c->next->prev;
		if (c->prev)
		{
			c->prev->next=c;
		}
		else
		{
			tail=c;
		}
		c->next->prev=c;
		c->next->next=d;
		if (d)
		{
			d->prev=c->next;
		}
		else
		{
			head=c->next;
		}
		c=c->next;
	}
}

void List::Sort_list()
{
	List_Item *u=new List_Item;  // где удаляется этот объект?
	int i,j;
	for (i=N-1;i>=1;i--)
	{
		u=tail;
		for (j=1;j<=i;j++)
		{
			u=u->next;
			if (u->inf<u->prev->inf)
				Swap_with_prev(u);
			//this->Print_list();
		}

	}
}

int main()
{
	int i,n=0;
	string s;
	List my_list;
	cout<<"Vvedite N"<<endl;
	cin>>n;
	cout<<endl<<"Vvedite elementy"<<endl;
	for (int i=1;i<=n;i++)
	{
		cin>>s;
		my_list.Add_item_to_head(s);
	}
	my_list.Sort_list();
	my_list.Print_list();
	return 0;
}

[Sla]

For read only, хреново
ни одного комментария

[For read only]

По-моему всё наглядно) имена говорящие
это двусвязный список с сортировкой обычным пузырьком

[RXL]

For read only, как известно, в красиво выглядящем тексте меньше ошибок и он лучше читается. Приучи себя форматировать код и писать комментарии. Поверь, через месяц-другой ты не вспомнишь, что и зачем писал. Другие программисты тоже не захотят читать такой некрасивый и некомментированный код - время свое жалко же. А еще, посмотри принятые для тех или иных языков и сред стили именования - тоже полезно для читаемости текста.

[Джон]

так лучше? =)

For read only, хреново

Очень хреново. Немного подправил форматирование... Такое ощущение, что ты совсем не понимаешь, что пишешь. Тривиальная ф-я пробегания по списку - Print_list()... Это же катастрофа!!!

Сколько раз отработает твой цикл после комбинации r=tail; r=r->next; ?

А Add_item_to_head для случая когда head уже существует? Что это за бред:

      head->next=r;  // здесь добавляется элемент ПОСЛЕ head, а не в head, как на то указывает ф-я
      r->prev=head;  // здесь тоже - замыкается двойной список
      head=r; // а здесь вдруг head становится новым элементом

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

зы типичный случай подгонки результата под ответ

[Вад]

Кстати, вопрос чисто по структуре типов: а какие есть причины в данном случае, чтобы класс List_Item описывать в глобальной области видимости? Он ещё где-то, кроме внутренностей списка, нужен?

[Dimka]

Вад, это, наверно, потом как-нибудь.

Сейчас он хотя и виден, но никакого вменяемого интерфейса не имеет (т.е. никто посторонний ничего полезного с ним не сделает), но зафренжен для списка. Проектирование, конечно, неудачное, но для начала сгодится.

For read only, проект лучше, но не совершенство И в реализации ошибки есть.

[For read only]

Джон, я тестила, всё работает и даже на крайних случаях)
подгонкой результата под ответ я никогда не занималась.
а что не так с Print_list() ?  Она по-идее распечатывает список с хвоста к голове, соответственно цикл отработает столько раз, сколько элементов в списке

И в реализации ошибки есть.

а где? я не вижу =)