22.1. ROOT Object Ownership
Table of Contents
Why ROOT Object Ownership Matters
ROOT manages many objects dynamically. Histograms, canvases, files, trees, and graphs are almost always created on the heap, sometimes behind the scenes. On top of that, ROOT has its own object ownership rules, which decide who will delete an object and when.
If you ignore ownership, you will run into two classes of problems: objects disappearing “mysteriously” and crashes due to double deletion or use of deleted memory. Understanding ROOT ownership helps you avoid both.
In ROOT, you must always know:
- Who owns an object now?
- Will ROOT delete it for me?
- If I store it somewhere, do I transfer ownership or only keep a pointer?
This chapter focuses on how ROOT handles object lifetimes, how to recognize the common traps, and how to debug ownership-related problems.
ROOT’s Basic Ownership Concepts
Automatic vs dynamic allocation
ROOT objects can be created in two main ways in C++.
On the stack (automatic storage):
void f() {
TH1F h("h", "title", 100, 0, 1);
h.Fill(0.5);
} // h is destroyed automatically hereOn the heap (dynamic storage):
void g() {
TH1F *h = new TH1F("h", "title", 100, 0, 1);
h->Fill(0.5);
// h exists until you explicitly delete it or owner decides to delete it
}For pure C++ code that does not involve ROOT containers or directories, this behaves as usual. The complexity starts when you put objects into ROOT structures such as TFile, TDirectory, TCanvas, TPad, TList, TTree or TChain.
C++ lifetime rules still apply to ROOT objects. If you create a ROOT object on the stack, do not return or store a pointer to it beyond its scope. This leads to dangling pointers and undefined behavior.
ROOT’s global directories and object lists
Most ROOT sessions have at least two important “owners” in the background:
The current directory, typically gDirectory, often a TFile or gROOT.
The current pad or canvas, gPad or a TCanvas.
Many object-creation functions automatically add the new object to one of these owners. If an object is added to an owner that deletes its contents in its destructor, the object will be deleted when the owner is destroyed or when the object is removed from its list.
This is why ownership problems often appear when you close a file or delete a canvas.
Who Owns What? Common Patterns
Objects owned by files and directories
Histograms, trees, and many other objects can be “directory objects.” When a TDirectory (for example a TFile) owns a directory object, the directory takes responsibility for its deletion.
Typical example:
TFile *f = new TFile("out.root", "RECREATE");
TH1F *h = new TH1F("h", "title", 100, 0, 1);
// By default h is associated with the current directory, which is f
h->Write(); // writes h to the file
f->Close(); // f is destroyed, and all directory-owned objects are deleted
After f->Close(), the pointer h is invalid if h was owned by the file.
You can check the directory of a histogram:
h->GetDirectory(); // returns a TDirectory* or nullptr
If it is nullptr, the histogram is not owned by a directory. If it points to a file or directory, that directory is the owner.
Any pointer to a directory-owned object becomes invalid when the owner directory is closed or destroyed. Never use a histogram, tree, or other directory object after its file or directory has been closed, unless you explicitly detached it from that directory.
To detach an object from any directory you can do:
h->SetDirectory(nullptr); // histogram is no longer owned by any TDirectoryROOT will no longer delete this histogram when a file closes. You must manage its lifetime yourself, for example by deleting it manually or letting a smart pointer handle it.
Objects owned by canvases and pads
Drawing an object often adds it to the list of primitives of the current pad or canvas. For instance:
TH1F *h = new TH1F("h","h",100,0,1);
h->FillRandom("gaus", 1000);
h->Draw(); // h is added to gPad’s list of primitives
gPad->GetListOfPrimitives() stores h. By default, TCanvas and TPad do not automatically delete the primitives they display when they are destroyed, but you can change that behavior:
pad->SetBit(kCanDelete); // now the pad will delete its primitives when clearedThis is a powerful feature but can cause double deletions if you also delete objects yourself.
If a canvas or pad is configured to delete its primitives, do not also delete those objects manually. Let the pad own them exclusively or manage everything yourself without enabling kCanDelete.
TTree and branch ownership
Trees and branches control the lifetime of certain internal objects, such as branch buffers, but they usually do not delete the user-level objects you pass to SetBranchAddress or SetBranchStatus. However, in more complex setups, such as TChain or branches that create objects internally, you can run into ownership confusion.
Important points for simple beginner analyses:
The TTree stored in a file is owned by the file or directory that contains it.
User-level objects that you connect to branches with SetBranchAddress are not deleted by the tree. You must delete them if you allocated them with new.
Objects created by TTree::Draw or TTree::Project are often written into the current directory or canvas, and follow the same rules as histograms.
Whenever you are unsure whether a tree or branch owns a helper object, check the documentation for that method and avoid manual deletion if ROOT is documented to manage it.
Common Ownership Pitfalls
Use-after-free when closing a file
A classic bug:
TFile *f = new TFile("data.root");
TH1F *h = (TH1F*)f->Get("histo");
// Do some plotting
h->Draw();
// Later
f->Close(); // h is deleted here if owned by the file
// Bug:
h->Draw(); // use-after-free, can crash or misbehaveSymptoms can be:
Segmentation fault when you try to draw or inspect the histogram.
Silent corruption, where the canvas shows garbage or nothing at all.
To avoid this, detach the histogram before closing the file if you need to keep it alive:
h->SetDirectory(nullptr);
f->Close(); // h is no longer owned by f
h->Draw(); // safeDouble deletion with manual delete and ROOT owner
Another frequent problem is deleting an object that ROOT has already deleted or will delete:
TFile *f = new TFile("out.root", "RECREATE");
TH1F *h = new TH1F("h", "h", 100, 0, 1);
// Attached to f by default
h->Write();
f->Close(); // deletes h
delete h; // double delete: undefined behaviorIf the object is directory-owned, never delete it after closing the directory. Either keep ownership by detaching it at creation time or rely completely on ROOT’s automatic deletion.
Lifetime of temporary objects returned by ROOT
Some ROOT functions return pointers to temporary objects that are owned by ROOT or by a directory. For example, TTree::Draw creates histograms or graphs internally and keeps them in memory until the current directory or global object list is cleared.
Code like this can be dangerous if you assume the returned pointer is always valid:
TH1F *h = (TH1F*)tree->Draw("x >> hx(100,0,1)");
// h is owned by the current directory
// After changing directory or closing the file, h may no longer be validIf you need to keep such an automatically created object, either clone it or detach it:
TH1F *h = (TH1F*)gDirectory->Get("hx");
h->SetDirectory(nullptr); // you now own hDebugging Ownership Problems
Recognizing ownership-related bugs
Ownership issues often show up as:
Segmentation faults when drawing, accessing, or fitting ROOT objects.
Errors when closing files or canvases.
Histograms “disappearing” from canvases or from in-memory object lists.
Fit functions or graphs losing their parameters or data unexpectedly.
Whenever you see crashes or invalid behavior that mention deleted memory in stack traces or valgrind output, consider ownership as a potential cause.
Checking owners and directories at runtime
For histograms and other directory objects, always check where they live:
TH1 *h = ...;
if (h->GetDirectory()) {
std::cout << "Histogram is owned by directory: "
<< h->GetDirectory()->GetName() << "\n";
} else {
std::cout << "Histogram is not owned by any directory.\n";
}For canvases and pads:
TCanvas *c = ...;
c->GetListOfPrimitives()->Print();
If a pointer appears in some owner list, you must consider that list’s deletion behavior before you decide to call delete or before you let the owner go out of scope.
Using valgrind or sanitizers
On Linux or macOS, tools such as valgrind or address sanitizers help you catch use-after-free or double delete errors.
Compile your macro with debug information and run it under valgrind:
valgrind root -l myMacro.CLook for messages about invalid reads or writes at addresses that correspond to ROOT objects. Combine this with your knowledge of directories and lists to infer which owner deleted the object before you used it.
Safe Patterns for Beginners
Prefer stack allocation when possible
When you just need a temporary object inside a function or macro and you do not store it in a ROOT container or directory, allocate it on the stack:
void simple() {
TH1F h("h","h",100,0,1);
h.FillRandom("gaus", 1000);
TCanvas c("c","c",800,600);
h.Draw();
c.SaveAs("histo.png");
} // h and c are destroyed automaticallyStack allocation avoids most ownership confusion because ROOT will not take over deletion responsibilities.
Use `SetDirectory(nullptr)` for independent histograms
If you want a heap-allocated histogram that should survive file closure, detach it immediately after creation:
TH1F *h = new TH1F("h","h",100,0,1);
h->SetDirectory(nullptr); // now no TDirectory will delete itLater, you can write it explicitly to a file:
TFile f("out.root","RECREATE");
h->Write(); // h content is written, but f does not own h
You must delete h yourself when you are done.
For histograms that should survive beyond file closure, call SetDirectory(nullptr) right after creation. This is one of the most useful habits to avoid ownership bugs in simple analyses.
Avoid `kCanDelete` until you need it
The kCanDelete bit allows canvases or pads to delete their primitives when they are cleared. This can simplify complex GUIs but is a common source of double deletes in beginner code.
If you are starting out, do not set kCanDelete. Instead, let canvases only display objects and manage their deletion yourself or let directories control directory-owned objects.
Be explicit about who deletes what
When you allocate with new, decide immediately who will delete the object.
Possibilities:
The object will be owned by a directory, so you will not call delete on it.
You detach the object from directories and will delete it yourself or let a smart pointer manage it.
A canvas or pad is configured to delete its primitives, in which case you never delete those objects manually.
Write down these decisions as comments next to object creation to avoid confusion later, especially in larger analyses.
Summary
ROOT object ownership is an extra layer on top of standard C++ lifetime rules. Files, directories, canvases, pads, and ROOT containers often own objects and can delete them automatically. Most difficult bugs such as use-after-free and double deletes arise when you lose track of who owns what.
To keep your analyses robust, learn to check GetDirectory() for histograms, avoid using objects after their owners are closed or deleted, use SetDirectory(nullptr) for independent histograms, and be cautious with automatic deletion features like kCanDelete. With these habits, many ROOT-specific crashes and “missing object” problems can be avoided or quickly diagnosed.
Views: 0
Where to Move
Move chapter:
- ☰ 1. Introduction to ROOT
- ☰ 1.1. What Is ROOT?
- ☰ 1.2. Installing ROOT
- ☰ 1.3. Starting ROOT
- ☰ 1.4. Your First ROOT Session
-
- ☰ 2. C++ Basics for ROOT
- ☰ 2.1. Why ROOT Uses C++
- ☰ 2.2. Variables and Data Types
- ☰ 2.3. Operators
- ☰ 2.4. Conditional Statements
- ☰ 2.5. Loops
- ☰ 2.6. Functions
- ☰ 2.7. Arrays and Vectors
-
- ☰ 3. ROOT Macros
- ☰ 3.1. What Is a ROOT Macro?
- ☰ 3.2. Running ROOT Macros
- ☰ 3.3. Functions Inside ROOT Macros
- ☰ 3.4. Compiling ROOT Macros
- ☰ 3.5. Organizing a ROOT Project
-
- ☰ 4. ROOT Objects and the ROOT Object Model
- ☰ 4.1. Introduction to ROOT Classes
- ☰ 4.2. Object Names and Titles
- ☰ 4.3. ROOT Collections
- ☰ 4.4. Inspecting ROOT Objects
-
- ☰ 5. Histograms
- ☰ 5.1. Introduction to Histograms
- ☰ 5.2. Creating a 1D Histogram
- ☰ 5.3. Filling Histograms
- ☰ 5.4. Drawing Histograms
- ☰ 5.5. Histogram Properties
- ☰ 5.6. Accessing Histogram Bins
- ☰ 5.7. Histogram Errors
- ☰ 5.8. Normalizing Histograms
- ☰ 5.9. Combining Histograms
-
- ☰ 6. Two-Dimensional Histograms
- ☰ 6.1. Creating 2D Histograms
- ☰ 6.2. Filling 2D Histograms
- ☰ 6.3. Drawing 2D Histograms
- ☰ 6.4. Projections
- ☰ 6.5. Profiles
-
- ☰ 7. Graphs
- ☰ 7.1. Introduction to TGraph
- ☰ 7.2. Creating a TGraph
- ☰ 7.3. Graph Styling
- ☰ 7.4. TGraphErrors
- ☰ 7.5. TGraphAsymmErrors
- ☰ 7.6. MultiGraph
-
- ☰ 8. Canvases and Plotting
- ☰ 8.1. TCanvas
- ☰ 8.2. Dividing a Canvas
- ☰ 8.3. Drawing Multiple Objects
- ☰ 8.4. Legends
- ☰ 8.5. Text and Annotations
- ☰ 8.6. Logarithmic Axes
- ☰ 8.7. Saving Plots
-
- ☰ 9. Styling ROOT Plots
- ☰ 9.1. ROOT Plot Styles
- ☰ 9.2. Axis Configuration
- ☰ 9.3. Line Styles
- ☰ 9.4. Marker Styles
- ☰ 9.5. Publication-Quality Figures
-
- ☰ 10. Mathematical Functions
- ☰ 10.1. Introduction to TF1
- ☰ 10.2. Built-in Functions
- ☰ 10.3. Custom Functions
- ☰ 10.4. Evaluating Functions
- ☰ 10.5. Function Integrals
-
- ☰ 11. Curve Fitting
- ☰ 11.1. Introduction to Fitting
- ☰ 11.2. Gaussian Fits
- ☰ 11.3. Polynomial Fits
- ☰ 11.4. Custom Fit Functions
- ☰ 11.5. Fit Parameters
- ☰ 11.6. Goodness of Fit
- ☰ 11.7. Fit Residuals
- ☰ 11.8. Fitting Graphs
-
- ☰ 12. ROOT Files
- ☰ 12.1. Introduction to ROOT Files
- ☰ 12.2. Creating ROOT Files
- ☰ 12.3. Writing Objects
- ☰ 12.4. Reading ROOT Files
- ☰ 12.5. Exploring ROOT Files
- ☰ 12.6. Directories Inside ROOT Files
-
- ☰ 13. TTrees
- ☰ 13.1. Introduction to TTrees
- ☰ 13.2. Creating a TTree
- ☰ 13.3. Filling a TTree
- ☰ 13.4. Writing a TTree to a File
- ☰ 13.5. Reading a TTree
- ☰ 13.6. Inspecting TTrees
- ☰ 13.7. Drawing Data from TTrees
- ☰ 13.8. Applying Selection Cuts
- ☰ 13.9. Branch Addresses
-
- ☰ 14. Event-Based Data Analysis
- ☰ 14.1. Understanding Event Data
- ☰ 14.2. Event Loops
- ☰ 14.3. Event Selection
- ☰ 14.4. Derived Quantities
- ☰ 14.5. Analysis Workflow
-
- ☰ 15. Working with Real Experimental Data
- ☰ 15.1. Importing Text Data
- ☰ 15.2. Converting Data to ROOT
- ☰ 15.3. Data Cleaning
- ☰ 15.4. Data Calibration
- ☰ 15.5. Signal and Background
-
- ☰ 16. Random Numbers and Simulations
- ☰ 16.1. Random Number Generation
- ☰ 16.2. Common Distributions
- ☰ 16.3. Simple Monte Carlo Simulation
- ☰ 16.4. Detector Resolution Simulation
- ☰ 16.5. Efficiency Simulation
-
- ☰ 17. Statistical Analysis with ROOT
- ☰ 17.1. Basic Statistics
- ☰ 17.2. Probability Distributions
- ☰ 17.3. Statistical Uncertainties
- ☰ 17.4. Chi-Square Tests
- ☰ 17.5. Confidence Intervals
-
- ☰ 18. Modern ROOT with RDataFrame
- ☰ 18.1. Introduction to RDataFrame
- ☰ 18.2. Loading Data
- ☰ 18.3. Filtering Data
- ☰ 18.4. Defining New Columns
- ☰ 18.5. Creating Histograms
- ☰ 18.6. Statistical Operations
- ☰ 18.7. Saving Results
- ☰ 18.8. Multithreading
-
- ☰ 19. ROOT and Python
- ☰ 19.1. Introduction to PyROOT
- ☰ 19.2. ROOT Objects in Python
- ☰ 19.3. Reading ROOT Files with Python
- ☰ 19.4. PyROOT and NumPy
- ☰ 19.5. PyROOT and Matplotlib
- ☰ 19.6. Choosing Between C++ and Python
-
- ☰ 20. Advanced TTree Techniques
- ☰ 20.1. Trees with Multiple Branches
- ☰ 20.2. Storing std::vector Objects
- ☰ 20.3. TChain
- ☰ 20.4. Friends
- ☰ 20.5. Efficient TTree Analysis
-
- ☰ 21. ROOT for Particle and Nuclear Physics
- ☰ 21.1. Four-Vectors
- ☰ 21.2. Particle Kinematics
- ☰ 21.3. Invariant Mass
- ☰ 21.4. Angular Distributions
- ☰ 21.5. Detector Spectra
-
- ☰ 22. Debugging and Common ROOT Problems
- ☰ 22.1. ROOT Object Ownership
- ☰ 22.2. Null Pointers
- ☰ 22.3. Segmentation Faults
- ☰ 22.4. Missing Histograms
- ☰ 22.5. ROOT File Problems
- ☰ 22.6. TTree Branch Problems
- ☰ 22.7. Histogram Range Problems
- ☰ 22.8. Fit Failures
- ☰ 22.9. Debugging ROOT Macros
-
- ☰ 23. Writing Better ROOT Analysis Code
- ☰ 23.1. Separating Analysis and Plotting
- ☰ 23.2. Using Functions
- ☰ 23.3. Using Header Files
- ☰ 23.4. Naming Conventions
- ☰ 23.5. Avoiding Hard-Coded Values
- ☰ 23.6. Configuration Parameters
- ☰ 23.7. Reproducible Analysis
- ☰ 23.8. Version Control with Git
-
- ☰ 24. Final Project
- ☰ 24.1. Project Overview
- ☰ 24.2. Analyze a complete scientific dataset using ROOT.
- ☰ 24.3. Import the Data
- ☰ 24.4. Explore the Dataset
- ☰ 24.5. Apply Data Selection
- ☰ 24.6. Create Histograms
- ☰ 24.7. Fit the Data
- ☰ 24.8. Calculate Physical Quantities
- ☰ 24.9. Estimate Statistical Uncertainties
- ☰ 24.10. Create Publication-Quality Figures
- ☰ 24.11. Save the Analysis Results
- ☰ 24.12. Write a Short Analysis Report
-
- ☰ 25. Appendices
- ☰ 25.1. A. ROOT Command Cheat Sheet
- ☰ 25.2. B. ROOT Histogram Classes
- ☰ 25.3. C. ROOT Graph Classes
- ☰ 25.4. D. Common TTree Commands
- ☰ 25.5. E. Common Drawing Options
- ☰ 25.6. F. Common Fit Functions
- ☰ 25.7. G. ROOT C++ Cheat Sheet
- ☰ 25.8. H. PyROOT Cheat Sheet
- ☰ 25.9. I. Common ROOT Errors and Solutions
- ☰ 25.10. J. Recommended ROOT Analysis Workflow
-
Comments
Please login to add a comment.
Don't have an account? Register now!