标签: raw-pointer

我有一个期望的C函数，*const std::os::raw::c_char并且在Rust中完成了以下操作：

use std::os::raw::c_char;
use std::ffi::{CString, CStr};
extern crate libc;

fn main() {
    let _test_str: *const c_char = CString::new("Hello World").unwrap().as_ptr();
    let fmt: *const c_char = CString::new("%s\n").unwrap().as_ptr();
    unsafe { libc::printf(fmt, _test_str); }

    unsafe {
        let slice = CStr::from_ptr(_test_str);
        println!("string buffer size without nul terminator: {}", slice.to_bytes().len());
    }
}

但是，我无法_test_str打印出来，上面程序的输出很简单

string buffer size without nul terminator: 0

如果我将传递给_test_str某些C函数，然后看到它是一个空字符串。我做错什么了？

谢谢！

我为C ++类实现了C-API，该类使用其他对象的共享指针来访问它们。在我的C-API中，我当然只能获得原始指针。因此，我将C-API中的原始指针“转换”为共享指针，然后将其与C ++类方法一起使用：

method(std::shared_ptr<dataType>(raw-pointer));

现在，我遇到的问题是，在“方法”的末尾，总是会调用共享指针析构函数，并且不幸的是，它杀死了我的原始指针指向的对象（我不想要）。因此，如何防止原始指针被杀死？

我已经尝试过像reset（）或swap（）这样的共享指针功能，但是它们都没有让我的原始指针走...

method(std::shared_ptr<dataType>(raw-pointer));

预期的结果是，此函数返回后，原始指针e仍指向有效对象。实际上，原始指针然后指向已删除的对象。

我正在编写一个数据包处理器并具有以下类：

class Parser {
  private:
    Packet* curr_pkt;
  public:
    void parsePacket(unsigned char byte) {
      if(byte == SyncPacket::headerVal) {
        SyncPacket pkt;
        curr_pkt = &pkt;
      }
      if(byte == SyncPacket::headerVal) {
        TypeAPacket pkt;
        curr_pkt = &pkt;
      }
    }
};
class Packet {
  public:
    void parseByte(unsigned char byte) {}
};
class SyncPacket : public Packet {
  public:
    static const unsigned char headerVal = 0x0A;
    void parseByte(unsigned char byte) {
      <do sync>
    }
};
class TypeAPacket : public Packet {
  public:
    static const unsigned char headerVal …

在实现链接列表时，我正在努力学习原始指针。一段简单的代码为我带来了意想不到的结果，因此我很难找到任何解释：

use std::cmp::PartialEq;
use std::default::Default;
use std::ptr;

pub struct LinkedListElement<T> {
    pub data: T,
    pub next: *mut LinkedListElement<T>,
}

pub struct LinkedList<T> {
    head: *mut LinkedListElement<T>,
}

impl<T: PartialEq> LinkedListElement<T> {
    pub fn new(elem: T, next: Option<*mut LinkedListElement<T>>) -> LinkedListElement<T> {
        let mut_ptr = match next {
            Some(t) => t,
            None => ptr::null_mut(),
        };
        let new_elem = LinkedListElement {
            data: elem,
            next: mut_ptr,
        };
        if !mut_ptr.is_null() {
            println!(
                "post create ll mut ptr: {:p}, post create ll mut ptr next …

我想重新分配一个具有自引用的名为的类CarJoker。
“重新分配”在这里意味着=更改对象的地址。

要使每个CarJoker生命实例都处于可调整大小的连续数组（例如池）中，此技术是必需的。

我考虑使用std::move，但是它无法CarJoker::wheels按照我希望的方式移动。
（MCVE）

#include <vector>
#include <iostream>
#include <string>
struct Wheel{
    void setBlade(){}
    void setTwinkle(){}
};
struct CarJoker{
    Wheel wa;
    Wheel wb;
    Wheel wc;
    std::vector<Wheel*> wheels;
    float hp=5;
    CarJoker(){
        wheels.push_back(&wa);
        wheels.push_back(&wb);
        wheels.push_back(&wc);
    }
    void wow(){
        //v want to apply something to every "wheel"
        for(auto wheel:wheels){
            wheel->setBlade();
        }
        //v want to apply something to some certain "wheel"
        wa.setTwinkle();
    }
};

int main(){
    CarJoker car1;
    CarJoker car2=std::move(car1);
    std::cout<<"want to 1 …

use std::sync::Arc;
use std::sync::atomic::{AtomicPtr, Ordering};
use std::thread;

fn main() {

    let mut arr = vec![1,2,3];
    let ptr = &mut arr as *mut Vec<i32>;
    println!("ptr : {:?}",ptr);
    // unsafe { (*ptr)[0] = 2; }
    let ptr_ref_1 = Arc::new(AtomicPtr::new(ptr));
    let a = thread::spawn(move || unsafe {
        let ptr_inner = (ptr_ref_1).load(Ordering::SeqCst);
        println!("ptr_inner_1 {:?}",ptr_inner);
        (*ptr_inner).push(4);
        println!("4 is done");
    });
    let ptr_ref_2 = Arc::new(AtomicPtr::new(ptr));
    let b = thread::spawn(move || unsafe {
        let ptr_inner = (ptr_ref_2).load(Ordering::SeqCst);
        println!("ptr_inner_2 {:?}",ptr_inner);

        (*ptr_inner).push(5);
        println!("5 is done");
    });
    let ptr_ref_3 = …