Why do owned slices take 16 bytes in rust? (on x64 machine) Announcing the arrival of Valued...
Is a self contained air-bullet cartridge feasible?
Marquee sign letters
Why do people think Winterfell crypts is the safest place for women, children & old people?
Deciphering death certificate writing
Protagonist's race is hidden - should I reveal it?
Why is water being consumed when my shutoff valve is closed?
Translate text contents of an existing file from lower to upper case and copy to a new file
What do you call an IPA symbol that lacks a name (e.g. ɲ)?
Does a Draconic Bloodline sorcerer's doubled proficiency bonus for Charisma checks against dragons apply to all dragon types or only the chosen one?
What is /etc/mtab in Linux?
Why doesn't the university give past final exams' answers?
All ASCII characters with a given bit count
Could typically electronic sounds be generated mechanically?
What to do with someone that cheated their way though university and a PhD program?
How to keep bees out of canned beverages?
Raising a bilingual kid. When should we introduce the majority language?
How did Elite on the NES work?
Putting Ant-Man on house arrest
Calculating the expected value of truncated normal
What's called a person who work as someone who puts products on shelves in stores?
Is Bran literally the world's memory?
Where to find documentation for `whois` command options?
Will I lose my paid in full property
What is the ongoing value of the Kanban board to the developers as opposed to management
Why do owned slices take 16 bytes in rust? (on x64 machine)
Announcing the arrival of Valued Associate #679: Cesar Manara
Planned maintenance scheduled April 23, 2019 at 23:30 UTC (7:30pm US/Eastern)
Data science time! April 2019 and salary with experience
The Ask Question Wizard is Live!Why does Rust borrow checker reject this code?Is &[T] literally an alias of Slice in rust?Why doesn't println! work in Rust unit tests?What is vector slice in Rust?Why are Rust executables so huge?Why are explicit lifetimes needed in Rust?Why is a &str called a slice in Rust?How To Assign Slices While Iterating Over a Vec in Rust without copying?How can I get a single byte from stdin in Rust without waiting for Enter?Creating a slice and appending to it in Rust
.everyoneloves__top-leaderboard:empty,.everyoneloves__mid-leaderboard:empty,.everyoneloves__bot-mid-leaderboard:empty{ height:90px;width:728px;box-sizing:border-box;
}
fn main() {
// prints 8, 8, 16
println!(
"{}, {}, {}",
std::mem::size_of::<Box<i8>>(),
std::mem::size_of::<Box<&[i8]>>(),
std::mem::size_of::<Box<[i8]>>(),
);
}
Why do owned slices take 16 bytes but referenced slices take only 8?
rust
edited 5 hours ago
Boann
37.6k1291123
asked 6 hours ago
aminamin
1,28812042
add a comment |
fn main() {
// prints 8, 8, 16
println!(
"{}, {}, {}",
std::mem::size_of::<Box<i8>>(),
std::mem::size_of::<Box<&[i8]>>(),
std::mem::size_of::<Box<[i8]>>(),
);
}
Why do owned slices take 16 bytes but referenced slices take only 8?
rust
edited 5 hours ago
Boann
37.6k1291123
asked 6 hours ago
aminamin
1,28812042
Playground: play.rust-lang.org/…
– French Boiethios
6 hours ago
2
Previous discussion: i.stack.imgur.com/Xt6L3.png
– hellow
5 hours ago
add a comment |
fn main() {
// prints 8, 8, 16
println!(
"{}, {}, {}",
std::mem::size_of::<Box<i8>>(),
std::mem::size_of::<Box<&[i8]>>(),
std::mem::size_of::<Box<[i8]>>(),
);
}
Why do owned slices take 16 bytes but referenced slices take only 8?
rust
edited 5 hours ago
Boann
37.6k1291123
asked 6 hours ago
aminamin
1,28812042
fn main() {
// prints 8, 8, 16
println!(
"{}, {}, {}",
std::mem::size_of::<Box<i8>>(),
std::mem::size_of::<Box<&[i8]>>(),
std::mem::size_of::<Box<[i8]>>(),
);
}
Why do owned slices take 16 bytes but referenced slices take only 8?
rust
rust
edited 5 hours ago
Boann
37.6k1291123
asked 6 hours ago
aminamin
1,28812042
edited 5 hours ago
Boann
37.6k1291123
asked 6 hours ago
aminamin
1,28812042
edited 5 hours ago
Boann
37.6k1291123
edited 5 hours ago
Boann
37.6k1291123
edited 5 hours ago
Boann
37.6k1291123
37.6k1291123
asked 6 hours ago
aminamin
1,28812042
asked 6 hours ago
aminamin
1,28812042
asked 6 hours ago
aminamin
1,28812042
1,28812042
Playground: play.rust-lang.org/…
– French Boiethios
6 hours ago
2
Previous discussion: i.stack.imgur.com/Xt6L3.png
– hellow
5 hours ago
add a comment |
Playground: play.rust-lang.org/…
– French Boiethios
6 hours ago
2
Previous discussion: i.stack.imgur.com/Xt6L3.png
– hellow
5 hours ago
Playground: play.rust-lang.org/…
– French Boiethios
6 hours ago
Playground: play.rust-lang.org/…
– French Boiethios
6 hours ago
2
2
Previous discussion: i.stack.imgur.com/Xt6L3.png
– hellow
5 hours ago
Previous discussion: i.stack.imgur.com/Xt6L3.png
– hellow
5 hours ago
add a comment |
2 Answers
2
active
oldest
votes
Box<T> is basically *const T (Actually it's a newtype around Unique<T>, which itself is a NonNull<T> with PhantomData<T> (for dropck), but let's stick to *const T for simplicity).
A pointer in rust normally has the same size as size_of::<usize>() except when T is a Dynamically sized type (DST). Currently, a Box<DST> is 2 * size_of::<usize>() in size (The exact representation is not stable at the time of writing). A pointer to a DST is called FatPtr.
Currently, there are two kinds of DSTs: Slices and traits. A FatPtr to a slice is defined like this:
#[repr(C)]
struct FatPtr<T> {
data: *const T,
len: usize,
}
For a trait pointer, len is replaced by a pointer to the vtable.
Box<i8>:i8is a sized type => basically the same as*const i8=> 8 bytes in size (on 64 bit)
Box<[i8]>:[i8]is a DST => basically the same asFatPtr<T>=> 16 bytes in size (on 64 bit)
Box<&[i8]>:&[i8]is not a DST. It's basically the same as*const FatPtr<T>=> 8 bytes in size (on 64 bit)
answered 5 hours ago
Tim DiekmannTim Diekmann
3,55291940
add a comment |
The size of a reference depends on the "sizeness" of the referenced type:
- A reference to a sized type is a single pointer to the memory address.
A reference to an unsized type is a pointer to the memory and the size of the pointed datum. That's what is called a fat pointer:
#[repr(C)]
struct FatPtr<T> {
data: *const T,
len: usize,
}
A Box is a special kind of pointer that points to the heap, but it is a pointer anyway.
Knowing that, you understand that:
Box<i8>is 8 bytes becausei8is sized,
Box<&[i8]>is 8 bytes because a reference is sized,
Box<[i8]>is 8 bytes because a slice is unsized
answered 5 hours ago
French BoiethiosFrench Boiethios
11.4k44081
add a comment |
Your Answer
StackExchange.ifUsing("editor", function () {
StackExchange.using("externalEditor", function () {
StackExchange.using("snippets", function () {
StackExchange.snippets.init();
});
});
}, "code-snippets");
StackExchange.ready(function() {
var channelOptions = {
tags: "".split(" "),
id: "1"
};
initTagRenderer("".split(" "), "".split(" "), channelOptions);
StackExchange.using("externalEditor", function() {
// Have to fire editor after snippets, if snippets enabled
if (StackExchange.settings.snippets.snippetsEnabled) {
StackExchange.using("snippets", function() {
createEditor();
});
}
else {
createEditor();
}
});
function createEditor() {
StackExchange.prepareEditor({
heartbeatType: 'answer',
autoActivateHeartbeat: false,
convertImagesToLinks: true,
noModals: true,
showLowRepImageUploadWarning: true,
reputationToPostImages: 10,
bindNavPrevention: true,
postfix: "",
imageUploader: {
brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
allowUrls: true
},
onDemand: true,
discardSelector: ".discard-answer"
,immediatelyShowMarkdownHelp:true
});
}
});
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f55814114%2fwhy-do-owned-slices-take-16-bytes-in-rust-on-x64-machine%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
2 Answers
2
active
oldest
votes
2 Answers
2
active
oldest
votes
active
oldest
votes
active
oldest
votes
Box<T> is basically *const T (Actually it's a newtype around Unique<T>, which itself is a NonNull<T> with PhantomData<T> (for dropck), but let's stick to *const T for simplicity).
A pointer in rust normally has the same size as size_of::<usize>() except when T is a Dynamically sized type (DST). Currently, a Box<DST> is 2 * size_of::<usize>() in size (The exact representation is not stable at the time of writing). A pointer to a DST is called FatPtr.
Currently, there are two kinds of DSTs: Slices and traits. A FatPtr to a slice is defined like this:
#[repr(C)]
struct FatPtr<T> {
data: *const T,
len: usize,
}
For a trait pointer, len is replaced by a pointer to the vtable.
Box<i8>:i8is a sized type => basically the same as*const i8=> 8 bytes in size (on 64 bit)
Box<[i8]>:[i8]is a DST => basically the same asFatPtr<T>=> 16 bytes in size (on 64 bit)
Box<&[i8]>:&[i8]is not a DST. It's basically the same as*const FatPtr<T>=> 8 bytes in size (on 64 bit)
answered 5 hours ago
Tim DiekmannTim Diekmann
3,55291940
add a comment |
Box<T> is basically *const T (Actually it's a newtype around Unique<T>, which itself is a NonNull<T> with PhantomData<T> (for dropck), but let's stick to *const T for simplicity).
A pointer in rust normally has the same size as size_of::<usize>() except when T is a Dynamically sized type (DST). Currently, a Box<DST> is 2 * size_of::<usize>() in size (The exact representation is not stable at the time of writing). A pointer to a DST is called FatPtr.
Currently, there are two kinds of DSTs: Slices and traits. A FatPtr to a slice is defined like this:
#[repr(C)]
struct FatPtr<T> {
data: *const T,
len: usize,
}
For a trait pointer, len is replaced by a pointer to the vtable.
Box<i8>:i8is a sized type => basically the same as*const i8=> 8 bytes in size (on 64 bit)
Box<[i8]>:[i8]is a DST => basically the same asFatPtr<T>=> 16 bytes in size (on 64 bit)
Box<&[i8]>:&[i8]is not a DST. It's basically the same as*const FatPtr<T>=> 8 bytes in size (on 64 bit)
answered 5 hours ago
Tim DiekmannTim Diekmann
3,55291940
add a comment |
Box<T> is basically *const T (Actually it's a newtype around Unique<T>, which itself is a NonNull<T> with PhantomData<T> (for dropck), but let's stick to *const T for simplicity).
A pointer in rust normally has the same size as size_of::<usize>() except when T is a Dynamically sized type (DST). Currently, a Box<DST> is 2 * size_of::<usize>() in size (The exact representation is not stable at the time of writing). A pointer to a DST is called FatPtr.
Currently, there are two kinds of DSTs: Slices and traits. A FatPtr to a slice is defined like this:
#[repr(C)]
struct FatPtr<T> {
data: *const T,
len: usize,
}
For a trait pointer, len is replaced by a pointer to the vtable.
Box<i8>:i8is a sized type => basically the same as*const i8=> 8 bytes in size (on 64 bit)
Box<[i8]>:[i8]is a DST => basically the same asFatPtr<T>=> 16 bytes in size (on 64 bit)
Box<&[i8]>:&[i8]is not a DST. It's basically the same as*const FatPtr<T>=> 8 bytes in size (on 64 bit)
answered 5 hours ago
Tim DiekmannTim Diekmann
3,55291940
Box<T> is basically *const T (Actually it's a newtype around Unique<T>, which itself is a NonNull<T> with PhantomData<T> (for dropck), but let's stick to *const T for simplicity).
A pointer in rust normally has the same size as size_of::<usize>() except when T is a Dynamically sized type (DST). Currently, a Box<DST> is 2 * size_of::<usize>() in size (The exact representation is not stable at the time of writing). A pointer to a DST is called FatPtr.
Currently, there are two kinds of DSTs: Slices and traits. A FatPtr to a slice is defined like this:
#[repr(C)]
struct FatPtr<T> {
data: *const T,
len: usize,
}
For a trait pointer, len is replaced by a pointer to the vtable.
Box<i8>:i8is a sized type => basically the same as*const i8=> 8 bytes in size (on 64 bit)
Box<[i8]>:[i8]is a DST => basically the same asFatPtr<T>=> 16 bytes in size (on 64 bit)
Box<&[i8]>:&[i8]is not a DST. It's basically the same as*const FatPtr<T>=> 8 bytes in size (on 64 bit)
answered 5 hours ago
Tim DiekmannTim Diekmann
3,55291940
edited 5 hours ago
answered 5 hours ago
Tim DiekmannTim Diekmann
3,55291940
answered 5 hours ago
Tim DiekmannTim Diekmann
3,55291940
answered 5 hours ago
Tim DiekmannTim Diekmann
3,55291940
3,55291940
add a comment |
add a comment |
The size of a reference depends on the "sizeness" of the referenced type:
- A reference to a sized type is a single pointer to the memory address.
A reference to an unsized type is a pointer to the memory and the size of the pointed datum. That's what is called a fat pointer:
#[repr(C)]
struct FatPtr<T> {
data: *const T,
len: usize,
}
A Box is a special kind of pointer that points to the heap, but it is a pointer anyway.
Knowing that, you understand that:
Box<i8>is 8 bytes becausei8is sized,
Box<&[i8]>is 8 bytes because a reference is sized,
Box<[i8]>is 8 bytes because a slice is unsized
answered 5 hours ago
French BoiethiosFrench Boiethios
11.4k44081
add a comment |
The size of a reference depends on the "sizeness" of the referenced type:
- A reference to a sized type is a single pointer to the memory address.
A reference to an unsized type is a pointer to the memory and the size of the pointed datum. That's what is called a fat pointer:
#[repr(C)]
struct FatPtr<T> {
data: *const T,
len: usize,
}
A Box is a special kind of pointer that points to the heap, but it is a pointer anyway.
Knowing that, you understand that:
Box<i8>is 8 bytes becausei8is sized,
Box<&[i8]>is 8 bytes because a reference is sized,
Box<[i8]>is 8 bytes because a slice is unsized
answered 5 hours ago
French BoiethiosFrench Boiethios
11.4k44081
add a comment |
The size of a reference depends on the "sizeness" of the referenced type:
- A reference to a sized type is a single pointer to the memory address.
A reference to an unsized type is a pointer to the memory and the size of the pointed datum. That's what is called a fat pointer:
#[repr(C)]
struct FatPtr<T> {
data: *const T,
len: usize,
}
A Box is a special kind of pointer that points to the heap, but it is a pointer anyway.
Knowing that, you understand that:
Box<i8>is 8 bytes becausei8is sized,
Box<&[i8]>is 8 bytes because a reference is sized,
Box<[i8]>is 8 bytes because a slice is unsized
answered 5 hours ago
French BoiethiosFrench Boiethios
11.4k44081
The size of a reference depends on the "sizeness" of the referenced type:
- A reference to a sized type is a single pointer to the memory address.
A reference to an unsized type is a pointer to the memory and the size of the pointed datum. That's what is called a fat pointer:
#[repr(C)]
struct FatPtr<T> {
data: *const T,
len: usize,
}
A Box is a special kind of pointer that points to the heap, but it is a pointer anyway.
Knowing that, you understand that:
Box<i8>is 8 bytes becausei8is sized,
Box<&[i8]>is 8 bytes because a reference is sized,
Box<[i8]>is 8 bytes because a slice is unsized
answered 5 hours ago
French BoiethiosFrench Boiethios
11.4k44081
answered 5 hours ago
French BoiethiosFrench Boiethios
11.4k44081
answered 5 hours ago
French BoiethiosFrench Boiethios
11.4k44081
answered 5 hours ago
French BoiethiosFrench Boiethios
11.4k44081
11.4k44081
add a comment |
add a comment |
Thanks for contributing an answer to Stack Overflow!
- Please be sure to answer the question. Provide details and share your research!
But avoid …
- Asking for help, clarification, or responding to other answers.
- Making statements based on opinion; back them up with references or personal experience.
To learn more, see our tips on writing great answers.
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f55814114%2fwhy-do-owned-slices-take-16-bytes-in-rust-on-x64-machine%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Playground: play.rust-lang.org/…
– French Boiethios
6 hours ago
2
Previous discussion: i.stack.imgur.com/Xt6L3.png
– hellow
5 hours ago