标签: local-variables

我有一个以下代码片段:

def isolation_level(level):
    def decorator(fn):
        def recur(level, *args, **kwargs):
            if connection.inside_block:
                if connection.isolation_level < level:
                    raise IsolationLevelError(connection)
                else:
                    fn(*args, **kwargs)
            else:
                connection.enter_block()
                try:
                    connection.set_isolation_level(level)
                    fn(*args, **kwargs)
                    connection.commit()
                except IsolationLevelError, e:
                    connection.rollback()
                    recur(e.level, *args, **kwargs)
                finally:
                    connection.leave_block()
        def newfn(*args, **kwargs):
            if level is None: # <<<< ERROR MESSAGE HERE, Unbound local variable `level`
                if len(args):
                    if hasattr(args[0], 'isolation_level'):
                        level = args[0].isolation_level
                elif kwargs.has_key('self'):
                    if hasattr(kwargs['self'], 'isolation_level'):
                        level = kwargs.pop('self', 1) 
            if connection.is_dirty():
                connection.commit()
            recur(level, *args, **kwargs)
        return newfn
    return decorator

它的作用并不重要,但是我将它以原始形式发布,因为我无法用更简单的方式重新创建这种情况. …

这是C和C++的理论问题.

我有一个4x4矩阵类型,其定义非常简单:

typedef float   Matrix44[16];

我也有很多方法将Matrix44参数作为参数,例如:

bool matrixIsIdentity(Matrix44 m);

我还有一个自定义内存分配方案,在堆上预先分配大面积内存,然后我手动管理该预取内存的分配.因此我已经用我自己的实现替换/重载malloc/ new.问题是,自定义malloc和new本质上都返回一个指针,而不是一个对象.

通常,我只会做以下事情:

   // Method 1
1] Matrix44 mat = { ... };
2] bool res = matrixIsIdentity(mat);

但是,第1行分配mat在堆栈上,而不是我想要的自定义内存区域.另一种选择是:

    // Method 2
1]  Matrix44 *mmat = myMalloc(...);
1a] Matrix44 *nmat = new ...
2]  bool res = matrixIsIdentity(*mat);

这里的问题是我必须使用解引用运算符来丢弃我的代码.现在一个选择是重写所有要采用的方法Matrix44*,但是,由于这是理论上的,我想假设这不是一个选项.

因此我的问题变成:有没有办法在C和/或C++中声明一个自动变量Method 1 Line 1,但它是否遵循备用分配方案(如Method 2 Line 1)？

(我很欣赏这可能涉及与编译器相关的讨论,但我还没有为此添加标签)

当声明一个仅使用一个函数的常量时,该变量是否应该在本地声明,因为它仅由该函数使用,或全局声明,因为它永远不会改变？

IE更好:

CONSTANT = (1, 3, 5, 8)

##SOME OTHER CODE HERE

def function1(arg):
    if arg in CONSTANT:
        do something

要么:

def function1(arg):
    CONSTANT = (1, 3, 5, 8)
    if arg in CONSTANT:
        do something

我知道这两者之间并没有太大区别,但我只是想知道这两种做法中哪一种是首选的,因为我刚开始并希望养成良好的习惯.

想象一下这个C#代码在某种方法中:

SomeClass.SomeGlobalStaticDictionary = new Dictionary<int, string>()
{
    {0, "value"},
};

假设没有人使用任何显式内存屏障或锁定来访问字典.

如果没有进行优化,则全局字典应为null(初始值)或具有一个条目的正确构造的字典.

问题是:可以重新排序Add调用和分配给SomeGlobalStaticDictionary的效果,以便其他一些线程看到一个空的非null SomeGlobalStaticDictionary(或任何其他无效的部分构造的字典？)

如果SomeGlobalStaticDictionary是易变的,答案会改变吗？

在阅读http://msdn.microsoft.com/en-us/magazine/jj863136.aspx(以及它的第二部分)之后,我从理论上了解到,因为在源代码中分配了一个变量,其他线程可能会因为很多原因.我查看了IL代码,但问题是JIT编译器和/或CPU是否允许在分配SomGlobalStaticDictionary之前不"刷新"Add调用对其他线程的影响.

如果它们是类变量,那么有一个问题询问lazy vals 的实现.如何实现局部变量,例如

def foo[A](a: => A) = {
  lazy val x: A = a
  // return something that uses x
}

我有一个类似下面的类:

class Program
    {
        static void Main(string[] args)
        {
            var outputWindow = new OutputWindow();

            var threads = new List<Thread>();

            Action action = () => outputWindow.Display(20);

            for (int i = 0; i < 10; i++)
            {
                var thread = new Thread(() => action()) {Name = "Thread " + i};
                threads.Add(thread);
            }

            foreach (var thread in threads)
            {
                thread.Start();
            }
        }
    }

    public class OutputWindow
    {
        public void Display(int x)
        {
            for (int i = 0; i < x; i++)
            {
                Console.WriteLine(Thread.CurrentThread.Name …

如果存在全局变量并且函数具有相同名称的参数,并且期望的结果是本地变量和全局变量的总和,那么在这种特定情况下我们如何引用全局函数？我知道这样做并不好.但只是为了好奇而要求.

int foo = 100;

int bar(int foo)
{
    int sum=foo+foo; // sum adds local variable and a global variable
    return sum;
}

int main()
{
    int result = bar(12);
    return 0;
}

在许多人都知道的C中,堆栈是所有局部变量所在的位置.堆栈是最后输出数据结构的第一个意味着您只能访问最近推送到其上的内容.所以给出以下代码:

int k = 5;
int j = 3;
short int i;

if (k > j) i = 1;

显然这是无用的代码,没有任何实际意义,但我试图绕过一些东西.

对于short int i声明,我假设在堆栈上分配了2个字节.对于4个字节的int k和int j,使用值5和3分配.因此堆栈将如下所示

----------   <- stack pointer
int i
----------
int k = 5
----------
int j = 3
----------

所以对于if语句,你必须弹出int i来获得条件k和j,如果是这样,int我去哪里？如果这是C执行局部变量的方式,这一切似乎都非常耗时且乏味.

那么这实际上C是怎么做的,还是我把它全部搞砸了？

我有以下功能

function test()

  local function test2()
      print(a)
  end
  local a = 1
  test2()
end

test()

这打印出零

以下脚本

local a = 1
function test()

    local function test2()
        print(a)
    end

    test2()
end

test()

打印1.

我不明白.我认为声明一个局部变量使它在整个块中有效.由于变量'a'在test() - 函数范围内声明,并且test2() - 函数在同一范围内声明,为什么test2()不能访问test()局部变量？

在下面,input_1更改:

def method_1(a)
  a << "new value"
end

input_1 = []
method_1(input_1)
input_1 #=> ["new value"]

在下面,input_2不会改变:

def method_2(a)
  a = ["new value"]
end

input_2 = []
method_2(input_2)
input_2 #=> []

为什么input_1改变input_2而不改变？