theory

In the past I had the need to clone objects, only to find that they don't implement a Clone() method, forcing me to do it by hand (create a new instance and copy all properties from the original to the new one) Why isn't cloning as easy as duplicating the memory block the object is allocated in, and thus have the Clone method in the object class, having all classes in .NET inherit it? Because that wouldn't perform a deep clone, which is usually what clones really need to be. Imagine you have a reference to an array, or a list... simply copying the memory taken by your object will simply clone

As the title suggests I am new to C and have a mid-term coming up shortly. I am revising from past papers currently and a recurring theme is double free problem. I understand that it is the process of calling free() on the same memory location twice, but I have a couple of questions that I'm not 100% sure how to answer: Question 1: What is the result of a double free in C, and why is it such a problem? This will cause a double free: char* ptr = malloc(sizeof(char)); *ptr = 'a'; free(ptr); free(ptr); My response to this would be, would it return a 0x0 memory address and cause a system

After reading this question I started to wonder: is it possible to have a shuffling algorithm which does not modify or copy the original list? To make it clear: Imagine you are given a list of objects. The list size can be arbitrary, but assume it's pretty large (say, 10,000,000 items). You need to print out the items of the list in random order, and you need to do it as fast as possible. However, you should not: Copy the original list, because it's very large and copying would waste a LOT of memory (probably hitting the limits of available RAM); Modify the original list, because it's sorted

What is the basic difference between convergence and idempotence in Chef? Convergence and idempotence are not Chef-specific. They're generally attributed to configuration management theory, though have use in other fields, notably mathematics. Let's start with the more basic, idempotent. We're going to ignore the mathematic use of idempotent, and focus instead on what configuration management people mean when they talk about it. That is: "multiple applications of the same action do not have side effects on the system state." A simple example of an idempotent operation is mkdir -p : mkdir -p

Is there a simple way to determine whether a grammar is LL(1), LR(0), SLR(1)... just from looking on the grammar without doing any complex analysis? For instance: To decide whether a BNF Grammar is LL(1) you have to calculate First and Follow sets - which can be time consuming in some cases. Has anybody got an idea how to do this faster? Any help would really be appreciated! First off, a bit of pedantry. You cannot determine whether a language is LL(1) from inspecting a grammar for it, you can only make statements about the grammar itself. It is perfectly possible to write non-LL(1) grammars

This is admittedly a rather loose question. My current understanding of singletons is that they are a class that you set up in such a way that only one instance is ever created. This sounds a lot like a static class to me. The main difference being that with a static class you don't / can't instance it, you just use it such as Math.pi() . With a singleton class, you would still need to do something like singleton firstSingleton = new singleton(); firstSingleton.set_name("foo"); singleton secondSingleton = new singleton(); Correct me if i am wrong, but firstSingleton == secondSingleton right

Theory question here: Why does specifying table.field IS NULL or table.field IS NOT NULL not work on a join condition (left or right join for instance) but only in the where condition? Non working Example: -this should return all shipments with any returns (non null values) filtered out. However, this returns all shipments regardless if anything meets the [r.id is null] statement. SELECT * FROM shipments s LEFT OUTER JOIN returns r ON s.id = r.id AND r.id is null WHERE s.day >= CURDATE() - INTERVAL 10 DAY Working example: -This returns the correct amount of rows which is total shipments, less

Which is the fastest way to implement an operation that returns the absolute value of a number? x=root(x²) or if !isPositive(x): x=x*(-1) Actually this question can be translated as, how fast is an if (and why please). My college programing professors always told me to avoid if s for they are extremely slow, but I always forgot to ask how slow and why. Does anybody here know? kquinn Conditionals are slower than plain arithmetic operations, but much, much faster than something as silly as calculating the square root. Rules of thumb from my assembly days: Integer or bitwise op: 1 cycle Floating