dereference

I remember an example where the difference between pointers and arrays was demonstrated. An array decays to a pointer to the first element in an array when passed as a function parameter, but they are not equivalent, as demonstrated next: //file file1.c int a[2] = {800, 801}; int b[2] = {100, 101}; //file file2.c extern int a[2]; // here b is declared as pointer, // although the external unit defines it as an array extern int *b; int main() { int x1, x2; x1 = a[1]; // ok x2 = b[1]; // crash at runtime return 0; } The linker does not type-check for external variables so no errors are generated

I was learning about C++ pointers and the -> operator seemed strange to me. Instead of ptr->hello(); one could write (*ptr).hello(); because it also seems to work, so I thought the former is just a more convenient way. Is that the case or is there any difference? The -> operator is just syntactic sugar because (*ptr).hello() is a PITA to type. In terms of the instructions generated at the ASM level, there's no difference. In fact, in some languages (D comes to mind), the compiler figures everything out based on type. If you do ptr.hello() , it just works, because the compiler knows that ptr is

From the Rust guide: To dereference (get the value being referred to rather than the reference itself) y , we use the asterisk ( * ) So I did it: fn main() { let x = 1; let ptr_y = &x; println!("x: {}, ptr_y: {}", x, *ptr_y); } This gives me the same results (x=1; y=1) even without an explicit dereference: fn main() { let x = 1; let ptr_y = &x; println!("x: {}, ptr_y: {}", x, ptr_y); } Why? Shouldn't ptr_y print the memory address and *ptr_y print 1? Is there some kind of auto-dereference or did I miss something? huon Rust usually focuses on object value (i.e. the interesting part of the

I often use the newtype pattern, but I am tired of writing my_type.0.call_to_whatever(...) . I am tempted to implement the Deref trait because it permits writing simpler code since I can use my newtype as if it were the underlying type in some situations, e.g. : use std::ops::Deref; type Underlying = [i32; 256]; struct MyArray(Underlying); impl Deref for MyArray { type Target = Underlying; fn deref(&self) -> &Self::Target { &self.0 } } fn main() { let my_array = MyArray([0; 256]); println!("{}", my_array[0]); // I can use my_array just like a regular array } Is this a good or bad practice? Why

Is there any way to check if an iterator (whether it is from a vector, a list, a deque...) is (still) dereferencable, i.e. has not been invalidated? I have been using try - catch , but is there a more direct way to do this? Example: (which doesn't work) list<int> l; for (i = 1; i<10; i++) { l.push_back(i * 10); } itd = l.begin(); itd++; if (something) { l.erase(itd); } /* now, in other place.. check if itd points to somewhere meaningful */ if (itd != l.end()) { // blablabla } I assume you mean "is an iterator valid," that it hasn't been invalidated due to changes to the container (e.g.,