Fairly new to using C++ with Godot and getting used to the conventions. My code currently crashes when I debug it in the editor and exit it. I think the issue is with a use after free/double free that I'm inadvertently doing, but I'm not sure what the best way to fix it is.

My code is the following:

#ifndef GAMEROOT_H
#define GAMEROOT_H

#include <godot_cpp/core/memory.hpp>
#include <godot_cpp/core/class_db.hpp>
#include <godot_cpp/classes/ref.hpp>
#include <godot_cpp/classes/node2d.hpp>
#include <godot_cpp/classes/circle_shape2d.hpp>
#include <godot_cpp/classes/collision_shape2d.hpp>
#include <godot_cpp/classes/character_body2d.hpp>

namespace godot
{

	struct GameCharacter : public CharacterBody2D
	{
		GDCLASS(GameCharacter, CharacterBody2D)
	public:
		CollisionShape2D *collision_shape;
		const float radius = 16.0;
		GameCharacter()
		{
			collision_shape = memnew(CollisionShape2D);
			auto shape = Ref<CircleShape2D>(memnew(CircleShape2D));
			shape->set_radius(radius);
			collision_shape->set_shape(shape);
			add_child(collision_shape);
		}
		~GameCharacter()
		{
			// memdelete(collision_shape);
		}

		static void _bind_methods()
		{
		}
	};

	struct GameRoot : public Node2D
	{
		GDCLASS(GameRoot, Node2D)

	public:
		std::vector<GameCharacter *> characters;
		GameRoot()
		{
		}
		~GameRoot()
		{
			// for (auto character : characters)
			// {
			// 	memdelete(character);
			// }
		}

		void _ready() override
		{
			auto character = memnew(GameCharacter);
			characters.emplace_back(character);
			add_child(character);
		}

		void _process(double delta) override
		{
		}

		static void _bind_methods()
		{
		}
	};

}

#endif

With my register_types.cpp being the following:

#include "register_types.h"

#include "gameroot.h"

#include <gdextension_interface.h>
#include <godot_cpp/core/defs.hpp>
#include <godot_cpp/godot.hpp>

using namespace godot;

void initialize_example_module(ModuleInitializationLevel p_level) {
	if (p_level != MODULE_INITIALIZATION_LEVEL_SCENE) {
		return;
	}

	GDREGISTER_CLASS(GameCharacter);
	GDREGISTER_CLASS(GameRoot);
}

void uninitialize_example_module(ModuleInitializationLevel p_level) {
	if (p_level != MODULE_INITIALIZATION_LEVEL_SCENE) {
		return;
	}
}

extern "C" {
// Initialization.
GDExtensionBool GDE_EXPORT example_library_init(GDExtensionInterfaceGetProcAddress p_get_proc_address, const GDExtensionClassLibraryPtr p_library, GDExtensionInitialization *r_initialization) {
	godot::GDExtensionBinding::InitObject init_obj(p_get_proc_address, p_library, r_initialization);

	init_obj.register_initializer(initialize_example_module);
	init_obj.register_terminator(uninitialize_example_module);
	init_obj.set_minimum_library_initialization_level(MODULE_INITIALIZATION_LEVEL_SCENE);

	return init_obj.init();
}
}

If I keep the memdeletes commented, then the code doesn't crash, but I assume there will be leaks since I haven't properly disposed of the memory. If I uncomment one or both of the memdeletes and run a scene with GameRoot being the only node, I start seeing crashes.

I'm using v4.3.1.rc.custom_build [6699ae789] on Ubuntu, if that helps.

  • xyz replied to this.

  • crotron Use Node::queue_free() instead of memdelete. You can also check if something hasn't already deleted the node using godot::UtilityFunctions::is_instance_valid(). It's declared in header <godot_cpp/variant/utility_functions.hpp>

      crotron Use Node::queue_free() instead of memdelete. You can also check if something hasn't already deleted the node using godot::UtilityFunctions::is_instance_valid(). It's declared in header <godot_cpp/variant/utility_functions.hpp>

          xyz
          Thanks, this fixed the problem (I guess queue_free automatically frees the memory under the hood).
          By any chance, is there any documentation/examples on proper usage of GDExtension that covers things like this?

          • xyz replied to this.

              crotron GDExtension is still kinda poorly documented and you're expected to dig through engine source when working with it. But a lot of stuff from GDScript is applicable directly to C++. The thing with nodes is that they automatically delete (free) their children. So if your node is in the editor, parented to another node, and that parent gets manually deleted, your child node will automatically be freed as well, invalidating any pointers you may hold to it. queue_free() likely checks if the node pointer is valid under the hood.

              EDIT: Here's how queue_free() does it. It calls SceneTree()::queue_delete() which adds the node to the deletion queue. SceneTree eventually flushes the queue by calling SceneTree::_flush_delete_queue(). Here the object pointer is re-acquired from ObjectDB::get_instance() which will presumably return nullptr if the instance is not valid any more.

              void SceneTree::_flush_delete_queue() {
	while (delete_queue.size()) {
		Object *obj = ObjectDB::get_instance(delete_queue.front()->get());
		if (obj) {
			memdelete(obj);
		}
		delete_queue.pop_front();
	}
}