rust is not abi stable

That's why Epochs is proposed to solve this issue

Epoch is just one suggestion. It was rejected because there is no implementation and not known if one can be even implemented. It will take a long time to mature because modules themselves are not supported completely by any major compilers and epochs as proposed today depends a lot on modules. Here is another proposal for ABI stability http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p2123r0.html which doesnt require extensive changes.

Edition preserve the backward compatibility

I don't think standardization process is affected by the vendors(GCC, clang...) implementation

Even modules are not implemented fully as you've said and got standardized

But I believe if we got modules and epochs Everything will move faster

>

Yes but you were also saying you didnt know why epochs got rejected. It got rejected because modules hasn't matured yet

So, if modules got matured as it seems it will There is a high chance for Epochs to get into the standard

void deleteAtMiddle(Node *&head,int pos) { if(head==NULL or pos==0) { deleteAtHead(head); return; } int jumps=1; Node *p=head; while(jumps<=pos-1) { p=p->next; } Node *n=p->next; p->next=n->next; n->next->prev=p; delete n; return; }

> Node *&head why

void deleteAtHead(Node *&head) { if(head==NULL) { return; } Node *temp=head->next; delete head; temp->prev=NULL; head=temp; return; }

void deleteAtMiddle(Node *&head,int pos) { if(head==NULL or pos==0) { deleteAtHead(head); return; } int jumps=1; Node *p=head; while(jumps<=pos-1) { p=p->next; } Node *n=p->next; p->next=n->next; n->next->prev=p; delete n; return; }

void deleteAtMiddle(Node *&head,int pos) { if(head==NULL or pos==0) { deleteAtHead(head); return; } int jumps=1; Node *p=head; while(jumps<=pos-1) { p=p->next; } Node *n=p->next; p->next=n->next; n->next->prev=p; delete n; return; }

void deleteAtHead(Node *&head) { if(head==NULL) { return; } if(head->next==NULL) { delete head; head=NULL; return; } Node *temp=head->next; delete head; temp->prev=NULL; head=temp; return; } int length(Node *head) { int cnt=0; while(head!=NULL) { cnt++; head=head->next; } return cnt; } void deleteAtTail(Node *&head) { if(head==NULL or head->next==NULL) { deleteAtHead(head); return; } Node *p=head; while(p->next->next!=NULL) { p=p->next; } Node *tail=p->next; delete tail; p->next=NULL; } void deleteAtMiddle(Node *&head,int pos) { if(head==NULL or pos==0) { deleteAtHead(head); return; } if(pos>=length(head)) { deleteAtTail(head); return; } int jumps=1; Node *p=head; while(jumps<=pos-1) { p=p->next; jumps++; } Node *n=p->next; p->next=n->next; if(n->next!=NULL) { n->next->prev=p; } delete n; return; }

overengineered. bool delete_at_pos(node **head, size_t pos) { if (head == nullptr || *head == nullptr) { return false; } while (pos--) { if (!(*head)->next) { return false; } head = &((*head)->next); } node *temp = *head; *head = temp->next; if (temp->next) { temp->next->prev = temp->prev; } delete temp; return true; }

You are not setting the next link for node before temp

*head = temp->next

This sets head to the node after temp. But what about the the node before temp. Its next link will be pointing to temp right?

And why are you even changing head pointer? You are just deleting a node somewhere in between. Why should head be changed to the node after the one deleted?

head contains the address of a next pointer (or an actual head pointer coming from outside)

Head could be the actual head pointer of the list. You shouldnt be changing that. node* temp = *head; Here *head is the node to be deleted. You set temp to that node. Now temp is the node to be deleted *head = temp->next; Here you set head to the node after temp that is the node after the node to be deleted. Neither of this code sets temp->prev->next to *head which is what I am talking about. You then go on to delete temp after setting temp->next->prev to temp->prev You have not changed temp->prev->next anywhere.

head either comes from outside using /* something something node *head something something */ delete_at_pos(&head, n); or changes at head = &((*head)->next);

Ok let me address this one by one. Suppose say I have this list l and head is a pointer to the first node in this list. node* head = 1st pointer. If I call delete_at_pos(&head, n) my head pointer would have been changed by your code. This is not correct design. Now coming to the other point, *head = temp->next doesnt set the next link in temp->prev. I am not sure how you are saying that it does so. Let me test this code later.

first point. yes. head would point to the new first node of the list now (which may be nullptr). why would it be bad design though? the delete_at_pos() is a modifier for the entire list object, so it asks for a pointer to the list (instead of the first node) and modifies the list as it sees fit. ideally there should be a using list = node * in the header file so the user's code should look like list l1 = create_list(first_elem); /* something something */ delete_at_pos(&l1, n); second point sure

I will check your code near a system. I am not sure if the prev node will be affected. But like you said, I missed the Node** and was interpreting your code as it being Node*. Will check it later.

You are deleting a node at some position in the list. That shouldnt change the head pointer. Ideally you shouldnt be changing the pointer passed in by the user at all without knowing what he is using it for. That is why I said it is not good design. He could be using that pointer as the head for his list. If he wanted to delete the 4th element, it shouldnt change the head pointer at all. Only in the case where it deletes the first node should the head pointer be changed. Not in any other cases.

no your interpretation was consistent throughout. i deleted that message. *head is the node to be deleted == delete *head; node is the node to be deleted == delete node;

No it was my mistake. The actual head pointer passed in would not be affected by your code. You are just resetting head here : head = &((*head)->next); which seems good. I got confused with a double pointer and a single pointer. Will have to check the logic for prev problem again just to be sure. Cant break my head over it on my phone but.

😁.

Nafiu Salisu Muhammad: Please help me with this assignment Exercises1:Write an algorithm to find the square of a number. Display the pictorial representation of the algorithm using a flowchart. Exercise 2:Draw a flowchart to solve the problem of a non-functioning light bulb. Exercise 3:Write an algorithm to check whether a number is odd or even. Present your algorithm in Psuedocode and flowchart

Solve problems

is there a way to find the KEY with the max number of values in it? in unordered_map? I know count() but for that I need to know the key

Do you mean an unordered_multimap? An unordered_map will have only one value associated with each key

Oh shit Yes sorry I can create a list as the values Now say, for the list, do I iterate over it and count the no of nodes?

Yes. You will have to iterate over the map and find the list with the longest length. The map interface doesnt support these sort of queries. If you need to do such queries frequently then an alternative way would be to use two multi maps where the 2nd multi map will store the first map's key as value and will use the first map's value (actually the list length) as key.

Hi is it possible for the condition of a loop to be a if statement for example while ( if else statements)

Don't know whether it's syntactically possible other than ternary operators.. But you can put the if statements in a function and call the function in the while statement condition part...

Should I learn DirectX11 or OpenGL for windows?