using System;
using System.Net;
var addr = "1.119.192.0/24";
var parts = addr.Split('/', 2);
var netIp = IPAddress.Parse(parts[0]);
Span<byte> bytes = stackalloc byte[4];
netIp.TryWriteBytes(bytes, out var _);
bytes.Reverse();
var range = int.Parse(parts[1]);
var networkIpNumber = BitConverter.ToUInt32(bytes);
for(var i = 1u; i< (1 << (32-range))-1; i++) {
BitConverter.TryWriteBytes(bytes, SwapEndianness(networkIpNumber | i));
var ip = new IPAddress(bytes);
Console.WriteLine(ip);
}
uint SwapEndianness(uint x)
{
return ((x & 0x000000ff) << 24) +
((x & 0x0000ff00) << 8) +
((x & 0x00ff0000) >> 8) +
((x & 0xff000000) >> 24);
}В проекте необходимо реализовать на каком этапе находится каждая задача, а затем вывести эту информацию в файл, с условием того, что файл можно будет загрузить и продолжить редактирование.
Не хочу брать docx, так как не все устройства имею у себя офис или его аналог
не все устройства имею у себя офис или его аналог
Я подумал, что ошибка связана с блокировкой (хотя это тоже странно).
Так как у меня стабильный Rust, я не могу использовать black_box, поэтому не могу выражать уверенность в достоверности этого теста.
каким образом было определено, что утекает именно при чтении из файла?
pub struct BinValue {
ptr: *mut u8,
}
impl BinValue {
#[inline(always)]
pub fn len(&self) -> usize {
let len: u16 = unsafe { ptr::read_unaligned(self.ptr.cast()) };
if len < 0xFFFFu16 {
return len as usize;
}
let len: u32 = unsafe { ptr::read_unaligned(self.ptr.offset(2).cast()) };
len as usize
}
pub fn new(slice: &[u8]) -> Self {
let len = slice.len();
let new_slice: *mut u8;
let size;
unsafe {
if len < 65535 {
// [u16, [u8]]
let mut vec = Vec::<u8>::with_capacity(len + 2);
assert_eq!(len + 2, vec.capacity());
new_slice = vec.as_mut_ptr();
std::mem::forget(vec);
ptr::write_unaligned(new_slice.cast(), len as u16);
size = 2;
} else {
// [FF, FF, u32, [u8]]
let mut vec = Vec::<u8>::with_capacity(len + 6);
assert_eq!(len + 6, vec.capacity());
new_slice = vec.as_mut_ptr();
std::mem::forget(vec);
ptr::write_unaligned(new_slice.cast(), 0xFFFFu16);
ptr::write_unaligned(new_slice.offset(2).cast(), len as u32);
size = 6;
}
ptr::copy_nonoverlapping(slice.as_ptr(), new_slice.offset(size), len);
}
BinValue {
ptr: new_slice
}
}
}
impl Drop for BinValue {
fn drop(&mut self) {
let data_len = self.len();
let len_size = if data_len < 65535 { 2 } else { 6 };
let buf_len = data_len + len_size;
unsafe {
drop(Vec::from_raw_parts(self.ptr, buf_len, buf_len));
}
}
}use std::ptr;
use std::thread::sleep;
use std::time::Duration;
fn main() {
let arr: &[u8] = &[0; 128];
println!("Data is not allocated yet!");
let mut bin_values = Vec::with_capacity(100);
for _ in 0..100 {
let val = BinValue::new(arr);
assert_eq!(val.len(), 128);
bin_values.push(val);
}
println!("Data allocated!");
let sum: usize = bin_values.iter().map(|x| x.ptr as usize).sum();
println!("Side effect! {sum}");
sleep(Duration::from_secs(10));
drop(bin_values);
println!("Data deallocated!");
sleep(Duration::from_secs(60));
}error: Undefined Behavior: attempting a write access using <3565> at alloc1400[0x0], but that tag does not exist in the borrow stack for this location*new_slice.offset(0) = len as u8;
1, мне недостаточно знаний, чтобы переписать это без unsafe.
Consumes and leaks the Vec, returning a mutable reference to the contents, &'a mut [T]. Note that the type T must outlive the chosen lifetime 'a. If the type has only static references, or none at all, then this may be chosen to be 'static.
As of Rust 1.57, this method does not reallocate or shrink the Vec, so the leaked allocation may include unused capacity that is not part of the returned slice.
This function is mainly useful for data that lives for the remainder of the program’s life. Dropping the returned reference will cause a memory leak.
Пример: оригинальная ссылка дпуостим: https://qna.habr.com
она превращается в: fsdf.namedomain
Плюс в моей стране это не нонейм, а сертифицированная марка
Это вполне неироничное предложение, так как, если, например, ты делаешь форму для ввода адреса для доставки - тебе пригодится подъезд с этажом, которые не хранятся в кладре.