wskaźnik wskazujący na wskaźnik, który wskazuje na coś

Question

Dzień dobry!

Jest nastepująca sytuacja:

int *a;
int *b;
int *c;
int *d;
a = b; // a wskazuje na b;

Teraz następuje nowe wywołanie funkcji, i nie mam dostępu do "b", bo zostało nadpisane.
a dokładniej to są to operacje na klasowych obiektach, więc właśnie w tym momencie został stworzony nowy obiekt z konstruktora. Dostęp do tamtego obiektu został mi jedynie poprzez wskaźnik "a" i teraz pytanie jest takie. Czy mając wskaźnik "a", który wskazuje na wskaźnik "b",
mogę przypisać coś do wskaźnika "b" ?
- Jeszcze jedna sprawa, że ten wskaźnik "a" to obiekt, który jest wskaźnikiem. "b" też.
Dlatego właśnie w tym miejscu chciałbym przypisać obiekt c do obiektu b za pomocą obiektu a, który wskazuje na obiekt b(wszystkie są wskaźnikami)

 

Jeżeli chodzi o kod, to nie to, że jest tajny czy coś. Pytanie jest w sumie proste a tyle tekstu napisałem, żeby to dokładnie zobrazować. Czy można przypisać coś do wskaźnika, jeżeli posiadamy jedynie dostęp do wskaźnika innego, który to wskazuje na ten wskaźnik, do którego chcemy coś przypisać?

Czy jest to w ogóle możliwe?
 

Answer 1

//dwa wskaźniki
int value;
int* pointerOne =  &value;
int* pointerTwo;
pointerTwo = pointerOne;
//pointerTwo wskazuje na value! nie na pointerOne

int ** inceptionPointer;
inceptionPointer = &pointerTwo;
//teraz inceptionPointer wskazuje na pointerTwo
**inceptionPointer = 5;

Comments

Czyli dwie gwiazdki słuza do tworzenia wskaznika, pokazującego na wskazniki?

---

int value; //zwykła zmienna
int* pointer; //wskaźnik wskazujący na typ int
int** secondLevelPointer; // wskaźnik wskazujący na typ int*
int*** thirdLevelPointer; //wskaźnik wskazujący na typ int**

Tak to się ma.

---

#include <iostream>
using namespace std;
class Node
{
public:
    Node(int val);
    ~Node();
    int value;
    Node* next;
};
Node::Node(int val) : value(val), next(nullptr)
{
//cout<<"konstruktor\n";
}
Node::~Node()
{
//cout<<"destruktor\n";
}
class List
{
public:
    List();
    void push_front(int value);
    bool pop_front(int &value);
    void push_back(int value);
    int size();
private:
    Node* head;
    Node* tail;
};
List::List() : head(nullptr), tail(nullptr)
{
}
void List::push_front(int value)
{
    Node* new_head = new Node(value);
    new_head->next = head;
    if(head == nullptr)
        tail = head->next;
    head = new_head;
}
bool List::pop_front(int &value)
{
  if(head == nullptr){
    return false;
  }
  else{
    Node* popped = head;
    head = head->next;
    value = popped->value;
    delete popped;
    return true;
  }
}
void List::push_back(int value)
{
    Node* new_node = new Node(value);
    if(head == nullptr){
        head = new_node;
        tail = new_node->next; //   1. TAIL wskazuje na next
    }
    else{ 
        tail = new_node; //  2. new_node przypisuje do tego na co TAIL wskazuje
        tail = new_node->next; // 3. tail wskazuje znowu na next (czyli powrót do krok 1.)
    }
}
int main()
{
    List list;
    list.push_back(1);
    list.push_back(2);
    list.push_back(3);
    list.push_back(4);
    int value = 0;
    while (list.pop_front(value))
    {
        cout << value << endl;
    }
return 0;

}

Ja już to zrobiłem jakiś tydzień temu inaczej i działało. ALE nie daje mi ciągle spokoju to, że nie umiem tego przypisać dobrze i wskazać dalej na coś innego.

Te kroki 1. 2. 3. - to opisałem tak jakbym chciał, żeby działo, ale tak nie działa, bo program wypisuje zły wynik.

Stąd się włąsnie pojawiło pytanie w głównym poście. TAIL wskazuje na NEXT a next też na coś wskazuje prawda? no i teraz jak przypisać coś do NEXT mająć TAIL, który na niego wskazuje, a później zmienić, żeby TAIL wskazywał na następnego już NEXT'a ?

A już wiem czemu mam problem:

tail = new_node; // 2.

w tym momencie zamiast przypisać new_node do NEXT'a na którego wskazuje mój TAIL to przypisuje tego new_node'a do TAIL'a i tym samym trace bez powrotnie wskaźnik na NEXT'a(bo teraz wskazuje na new_node). Jak w takim razie przypisać new_node do tego na co TAIL wskazuje czyli do NEXT? chcę, żeby next wskazywało na new_node!

Answer 2

a = b; //a wskazuje na b. Raczej: a = &b;