ProgramGuru

Understand Manual Allocation

Understand Manual Allocation

New creates a dynamically allocated object and delete releases it.

This short example explains the pairing so that you can recognize ownership in older code before choosing safer owners.

Before this lesson, review Check Pointer Validity when needed.

What you’ll learn

  • Use dynamic memory to understand Manual Allocation.
  • Explain how the complete example produces 72.
  • Make the practice change and explain why the result changes or stays the same.

Follow a complete C++ example

This short example explains the pairing so that you can recognize ownership in older code before choosing safer owners.

Read the declarations above main before tracing its statements. Each declared name supplies the value, type or operation used later. The std:: prefix selects a name from the standard library, and cout << sends a value to the output stream.

C++17 · main.cpp · complete program

#include <iostream>

int main()  {
  int* marks = new int(72);
  std::cout << *marks << '\n';
  delete marks;
  marks = nullptr;
  return 0;
}

Expected output

72
Run in C++ compiler →

Connect the code to its result

C++17 · source used in this explanation

#include <iostream>

int main()  {
  int* marks = new int(72);
  std::cout << *marks << '\n';
  delete marks;
  marks = nullptr;
  return 0;
}

Expected output

72

New creates a dynamically allocated object and delete releases it. This short example explains the pairing so that you can recognize ownership in older code before choosing safer owners.

Trace the result: Read the complete program below from its starting values to the output operations. Each std::cout statement displays the value supplied at that point; \n begins the next line. The resulting lines, in order, are 72. In this example, distinguish what the program calculates or changes from what it actually displays.

Important mistakes and boundaries

Do not delete twice or use an object after deletion. Match new[] with delete[]; prefer containers and smart pointers in new application code.

Change the school example

C++17 · edit this complete example

#include <iostream>

int main()  {
  int* marks = new int(72);
  std::cout << *marks << '\n';
  delete marks;
  marks = nullptr;
  return 0;
}

Your task: Allocate 80 instead. Before running your edited program, predict the new output and explain which stored value, condition or object changes. Keep the rest of the example intact.

Use the complete source repeated here; this task does not depend on remembering code from another section.

Worked answer and reasoning

Worked variation: Allocate 80 instead. It prints 80 before the allocation is released.

New creates a dynamically allocated object and delete releases it. This short example explains the pairing so that you can recognize ownership in older code before choosing safer owners.

Do not delete twice or use an object after deletion. Match new[] with delete[]; prefer containers and smart pointers in new application code.

For a baseline run, save this source as main.cpp and use clang++ -std=c++17 -Wall -Wextra -pedantic main.cpp -o school, or equivalent g++ flags. Recompile after editing so that you run the updated executable.

The source and output below belong to the edited program. Compare them with the original example to see the consequence of this single change.

C++17 · worked variation · complete program

#include <iostream>

int main()  {
  int* marks = new int(80);
  std::cout << *marks << '\n';
  delete marks;
  marks = nullptr;
  return 0;
}

Expected output

80
Run in C++ compiler →

Check your understanding

C++17 · original program for this question

#include <iostream>

int main()  {
  int* marks = new int(72);
  std::cout << *marks << '\n';
  delete marks;
  marks = nullptr;
  return 0;
}
Before making the practice edit, what does the original C++17 program print?
Choose one answer. You can try again.

Answer and explanation

72

New creates a dynamically allocated object and delete releases it. This short example explains the pairing so that you can recognize ownership in older code before choosing safer owners. Do not delete twice or use an object after deletion. Match new[] with delete[]; prefer containers and smart pointers in new application code.

What to remember

New creates a dynamically allocated object and delete releases it. Do not delete twice or use an object after deletion. Match new[] with delete[]; prefer containers and smart pointers in new application code.

Useful connections: Check Pointer Validity, Give a Task a Name.

Language and design guidance: C++ Core Guidelines and C++ working draft. The draft describes an evolving language; these examples deliberately target C++17.

Reaching the recap and completing the quizzes are separate milestones.

    Next lesson: Tie Cleanup to Lifetime →