mutable

I've defined a class where I'd like a public property to appear as though it is backed by an NSArray . That is simple enough, but in my case the actual backing ivar is an NSMutableArray : @interface Foo { NSMutableArray* array; } @property (nonatomic, retain) NSArray* array; @end In my implementation file ( *.m ) I @synthesize the property but I immediately run into warnings because using self.words is the same as trying to modifying an NSArray . What is the correct way to do this? Thanks! I would declare a readonly NSArray in your header and override the getter for that array to return a copy

This question already has answers here : Why are python strings and tuples are made immutable? (6 answers) Possible Duplicate: Why are python strings and tuples are made immutable? What lower-level design makes tuple not mutable in Python? Why this feature is useful? A few reasons: Mutable objects like lists cannot be used as dictionary keys or set members in Python, since they are not hashable . If lists were given __hash__ methods based on their contents, the values returned could change as the contents change, which violates the contract for hash values. If Python only had mutable sequences

This one's really an offshoot of this question , but I think it deserves its own answer. According to section 15.13 of the ECMA-334 (on the using statement, below referred to as resource-acquisition ): Local variables declared in a resource-acquisition are read-only, and shall include an initializer. A compile-time error occurs if the embedded statement attempts to modify these local variables (via assignment or the ++ and -- operators) or pass them as ref or out parameters. This seems to explain why the code below is illegal. struct Mutable : IDisposable { public int Field; public void

I have a class(A) that has a struct variable (S). In one function of this class I call a mutating function on struct variable,this function takes a closure. Body of this closure checks the struct variable's name property. Struct's mutating function in turns calls a function of some class(B). This class's function again takes a closure. In this closure's body mutate the struct, i.e. change the name property, and call the closure that was supplied by the first class. When the first class (A) closure is called where we are inspecting the struct's name property, it is never changed. But in step 2

Why was the MutableString class deprecated in Python 2.6; and why was it removed in Python 3? The MutableString class was meant to be educational, and not to be used in real programs. If you look at the implementation, you'd see that you can't really use this in a serious application requiring mutable strings. If you need mutable bytestrings, you might consider using bytearray that's available in Python 2.6 and 3.x. The implementation doesn't create new strings every time you modify the old one, so it is much more faster and usable. It also supports the buffer protocol properly so it can be

From my understanding , mutable cancels the constness of a variable Class A { void foo() const { m_a = 5; } mutable int m_a; }; But also 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; } So , what changes one from the other ? Thanks const_cast cannot cancel constness of an object. const_cast can only remove constness from an access path to an object. Access path is a pointer or a reference to an object. Removing the constness from the access path has absolutely no effect on the object

I've been going over and over this in my head, and I can't seem to come up with a good reason why C# closures are mutable. It just seems like a good way to get some unintended consequences if you aren't aware of exactly what's happening. Maybe someone who is a little more knowledgeable can shed some light on why the designers of C# would allow state to change in a closure? Example: var foo = "hello"; Action bar = () => Console.WriteLine(foo); bar(); foo = "goodbye"; bar(); This will print "hello" for the first call, but the outside state changes for the second call, printing "goodbye." The

I am doing calculations with BigIntegers that uses a loop that calls multiply() about 100 billion times, and the new object creation from the BigInteger is making it very slow. I was hoping somebody had written or found a MutableBigInteger class. I found the MutableBigInteger in the java.math package, but it is private and when I copy the code into a new class, many errors come up, most of which I don't know how to fix. What implementations exist of a Java class like MutableBigInteger that allows modifying the value in place? Is their any particular reason you cannot use reflection to gain