全部问题

有一段代码，其中有很多条件，每个条件都可能导致错误（超出数组范围）。如果发生错误时（例如，在其中第二个），如何检查所有条件，检查其余的停止？

def LoseCheck(x,y,_matrix,k): #проверка, является ли ход проигрышным
    try:  
        if (
            _matrix[x-2][y] == _matrix[x-1][y] == _matrix[x][y] == 1 
            or _matrix[x][y] == _matrix[x+1][y] == _matrix[x+2][y] == 1 
            or _matrix[x-1][y] == _matrix[x][y] == _matrix[x+1][y] == 1 
            or _matrix[x][y-2] == _matrix[x][y-1] == _matrix[x][y] == 1 
            or _matrix[x][y] == _matrix[x][y+1] == _matrix[x][y+2] == 1
            or _matrix[x][y-1] == _matrix[x][y] == _matrix[x][y+1] == 1 
            or _matrix[x-2][y+2] == _matrix[x-1][y+1] == _matrix[x][y] == 1 
            or _matrix[x][y] == _matrix[x+1][y-1] == _matrix[x+2][y-2] == 1 
            or _matrix[x-1][y+1] == _matrix[x][y] == _matrix[x+1][y-1] == 1 
            or _matrix[x-2][y-2] == _matrix[x-1][y-1] == _matrix[x][y] == 1 
            or _matrix[x][y] == _matrix[x+1][y+1] == _matrix[x+2][y+2] == 1 
            or _matrix[x-1][y-1] == _matrix[x][y] == _matrix[x+1][y+1] == 1
        ):
            if k%2 == 0:
                print("Второй игрок проиграл!")
                return 1
            else:
                print("Первый игрок проиграл!")
                return 1
        return 0  
    except:
        pass      

我开始慢慢掌握 Unity（当然是基于 YouTube 的指南）。我正在用立方体制作一个简单的拼图。目标是拉出红色立方体。

Rigidbody所有立方体都用Box Collider零摩擦材料悬挂。

问题在于，当一种类型的三个或更多立方体被推入另一种类型时，即使没有初步加速，它们也只是被推过它。此外，如果立方体少于三个，则一切或多或少都能正常工作，尽管仍然尝试通过）

如果此时移动蓝色块，就会发生这种情况 xD

看起来很有趣，但他们不应该这样做。我尝试改变 yRigidbody Interpolate和Collision Detection，没有效果。

我用谷歌搜索，但没有找到答案（很可能我谷歌搜索得不好）

另一个额外的问题是：如何确保立方体在移动时不会卡在角落？在舞台上，我似乎把一切都安排好了Freeze Rotation，Freeze Position但他们还是撞到了一起。到目前为止，我刚刚将预制件的碰撞器从 1 减少到 0.99，但它工作不可靠，而且看起来很歪。

我附上了脚本，它对于所有多维数据集都是相同的：

using System;
using UnityEngine;

public class CubeMovement : MonoBehaviour
{
    [SerializeField] KeyCode moveForwardKey;
    [SerializeField] KeyCode moveBackKey;
    [SerializeField] Vector3 moveDirection;

    private AudioSource audioSource;

    private Rigidbody rb;

    public static event Action OnTrigger;
    void Start()
    {
        audioSource = GetComponent<AudioSource>();
        rb = GetComponent<Rigidbody>();
    }
    private void FixedUpdate()
    {
        if (Input.GetKey(moveForwardKey))
        {
            rb.velocity += moveDirection;
        }
        if (Input.GetKey(moveBackKey))
        {
            rb.velocity -= moveDirection;
        }
    }
    private void OnTriggerEnter(Collider other)
    {
        if(this.CompareTag("Player") && other.CompareTag("Finish"))
        {
            if (OnTrigger != null)
            {
                OnTrigger.Invoke();
            }
        }
    }
    private void OnCollisionEnter(Collision collision)
    {
        audioSource.Play();
    }
}

有一些大型类是用 C++ 实现的。我需要在 C# 项目中使用它。为了节省时间并且不重写代码，我选择了用 C++/CLI 编写此类的包装器，并将其全部放入类库中。但是，我在使用 1 种方法时遇到了困难，该方法将回调函数的指针作为参数。

情况如下：本机类有一个方法，该方法接受一个指向某个函数的指针，该函数在某些事件发生时被调用。任务是在包装类中提供类似的方法，但将分别传递委托而不是指针。

我简化了代码来演示该问题：

class CFoo
{
public:

    bool FooMember;

    CFoo()
    {
        FooMember = true;
    }

    void Call(void(*callback)(CFoo))
    {
        CFoo foo = CFoo();
        std::thread thr([=]() { callback(foo); });
        thr.join();
    }
};

ref class FooWrapper
{
public:

    delegate void ManagedCallback(FooWrapper^ foo);

private:

    delegate void UnmanagedCallback(CFoo foo);

    ManagedCallback^ Callback;

    void FooProc(CFoo foo)
    {
        std::cout << "FooProc: " << (foo.FooMember ? "true" : "false") << std::endl;
        Callback(gcnew FooWrapper(&foo));
    }

public:

    CFoo* foo;

    FooWrapper()
    {
        foo = new CFoo();
    }

    FooWrapper(CFoo* foo)
    {
        this->foo = foo;
    }

    void Call(ManagedCallback^ callback)
    {
        Callback = callback;

        UnmanagedCallback^ unmanagedCallback = gcnew UnmanagedCallback(this, &FooWrapper::FooProc);
        IntPtr^ methodPtr = Marshal::GetFunctionPointerForDelegate(unmanagedCallback);
        foo->Call(static_cast<void(*)(CFoo)>(methodPtr->ToPointer()));
    }
};

ref class Program
{
public:

    FooWrapper^ Foo;

    void Callback(FooWrapper^ foo)
    {
        Foo = foo;
        std::cout << "Callback: " << (foo->foo->FooMember ? "true" : "false") << std::endl;
    }

    void Start()
    {
        FooWrapper^ w = gcnew FooWrapper();
        w->Call(gcnew FooWrapper::ManagedCallback(this, &Program::Callback));
    }
};

int main(array<System::String ^> ^args)
{
    Program^ c = gcnew Program();
    c->Start();

    CFoo foo = *c->Foo->foo; // <- AccessViolationException

    return 0;
}

控制台输出：

FooProc：正确

回调：true

一旦CFoo::Call方法中创建的线程完成执行，类成员FooWrapper::foo就会被销毁。我尝试查看对析构函数的调用FooWrapper并CFoo确保该对象没有被破坏。您还可以在尝试取消引用之前查看指针本身的数值，并确保指针有效。

例外：

System.AccessViolationException：“尝试读取或写入受保护的内存。这通常表明其他内存已损坏。

也许有一种更好的方法来实现包装器，或者您可以以某种方式修复现有的方法。

任务是：

给定一个字符串列表。有必要从列表中删除每隔一个元素。例如：

['1', '2', '3', '4'] => ['2', '4']
['qwerty', 'asdfg', 'zxcvb'] => ['asdfg']

我想写一个单行解决方案来解决这个问题。我的尝试：

return [i for i in spisok if spisok.index(i) % 2 == 0]

当然，该代码不适用于包含重复值的列表，因为该方法返回列表中第一个匹配项的list.index()索引。当然，用多行代码很容易解决这个问题，比如

i = 1
while index < len(spisok):
    del spisok[i]
    i += 1
return spisok

但是，是否有一个单一的解决方案可以解决这个问题呢？我想知道

• 最简洁的解决方案
• 最清晰的解决方案
• 最令人困惑的解决方案(☻)

#include <iostream>


template <typename T, typename U>
struct is_same{
    const static bool value = false;
};

template <typename T>
struct is_same<T, T>{
    const static bool value = true;
};



template<typename T, typename U>
bool same(T, U){
    return is_same<T, U>::value;
}


int main(){

    const int x = 0;
    int y;

    std::cout << is_same<const int, int>::value << '\n'; // false 
    std::cout << same(x, y) << '\n';                     // true

}

如果类型 x 是 const int 并且 y 是 int，为什么同样会返回 true？应该怎么做才能像 is_same 一样返回 false？