标签: mutable

我有关于C++中字符串的以下问题

1 >>这是一个更好的选择(考虑性能),为什么？

1.

string a;
a = "hello!";

要么

2.

string *a;
a = new string("hello!");
...
delete(a);

2 >>

string a;
a = "less"; 
a = "moreeeeeee"; 

当更大的字符串被复制到更小的字符串时,如何在c ++中处理内存管理？c ++字符串是否可变？

在线某处有一个表格或图表,显示哪些类型(内置)在python中是可变的和不可变的？

上下文

这个问题的背景是我想要使用基因表达式编程(GEP),这是一种使用Erlang的进化算法.GEP使用基于字符串的DSL称为" Karva表示法 ".Karva表示法很容易翻译成表达式解析树,但是翻译算法假定一个实现具有可变对象:在翻译过程的早期创建不完整的子表达式,并且他们自己的子表达式随后用值填充.在他们被创建时不知道.

Karva表示法的目的是保证在没有任何昂贵的编码技术或遗传密码校正的情况下创建语法正确的表达式.问题是,使用像Erlang这样的单任务编程语言,我必须在每个子表达式被填充时不断重新创建表达式树.这需要一个便宜的 - O(n)？ - 更新操作并将其转换为在指数时间内完成的操作(除非我弄错了).如果我找不到将K表达式转换为表达式树的有效函数算法,那么GEP的一个引人注目的特性就会丢失.

问题

我很欣赏K表达式翻译问题非常模糊,所以我想要的是如何将一个固有的非功能性算法(利用可变数据结构的算法)转换为不具备这种算法的算法.纯函数式编程语言如何适应计算机科学早期生成的许多算法和数据结构,这些算法和数据结构依赖于可变性来获得所需的性能特征？

我想知道无状态编程的好处,并找到了一个分享我的问题的人: 无状态编程的优点？

当我读完答案时,它让我对这个相反的问题感到好奇.有状态编程有哪些优点？似乎最近有很多关注无状态代码,但我对趋势很谨慎.

似乎有状态(即命令式)编程可能比无状态(即功能)编程更适合某些场景,并且我希望能够更好地识别哪些问题可以通过有状态编程来解决.

假设我有一个AtomicReference对象列表:

AtomicReference<List<?>> batch = new AtomicReference<List<Object>>(new ArrayList<Object>());

线程A将元素添加到此列表:batch.get().add(o);

稍后,线程B获取列表,例如,将其存储在DB中:insertBatch(batch.get());

在写入(线程A)和读取(线程B)时,是否必须执行其他同步以确保线程B按照A离开的方式查看列表,或者由AtomicReference处理？

换句话说:如果我有一个可变对象的AtomicReference,并且一个线程更改了该对象,其他线程是否会立即看到此更改？

编辑:

也许一些示例代码是有序的:

public void process(Reader in) throws IOException {
    List<Future<AtomicReference<List<Object>>>> tasks = new ArrayList<Future<AtomicReference<List<Object>>>>();
    ExecutorService exec = Executors.newFixedThreadPool(4);

    for (int i = 0; i < 4; ++i) {
        tasks.add(exec.submit(new Callable<AtomicReference<List<Object>>>() {
            @Override public AtomicReference<List<Object>> call() throws IOException {

                final AtomicReference<List<Object>> batch = new AtomicReference<List<Object>>(new ArrayList<Object>(batchSize));

                Processor.this.parser.parse(in, new Parser.Handler() {
                    @Override public void onNewObject(Object event) {
                            batch.get().add(event);

                            if (batch.get().size() >= batchSize) {
                                dao.insertBatch(batch.getAndSet(new …

根据我的理解,mutable取消constness变量

Class A {
  void foo() const {
  m_a = 5;
}
mutable int m_a;
};

但是const_cast:

void print (char * str)
{
  cout << str << endl;
}

int main () {
  const char * c = "this is a line";
  print ( const_cast<char *> (c) );
  return 0;
}

那么,是什么改变了另一个呢？

谢谢

在python中,有没有办法检查对象是不可变还是可变？

喜欢isimmutable(a)会返回True,如果a是不可变的,则返回False.

基本上,我有以下情况.注意:void*用于表示任意数据,它在实际应用程序中强类型.

class A
{
public:
   //uses intermediate buffer but doesn't change outward behavior
   //intermediate buffer is expensive to fill
   void foo(void* input_data);

   //uses intermediate buffer and DOES explicitly change something internally
   //intermediate buffer is expensive to fill
   void bar(void* input_data);

   //if input_data hasn't changed since foo, we can totally reuse what happened in foo
   //I cannot check if the data is equal quickly, so I allow the user to pass in the
   //assertion (put the honerous on them, …

假设我有一个非常简单的数据类型:

class SimpleObject:
    def __init__(self, property):
        self.property = property

    def update_property(self, value):
        self.property = value

我是一种特殊的列表来存储数据类型:

class SimpleList(collections.MutableSequence):
    def update_useful_property_of_list(self, value):
        self.useful_property_of_list = value

我存储它们:

simple1 = SimpleObject(1)
simple2 = SimpleObject(2)

simple_list = SimpleList([simple1, simple2])

有没有办法让SimpleList对象知道其成员的某个属性何时发生变化？例如,当这样的事情发生时,我怎样才能simple_list执行self.update_useful_property_of_list():

simple1.update_property(3)

为什么MobX鼓励在文档中使用可变对象？

但是，我看到了有关MobX的教程：http ://orlandohamsho.com/javascript/mobx-react-tutorial-building-first-application/

而且，他在教程中使用了不变的方法，而不是使用可变方法（参见下文）。

@action setUsers = (users) => { this.users = [...users]; （而不是推动它）

我也认为不变性方法更好（这样React.PureComponent可以工作，这意味着优化性能）

为什么MobX鼓励对对象进行变异？我应该使用哪种方法？