在全局范围内调用 new 运算符

发布于 2024-12-14 10:00:00 字数 451 浏览 2 评论 0原文

我和一位同事正在争论在全局范围内编写此代码的编译性：

int* g_pMyInt = new int;

我的争论围绕着调用函数（new 是）这一事实在全球范围内是不可能的。令我惊讶的是，上面的行编译得很好（MS-VC8 和 Apple 的 LLVM 3）。

所以我继续尝试：

int* foo()
{
    return new int;
}
int* g_pMyInt = foo(); // Still global scope.

而且，它也编译好了并且工作得像一个魅力（稍后用一个类进行了测试） whos 构造函数/析构函数打印出一条消息。演员的留言通过了，医生没有。那次不太惊讶。）

虽然这对我来说似乎非常错误（没有有序/正确的方式/时间来调用删除），编译器不禁止它。为什么？

原文

A colleague and I were arguing the compilability of writing this at global scope:

int* g_pMyInt = new int;

My arguments revolved around the fact that calling a function (which new is)
at global scope was impossible. To my surprise, the above line compiled just fine
(MS-VC8 & Apple's LLVM 3).

So I went on and tried:

int* foo()
{
    return new int;
}
int* g_pMyInt = foo(); // Still global scope.

And, that compiled as well and worked like a charm (tested later with a class
whos constructor/destructor printed out a message. The ctor's message
went through, the dtor's didn't. Less surprised that time.)

While this appears very wrong to me (no orderly/right way/time to call delete),
it's not prohibited by the compiler. Why?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

纸短情长 2024-12-21 10:00:00

为什么不应该被允许？您所做的只是初始化一个全局变量，我们完全欢迎您这样做，即使初始化涉及函数调用：

int i = 5 + 6;

double j(std::sin(1.25));

const Foo k = get_my_foo_on(i, 11, true);

std::ostream & os(std::cout << "hello world\n");

int * p(new int);                // fine but very last-century
std::unique_ptr<int> q(new int); // ah, welcome to the real world

int main() { /* ... */ }

当然，您需要担心删除动态分配的对象，无论是它们是否在全局范围内分配...拥有资源的包装类（例如unique_ptr）将是理想的解决方案。

Why shouldn't it be allowed? All you're doing is initializing a global variable, which you are perfectly welcome to do, even if the initialization involves a function call:

int i = 5 + 6;

double j(std::sin(1.25));

const Foo k = get_my_foo_on(i, 11, true);

std::ostream & os(std::cout << "hello world\n");

int * p(new int);                // fine but very last-century
std::unique_ptr<int> q(new int); // ah, welcome to the real world

int main() { /* ... */ }

Of course you'll need to worry about deleting dynamically allocated objects, whether they were allocated at global scope or not... a resource-owning wrapper class such as unique_ptr would be the ideal solution.

回复收藏 0 原文