Серьезные проблемы с связным списком. с++

[MrQuestion]

#include <iostream>
using namespace std;

class spisok // Создали класс
{
      public:
             int a,b; // Создали полезные данные
             
             spisok* next; // Создали указатель на следующий объект в списке
};

spisok* head = 0; // Создали начало списка, ни на что не указывающее.

void addelement()
{
     spisok* current = new spisok; // Здесь создали новый объект.
     
     cin >> current->a;
     cin >> current->b; // Забили поля объекта полезными данными.
     
     current->next = 0; // Забили в указатель текущего объекта нуль. Указатель текущего объекта ни на что не указывает.
     
     if(head == 0) // Если в списке нет адреса какого либо объекта...
     {
             head = current; // ... верх списка указывает на текущий объект.
     }
     
     else // Если head на что то указывает
     {
         spisok* temp = head; // Создаем новый указатель, который указывает на начало списка. Т.е. на нуль. 
         while(temp->next != 0) temp = temp->next;
            // Пока указатель next указателя temp не указывает на нуль, temp указывает на  temp->next.
                Но чему изначально равен temp->next?
         temp->next=current; // Указатель next указателя temp указывает на текущий объект.
                     Каким образом осуществлен проход по списку?
     }
}
     
int main()
{
    int value = 0;
    while(value<5)
    {
              addelement();
              value++;
    };
    
    spisok* current = head; // Создали указатель на начало списка. Теперь текущий объект указывает на head, 
                                а т.к. head ни на что не указывает, то и current ни на что не указывает.
    while(current!=0) // Пока текущий объект не указывает на нуль, выполнять цикл. Но текущий объект как раз указывает на нуль.
    {
            cout << current->a << " " << current->b << endl;
            current = current->next;
    }            
    system("pause");
    return 0;
}

Здравствуйте. Никак не могу разобраться со связным списком. Все основные вопросы в моих же собственных комментариях к программе. Основной интерес вызывает тот кусок, что идет после else. Буду благодарен за помощь и подробные объяснения.

[eoln]

while(temp->next != 0) temp = temp->next;
 // Пока указатель next указателя temp не указывает на нуль, temp указывает на  temp->next. 
Но чему изначально равен temp->next?

если
temp = head
значит
temp->next = head->next
то есть первоначально
temp->next = указатель на второй добавленный элемент списка (или на ноль, если список состоит только из одной головы)

spisok* current = head; 
// Создали указатель на начало списка. Теперь текущий объект указывает на head, а т.к. head 
ни на что не указывает, то и current ни на что не указывает.

глобальный head был изменен в ранее идущей ф-ии addelement и он указывает на самый первый new spisok, т.е. на начало, значит и current первоначально указывает туда же

[MrQuestion]

если
temp = head
значит
temp->next = head->next
то есть первоначально
temp->next = указатель на второй добавленный элемент списка (или на ноль, если список состоит только из одной головы)

Так, если head->next == temp-> next, то temp->next == current->next, ведь и current == head. И все эти указатели указывают в никуда. На нуль.

Да и вообще. Если взять другой пример. Функцию добавления в начало списка.

 spisok head = 0;

           void add(spisok* current)
{
           current->next = head;
           head = current;
}

И что же получается? current->next указывает на head. Потом head указывает на current. И получается, что current->next == current. Т.е. это указатель не на следующий элемент, а сам на себя.

[eoln]

Советую взять отладчик и посмотреть как изменяются адреса.
head - фиксированные для всей программы
current - каждый раз новый при входе в функцию, но от начала ф-ии до её конца не меняется
temp - многократно изменяется в циклах while

spisok* current = new spisok;
...
     if(head == 0) 
     {
             head = current;

Сначала в current записывается какой-то адрес, например, 12345600.
Потом это же присваивается и глобальной переменной head. Больше head не меняется и всегда равен этому 12345600

Переменная temp сначала = head, то есть 12345600
Затем в цикле:
1) если у temp (которая сейчас равна head=12345600) есть последователи (то есть если temp->next != 0), то temp = temp->next = адресу последователя, например, 12345611;
2) если у temp (которая сейчас равна head->next=12345611) есть ещё последователи (то есть если temp->next != 0), то temp = temp->next = адресу следуещего последователя, например, 12345622;
3) если у temp (которая сейчас равна head->next->next=12345622) есть ещё последователи (то есть если temp->next != 0), то temp = temp->next = адресу следуещего последователя, например, 12345633;
и т.д. пока последователи не кончатся.
Как только кончаются последователи в цепочке, то добавляем ещё одного нового к самому последнему

temp->next=current;

В прошлом посте я подчеркнул слово первоначально

[MrQuestion]

1) если у temp (которая сейчас равна head=12345600) есть последователи (то есть если temp->next != 0), то temp = temp->next = адресу последователя, например, 12345611;

С каждым постом картина проясняется, но не до конца ясно вот что. В момент, когда head и temp указывают на один адрес, в вашем примере на 12345600, в этот момент head->next = temp->next. И вот это что то невообразимое.

то temp = temp->next = адресу последователя, например, 12345611

temp->next == head->next.

Получается, запись temp = temp->next аналогична записи temp = head->next. Но что за адрес хранится в head->next? Там current->next или, вообще, что?

Каким образом temp->next получает адрес следующего элемента?

[eoln]

В момент, когда head и temp указывают на один адрес, в вашем примере на 12345600, в этот момент head->next = temp->next. И вот это что то невообразимое.

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

temp = temp->next аналогична записи temp = head->next

только для первой итерации цикла while
для второй так:

temp = temp->next аналогична записи temp = head->next->next

для третьей

temp = temp->next аналогична записи temp = head->next->next->next

для четвёртой

temp = temp->next аналогична записи temp = head->next->next->next->next

и так далее
и вот чтобы не писать для каждой итерации всё больше и больше кода, на каждом проходе делают замену. Заменяют temp= temp->next. В итоге получаем краткую запись как в программе

Но что за адрес хранится в head->next?

Всегда указатель на второй элемент (или ноль, если его нет)

Каким образом temp->next получает адрес следующего элемента?

temp->next принимает значение адреса 2-го, 3-го, 4-го и т,д, элемента. Это просто некий счётчик в цикле while

[MrQuestion]

Всегда указатель на второй элемент (или ноль, если его нет)

Т.е. при первой итерации в temp->next и head->next хранится адрес current?

И в присвоении head = current происходит не присвоение head->next = current->next, а head->next = current?

Если не трудно, вы могли бы описать схему и поочередность присвоений? Что к чему конкретно присваивается и что на что указывает. Я не понимаю.

1) если у temp (которая сейчас равна head=12345600) есть последователи (то есть если temp->next != 0), то temp = temp->next = адресу последователя, например, 12345611;

Если адрес head = 12345600, а head->next == адрес второго элемента (т.е. currennt( который тоже 12345600) то temp=temp->next то же самое, что 12345600 == 12345600. Адрес не двигается с места. Это замкнутый круг.

[eoln]

Сообщение от MrQuestion

Т.е. при первой итерации в temp->next и head->next хранится адрес current?
И в присвоении head = current происходит не присвоение head->next = current->next, а head->next = current?

Итерации цикла, я везде писал про цикл, про цикл после else
current вообще записывается в самом конце процедуры, Это новый указатель на элемент. До самого конца на него ничего не указывает и ничего с ним не связано, и сам он ни с чем не связан.
Тут вообще нет понимания что такое указатель. head/current/temp - это не объекты класса, это просто числа, набор цифр, адрес по которому можно найти объект. Что-то типо GPS-координат.
Если написано head = current, то это значит что
head->next = current->next
head->a= current->a
head->b= current->b
Но опять в 6-ой раз скажу, что это происходит лишь однажды

head=current выполняется всего лишь один раз за всё время когда список вообще пуст. Больше эта строка не выполняется никогда. В любое другое время в current уже другой адрес.

Если адрес head = 12345600, а head->next == адрес второго элемента (т.е. currennt( который тоже 12345600)

Нет и ещё раз нет. current и head совпадают лишь однажды в самом начале, в другие моменты времени current имеет совершенно другие значения. В первый раз ни до каких temp, ни до каких вторых элементов не доходит, выполняется только это

if(head == 0) 
     {
             head = current; 
     }

описать схему и поочередность присвоений?

Я уже привёл краткую схему, подробности в учебниках.

Я не понимаю.

Объяснения в книжках. Тут только конкретные вопросы.
И ещё раз советую включить пошаговую отладку и посмотреть какие значения принимают head/current/temp. Это всё после прочтения о том как устроены динамические списки.

[MrQuestion]

Да! Я понял! Я понял, как они работают! Воспользовался отладочной печатью и всё понял! Ха-ха-ха! Нужно было включать мозги с самого начала! Спасибо eoln! Большое спасибо!

[Алексей_2012]

Если автор разобрался, то теперь вопросы у меня..., естественно по теме)

Здесь в качестве списка создаются связанные экземпляры класса? Просто мы для создания связанного списка писали примерно вот так:

struct spisok
{
int a,b;
spisok *next;
}

spisok *head;

Если да, то исходные списки продолжают существовать как отдельные объекты?

Плюс вопрос по коду из первого поста:

Разве при выводе списка не нужно писать так:

while (!head)

?