C++转C#：如何处理同类型结构体内部的结构体指针？

Hey there! I see you're working on converting C++ code to C# for a personal learning project using Unity, and you're stuck on handling struct pointers inside the same struct type—like those HexTri m_nbAB, m_nbBC, m_nbCA members (I assume these are pointers/references in your original C++ code). Let's walk through your options clearly.

Key Difference Between C++ and C# Structs #

First, it's critical to grasp this core distinction:

• In C++, structs can hold pointers to other structs of the same type effortlessly, giving you reference semantics (you’re pointing to the exact same instance in memory).
• In C#, struct is a value type—if you declare a struct member inside another struct, it gets copied by value instead of referenced. That’s why your current approach isn’t replicating the original C++ behavior.

Recommended Solution: Switch to class #

The simplest and most idiomatic way to mirror the pointer/reference logic from C++ is to convert your HexTri struct to a C# class. Here’s why this works so well:

• C# class is a reference type, so when you declare a member like HexTri m_nbAB; inside the class, it acts exactly like a C++ pointer/reference—it points to the same in-memory instance, no value duplication.
• This aligns perfectly with your original C++ logic for tracking adjacent HexTri instances.
• Unity integrates seamlessly with classes, and you won’t have to deal with unsafe code or manual memory management (C#’s garbage collector handles that for you).

Example Snippet (C# Class Version) #

public class HexTri
{
    // Your existing Unity-compatible members (e.g., Vector3 positions)
    public Vector3 CenterPosition;
    
    // Adjacent HexTri references (matches C++ pointer behavior)
    public HexTri m_nbAB;
    public HexTri m_nbBC;
    public HexTri m_nbCA;
    
    // Add your methods here, just like you would in the original C++ code
}

Alternative: Unsafe Code with Struct Pointers (Not Recommended) #

If you absolutely need to keep using struct for specific reasons, you can use C#’s unsafe code feature to work with pointers. However, this is not ideal for Unity projects (or most C# work) because:

• You’ll need to enable unsafe code in your Unity project settings (Edit > Project Settings > Player > Allow Unsafe Code).
• You have to manually manage memory, which comes with risks like leaks or invalid memory access.
• It’s non-idiomatic C# and makes your code harder to read, debug, and maintain.

Example Snippet (Unsafe Struct Version) #

public unsafe struct HexTri
{
    public Vector3 CenterPosition;
    
    // Pointers to adjacent HexTri instances
    public HexTri* m_nbAB;
    public HexTri* m_nbBC;
    public HexTri* m_nbCA;
}

Final Recommendation #

For your learning project (and almost all real-world Unity development), go with the class approach. It’s straightforward, matches your original C++ logic perfectly, and avoids the headaches of unsafe code. You’ll be able to track adjacent HexTri instances just like you did with pointers in C++.

内容的提问来源于stack exchange，提问作者user3884747