通过T**写入const T*是否合法？C++20类型别名合规性疑问

首先直接给结论：你用const_cast把const int**转成int**并修改其指向的操作，是违反C++20标准的，属于未定义行为——哪怕你只是修改指针变量本身，并没有触碰它指向的const对象。

为什么这是未定义行为？ #

核心原因是C++的严格别名规则（Strict Aliasing Rule）。这个规则规定：你不能用一个类型的指针去访问另一个不兼容类型的对象，除非满足特定的例外情况（比如用char*访问任意类型，或者void*作为中间转换，或者基类指针访问派生类对象等）。

而int**和const int**是完全不兼容的类型，不在规则的例外范围内。在你的testConst2例子里：

const int *i;
setIntPtr2(const_cast<int **>(&i));

&i的真实类型是const int**，你把它转成int**后，通过这个指针修改i的值——本质上是用int**类型的指针去操作一个const int*类型的对象，这直接违反了严格别名规则。

你看到Godbolt上汇编相同只是巧合：编译器在某些场景下可能没有启用严格别名优化，但标准不保证这种行为在所有编译器、所有优化级别下都能正常工作。一旦编译器开启了严格别名优化（比如O2及以上），你的代码可能会出现奇怪的bug，比如变量值没有被正确更新，甚至程序崩溃。

比std::variant更简洁的合法解决方案 #

既然你想避免重复代码，同时兼容带const和不带const的next指针，模板是最理想的选择——它既能自动适配不同类型，又完全符合标准，没有任何未定义行为。

1. 针对你的指针赋值场景的模板函数

#include <iostream>

int g_i = 42;

template<typename T>
void setIntPtr(T** p) {
    // 用static_cast确保类型匹配，避免隐式转换警告
    *p = static_cast<T*>(&g_i);
}

int testNonConst() {
    int *i;
    setIntPtr(&i);
    return *i; // 返回42，合法
}

int testConst() {
    const int *i;
    setIntPtr(&i);
    return *i; // 返回42，合法
}

int main() {
    std::cout << testNonConst() << " " << testConst() << std::endl;
    return 0;
}

模板会自动推导T的类型：当传入int**时，T是int；传入const int**时，T是const int。完全不需要任何类型转换，代码简洁且安全。

2. 针对你的链表构建场景的通用模板

对于链表尾指针的管理，你可以写一个模板类来自动适配不同的节点类型：

#include <iostream>

struct WorkingElementType {
    void *pNext;
    int data;
};

struct TroublesomeElementType {
    const void *pNext;
    const char* str;
};

template<typename Node>
class LinkedListTail {
private:
    // 自动推导next指针的类型，完美适配带const和不带const的情况
    decltype(&Node::pNext) m_ppNext;
public:
    explicit LinkedListTail(Node* initial_node)
        : m_ppNext(&initial_node->pNext) {}

    void append(Node* new_node) {
        // 直接赋值，类型完全匹配
        *m_ppNext = new_node;
        // 更新尾指针到新节点的next字段
        m_ppNext = &new_node->pNext;
    }
};

int main() {
    WorkingElementType node1{nullptr, 10};
    LinkedListTail tail1(&node1);
    WorkingElementType node2{nullptr, 20};
    tail1.append(&node2);
    std::cout << static_cast<WorkingElementType*>(node1.pNext)->data << std::endl; // 输出20

    TroublesomeElementType node3{nullptr, "hello"};
    LinkedListTail tail2(&node3);
    TroublesomeElementType node4{nullptr, "world"};
    tail2.append(&node4);
    std::cout << static_cast<const TroublesomeElementType*>(node3.pNext)->str << std::endl; // 输出world

    return 0;
}

这个模板不需要任何特殊处理，不管节点的pNext是void*还是const void*，都能完美工作，完全避免了重复代码和类型转换的问题。

总结 #

不要试图用const_cast来绕开类型不兼容的问题——这会引入未定义行为，给未来埋下隐患。模板是C++中解决这类泛型问题的原生方案，既简洁又安全，完全符合标准要求。

内容的提问来源于stack exchange，提问作者Jonathan S.