标签: mutable

我想在java中创建可变和不可变节点，除了可变之外，两者都应该是相同的。如何实现基类和可变类和不可变类的两个派生类？

看完这篇文章后关于用 PostgreSQL 实现标签的，我决定使用 PostgreSQL 的数组数据类型。

但据我所知，SQLAlchemy 中没有对可变数组的任何内置支持。我还想防止这些数组中的重复（PostgreSQL 中没有任何内置的“类集”数据类型）。

我很难找到有关如何使用和操作由 PostgreSQL 支持的 SQLAlchemy 数组（以声明方式）的任何具体示例，即使对于简单的追加/更新操作也是如此。我将如何设置 ARRAY 并附加到（如果要附加的字符串不是重复的）到 SQLAlchemy ARRAY 数据类型？

我想定义一个包含多个mutable字段的聚合（将其保存在std::setor中std::priority_queue并在将来修改它，当然会保存容器不变量）。我尝试了以下语法并成功编译：

#include <cstdlib>

int
main()
{
    struct X
    {
        mutable struct 
        {
            int i;
            int j;            
        };
    };
    X const x{};
    //x.i = 1;
    return EXIT_SUCCESS;
}

的实例clang 3.8。

但语句x.i = 1;给出错误：

错误：无法分配给具有 const 限定类型“const X”的变量“x”

我的目的是将大量连续的文件分组并向mutable该组应用关键字。

这个语法有错吗？如果是这样，编译器制造商允许这种语法（如果有的话）的意图是什么？

额外的：

代码：

#include <cstdlib>

int
main()
{
    struct X
    {
        mutable struct 
        {
            int i;
            int j;            
        };
        void f() const { i = 1; }
    };
    X const x{}; …

在 Python 3 中，一切都应该是一个对象，甚至是数字，但它们是不可变的。

是否可以为数字创建包装对象，例如 float，使其行为与普通数字完全相同，但它必须是可变的？

我想知道通过创建从 float 派生的匿名包装对象，但将其行为更改为可变的，使用内置类型函数是否可行。

>>> f = lambda x : type('', (float,), dict())(x)
>>> a = f(9)
>>> a
9.0

我必须改变哪些参数˚F做出号一个是可变的？

我如何验证数字是否可变：

我必须能够创建这样的函数f，它可以从整数值创建一个浮点值，并且在浅拷贝之后它将以以下方式运行：

>>> list_1 = [f(i) for i in [1, 2, 3, 4]]
>>> list_1
[1.0, 2.0, 3.0, 4.0]
>>> list_2 = copy.copy(list_1)
>>> list_1[0] *= 100
>>> list_1
[100.0, 2.0, 3.0, 4.0]
>>> list_2
[100.0, 2.0, 3.0, 4.0]

修改了第一个列表，两个都改变了。

也许我必须向 dict() 添加一些字段或添加额外的基类来强制执行可变性？

我是 Python 和面向对象编程的新手，有一个非常基本的 101 问题：

我看到一些方法返回一个修改过的对象，并保留原来的：

In: x="hello"
In: x.upper()
Out: 'HELLO'
In: x
Out: 'hello'

我看到其他方法修改和覆盖原始对象：

In: y=[1,2,3]
In: y.pop(0)
Out: 1
In: y
Out: [2, 3]

这两个是常态吗？有没有办法知道我正在为给定的类和方法处理哪种情况？

我有

fn plus_one(x: &i32) -> i32 {
    x + 1
}

fn plus_one_star(x: &i32) -> i32 {
    *x + 1
}

fn plus_one_mut(x: &mut i32) -> i32 {
    x + 1
}

fn plus_one_mut_star(x: &mut i32) -> i32 {
    *x + 1
}

fn main() {
    let a: i32 = 5;
    let mut b: i32 = 5;

    println!("{:?}", plus_one(&a));
    println!("{:?}", plus_one_star(&a));
    println!("{:?}", plus_one_mut(&mut b));
    println!("{:?}", plus_one_mut_star(&mut b));
    // I expect all to print '6' as I never actually mutate b …

我正在尝试在中创建一个备忘录功能Rust。问题是获取缓存的可变引用时HashMap。我对类型系统仍然没有信心，我有点挣扎。

use std::collections::HashMap;
use std::hash::Hash;

fn memoize<A, B, F>(f: F, cache: &'static HashMap<A, B>) -> impl Fn(A) -> B
where
    A: Eq + Hash + Copy,
    B: Clone,
    F: Fn(A) -> B,
{
    move |value: A| {
        if !cache.contains_key(&value) {
            cache.insert(value, f(value.clone()));
        }
        let res = cache.get(&value).unwrap();
        res.clone()
    }
}

错误是：

use std::collections::HashMap;
use std::hash::Hash;

fn memoize<A, B, F>(f: F, cache: &'static HashMap<A, B>) -> impl Fn(A) -> B
where
    A: Eq + Hash + Copy, …

在代码中我实例化了同一类的两个不同对象，怎么可能object1改变object2的属性？如何保留不同的“self.mutable”变量？我的错误在哪里？:-)

谢谢

class Class:
    mutable = {}
    immutable = 0

    def change(self):
        self.immutable = 1
        self.mutable["key"] = "value"

    def observe(self):
        print(self.immutable, self.mutable)


object1, object2 = Class(), Class()

object1.change()
object2.observe()
# output is: 0 {'key': 'value'}

我正在学习 Rust，以下代码来自在线书籍The Rust Programming Language。

fn main() {
    let mut s = String::from("hello world");

    let word = first_word(&s);

    s.clear(); // error!

    println!("the first word is: {}", word);
}


fn first_word(s: &String) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

当我运行它时，我得到这个：

C:/Users/administrator/.cargo/bin/cargo.exe run --color=always --package rust2 --bin rust2
   Compiling rust2 v0.1.0 (C:\my_projects\rust2)
error[E0502]: cannot borrow `s` as mutable because it is also …

所以我正在使用 Rust 开发一个小的 NES 模拟器，我正在尝试使用我的状态寄存器。寄存器是一个结构，其中包含一些包含布尔值的字段（标志），寄存器本身是 CPU 结构的一部分。现在，我想遍历这些字段并根据我执行的一些指令设置 bool 值。但是，我无法实现可变迭代器，我已经实现了一个 into_iter() 函数并且能够遍历字段以获取/打印 bool 值，但是如何在结构本身内改变这些值？这甚至可能吗？

pub struct StatusRegister {
    CarryFlag: bool,
    ZeroFlag: bool,
    OverflowFlag: bool,
}

impl StatusRegister {
    fn new() -> Self {
        StatusRegister {
            CarryFlag: true,
            ZeroFlag: false,
            OverflowFlag: true,
        }
    }
}

impl<'a> IntoIterator for &'a StatusRegister {
    type Item = bool;
    type IntoIter = StatusRegisterIterator<'a>;

    fn into_iter(self) -> Self::IntoIter {
        StatusRegisterIterator {
            status: self,
            index: 0,
        }
    }
}

pub struct StatusRegisterIterator<'a> {
    status: &'a StatusRegister,
    index: usize, …