#[derive(Debug)]
struct Node<'a>{
next : &'a mut Node<'a>,
data : i32,
}
struct LinkedList<'b>{
head : Node<'b>,// not use mut ,because of "let mut var = ..." of "mut" including mutability to inner members.
//rear : &'b mut Node<'b>,
}
// macro_rules! ListAdd {
// ($list:expr,$node:expr) => {
// let mut t = Node{next:LinkedList::null(),data:$node};
// if $list.head.data == 0{
// $list.head.next = &mut t;
// $list.rear = &mut t;
// $list.head.data += 1;
// return;
// }
// $list.rear.next = &mut t;
// $list.rear = &mut t;
// $list.head.data += 1;
// };
// }
impl<'d> Node<'d>{
pub fn new(d:i32)->Node<'d>{
Node{
next:Node::null(),
data:d,
}
}
pub fn null()->&'d mut Node<'d>{
unsafe{
&mut *(0 as *mut Node)
}
}
}
impl<'c> LinkedList<'c>{
pub fn new()-> LinkedList<'c>{
LinkedList{
head : Node{next:Node::null(),data:0},
//rear : Node::null(),
}
}
pub fn append_child(&mut self,node : &'c mut Node<'c>){
//let mut t = Box::new(Node{next:LinkedList::null(),data:d});
//let mut t = Node::<'c>{next:LinkedList::null(),data:d};
self.head.data += 1;
if self.head.data == 0 {
self.head.next = node;
return;
}
unsafe{
node.next = &mut *(self.head.next as *mut Node);
}
self.head.next = node;
// if self.head.data == 0{
// self.head.next = node;
// self.rear = node;
// self.head.data +=1;
// return;
// }
// self.head.data += 1;
// self.rear.next = node;
// self.rear = node;
}
pub fn len(&self)-> i32{
self.head.data
}
pub fn to_array(&self)->Vec<i32>{
let mut arr = Vec::new();
// error[E0507]: cannot move out of borrowed content
// --> LinkedList2.rs:88:23
// |
// 88 | let mut ptr = self.head.next;
// | ^^^^----------
// | |
// | cannot move out of borrowed content
// | help: consider using a reference instead: `&self.head.next`
/*
*
* Pointing to content, reference variable --raw point
* in essence-- cannot "move" into another variable
*
* let mut ptr = self.head.next;//error
*
*/
let mut ptr = &self.head.next;
let len = self.len();
for _ in 0..len{
//error[E0308]: mismatched types
// --> LinkedList2.rs:93:18
// |
// 93 | ptr = *&ptr.next;
// | ^^^^^^^^^^ expected mutable reference, found struct `Node`
// |
// = note: expected type `&&mut Node<'c>`
// found type `&'c mut Node<'c>`
// error: aborting due to previous error
/*
* && <---> ** | & <---> *
* one "&" to one "*"
* Conception of reference and dereference
* You must understand!
*
* If you write the following code:
*
* arr.push(ptr.data);
*
* this is also right!
*
*/
arr.push((**ptr).data);
ptr = &ptr.next;
}
arr
}
}
fn main(){
println!("{}", "LinkedList Writing!");
let mut l = LinkedList::new();
/*
*
* How to use "unsafe"?
* You must learn about how "function" works!
* You can use two or more references(raw pointer) pointing to just one content if
* you are sure this is safe way.
*
* This is aiming at transmiting address content to "next".It is necessary.
* After done,there is only one reference variable pointing to the variable
* you defined in high scope layer it can own a long lifetime.
*
*/
unsafe{
let mut node = Node::new(12);
l.append_child(&mut *(&mut node as *mut Node));
let mut node = Node::new(11);
l.append_child(&mut *(&mut node as *mut Node));
let mut node = Node::new(13);
l.append_child(&mut *(&mut node as *mut Node));
let mut node = Node::new(15);
l.append_child(&mut *(&mut node as *mut Node));
let mut node = Node::new(17);
l.append_child(&mut *(&mut node as *mut Node));
let mut node = Node::new(18);
l.append_child(&mut *(&mut node as *mut Node));
let mut node = Node::new(19);
l.append_child(&mut *(&mut node as *mut Node));
let mut node = Node::new(10);
l.append_child(&mut *(&mut node as *mut Node));
}
println!("{:?}", l.to_array());
println!("{:?}", l.to_array());
println!("{:?}", l.to_array());
// ListAdd!(l,123);
// ListAdd!(l,22);
// ListAdd!(l,55);
// ListAdd!(l,11);
// ListAdd!(l,888);
// println!("{:p}", Node::null());
let a = Node::new(100);
let b = &a;
let c = &b;
println!("a node : {:?}", a.data);
println!("&a address {:p}", &a);
println!("&&a address {:p}", &&a);
println!("&&&a address {:p}", &&&a);
println!("b node : {:?}", b.data);
println!("&b address {:p}", &b);
println!("&&b address {:p}", &&b);
println!("&&&b address {:p}", &&&b);
println!("c node : {:?}", c.data);
println!("&c address {:p}", &c);
println!("&&c address {:p}", &&c);
println!("&&&c address {:p}", &&&c);
println!("== &*b=&a =====");
println!("&*b address {:p} (&a == {:p})", &*b,&a);
println!("== &*c=&b =====");
println!("&*c address {:p} (&b == {:p})", &*c,&b);
println!("== &**c=&a =====");
println!("&**c address {:p} (&a == {:p})", &**c,&a);
println!("================");
let d = &a;
let f = d;
println!("&d address {:p}", &d);
println!("&f address {:p}", &f);
println!("&*d:{:p} ?= {:p}:&*f (&a == {:p})", &*d,&*f,&a);
}
LinkedList Writing!
[10, 19, 18, 17, 15, 13, 11, 12]
[10, 19, 18, 17, 15, 13, 11, 12]
[10, 19, 18, 17, 15, 13, 11, 12]
a node : 100
&a address 0x7ffe20a244b0
&&a address 0x7ffe20a245b8
&&&a address 0x7ffe20a24610
b node : 100
&b address 0x7ffe20a244c0
&&b address 0x7ffe20a24708
&&&b address 0x7ffe20a24760
c node : 100
&c address 0x7ffe20a244c8
&&c address 0x7ffe20a24858
&&&c address 0x7ffe20a248b0
== &*b=&a =====
&*b address 0x7ffe20a244b0 (&a == 0x7ffe20a244b0)
== &*c=&b =====
&*c address 0x7ffe20a244c0 (&b == 0x7ffe20a244c0)
== &**c=&a =====
&**c address 0x7ffe20a244b0 (&a == 0x7ffe20a244b0)
================
&d address 0x7ffe20a24ad0
&f address 0x7ffe20a24ad8
&*d:0x7ffe20a244b0 ?= 0x7ffe20a244b0:&*f (&a == 0x7ffe20a244b0)