小编Jan*_*ner的帖子

我目前正在尝试在Rust中实现一个简单的Parser-Combinator库.为此,我希望有一个泛型map函数来转换解析器的结果.

问题是我不知道如何复制持有闭包的结构.示例是Map以下示例中的结构.它有一个mapFunction存储函数的字段,它接收前一个解析器的结果并返回一个新结果.Map它本身就是一个可以与其他解析器进一步组合的解析器.

但是,对于要组合的解析器,我需要它们是可复制的(具有Clone特征限制),但是我该如何提供Map呢？

示例:(只有伪代码,很可能无法编译)

trait Parser<A> { // Cannot have the ": Clone" bound because of `Map`.
    // Every parser needs to have a `run` function that takes the input as argument
    // and optionally produces a result and the remaining input.
    fn run(&self, input: ~str) -> Option<(A, ~str)>
}

struct Char {
    chr: char
}

impl Parser<char> for Char {
    // The char parser returns Some(char) if …

我想创建一个std::array只有数字类型的别名

template<typename T, std::size_t n, T = std::is_arithmetic<T>::value>
using NumericArray = std::array<T, n>;

这适用于整数

NumericArray<int, 2> i{1, 2};

但是,如果我想要一个浮点数或双精度,我会因非类型模板参数而出错

NumericArray<float, 2> f{1.0f, 2.0f};

还有其他方法可以做到这一点吗？

通过在GitHub上托管的Sascha Willem的C++ Vulkan演示,我注意到一些函数返回了数据类型VkBool32.

我很好奇为什么当我注意到Line时,Khronos没有使用普通的bool

typedef uint32_t VkBool32;

在vulkan.h.uint32_t定义为

typedef unsigned int uint32_t;

在stdint.h中.

我的问题是,如果一个标准的Bool只用一个字节来完成这个工作,为什么它会让Sense丢掉3个字节？我的小Recherche显示没有性能差异(请参阅哪个更快:if(bool)或if(int)？),而Khronos他们自己说他们希望最小化兼容性问题(在这种情况下,旧C没有原始布尔类型)以便专注于现代代码.

(见Trevett的报价取自这里)

一个彻底的重新设计,我们不向后兼容

我上课了widget.
我有一个抽象类base与衍生物derived_a,derived_b等等.

我希望widget保留任意数量的派生对象,base以便以后以多态方式使用它们.

我的第一次尝试看起来像这样:

#include <vector>
#include <ostream>
#include <iostream>
#include <memory>

class widget {
public:
    explicit widget(std::vector<std::unique_ptr<base>>&& params) :
    members {std::move (params)}
    {            
    }

private:
    std::vector<std::unique_ptr<base>> members;
};

并将被称为这样:

std::vector<std::unique_ptr<base>> v;
v.push_back(std::move(std::make_unique<derived_a>()));
widget w (std::move(v));

但是,这个解决方案接口冗长,而不是用户友好,特别是在提供多种类型时:

std::vector<std::unique_ptr<base>> v;
v.push_back(std::move(std::make_unique<derived_a>()));
v.push_back(std::move(std::make_unique<derived_b>()));
v.push_back(std::move(std::make_unique<derived_c>()));
v.push_back(std::move(std::make_unique<derived_a>()));
v.push_back(std::move(std::make_unique<derived_b>()));
v.push_back(std::move(std::make_unique<derived_c>()));
widget w {std::move(v)};

相反,我更喜欢沿着这条线使用

widget w {derived_a(), 
          derived_b(), 
          derived_c(), 
          derived_a(), 
          derived_b(), 
          derived_c()};

因此,widget它提供了一个随后可以变成的右值列表std::vector<unique_ptr<base>>.
我的印象是,这可以通过模仿ctor来实现,但是,尽管谷歌搜索量很大,但我并不知道如何准确地实现我的目标.

请注意,类模板解决方案看起来像这样:

widget<derived_a, 
       derived_b, 
       derived_c, 
       derived_a, …

我正在运行一个有3个结构的程序,我在二进制文件中读/写的操作如下:

struct Medico
{
    int Id_Doctor;
    int Estado;
    char Nombre[60];
    char Clave_Acceso[20];
    char Especialidad[40]; 
    struct Medico *next;
};

typedef struct Medico *Medicazos;
typedef struct Medico Meds;

Medicazos Nuevo;
FILE *Archivaldo;
char especialida[40], password[20];
char nombre_doc[60];
int estado_doc, id_doc;

Archivaldo=fopen("md.dat", "rb");
fclose(Archivaldo);

if((Archivaldo=fopen("md.dat", "rb"))==NULL)
{
    printf("No se pudo abrir el archivo de Medicos\n"); //couldnt open file msg
    exit(1);
}

rewind(Archivaldo);
while(!feof(Archivaldo))
{
    if(*Inicio != NULL)  //read from file and write in struct
    {
        Nuevo = (Medicazos) malloc (sizeof(Meds)); //new=pointer
        fread(&id_doc, sizeof(int), …

我创建了以下简单的Fibonacci实现:

#![feature(test)]
extern crate test;

pub fn fibonacci_recursive(n: u32) -> u32 {
    match n {
        0 => 0,
        1 => 1,
        _ => fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2)
    }
}

pub fn fibonacci_imperative(n: u32) -> u32 {
    match n {
        0 => 0,
        1 => 1,
        _ => {
            let mut penultimate;
            let mut last = 1;
            let mut fib = 0;
            for _ in 0..n {
                penultimate = last;
                last = fib;
                fib = penultimate + last; …

我正在研究一个需要访问特征绑定的绝对路径的Rust插件.实际上,这意味着对于以下代码,我想解析Debugas 的完整路径std::fmt::Debug.

use std::fmt::*;

#[foo]
trait Foo: Debug {}

我目前的做法包括采取的Annotatable是MultiItemDecorator为我和图案化,匹配 Annotatable::Item,在这里我匹配.node到ItemKind::Trait.然后我匹配.generic_bounds到GenericBound::Trait我检索的集合.trait_ref.path.

但是这个结构只包含path(Debug),这对我来说不够.

我最近遇到了Rust,发现可以轻松地在Rust中编写系统代码而无需触及程序集.
我只是想从我的hello.rs代码中创建一个可启动的hello world程序:

fn main() {
    println!("Hello World");
}

有没有办法使这个Rust代码可启动？