C++ Robot, homework assignment - getting valgrind errors due to memory leak. Really need some hints

Question

     enum Direction {
     NORTH = 0,
     EAST = 1,
     SOUTH = 2,
     WEST = 3 };

     struct Point {
     int x, y; };

     class Path {
         private:
         Point visited[10000];
         int visited_positions;
         bool circular;

         public:
             Path() {
             visited_positions = 1;
             circular = 0;
             Point p;
             p.x = 0;
             p.y = 0;
             visited[0] = p;
         }

         void add_point(Point p) {
             if(!circular) {
                 for(int i = 0; i < visited_positions; i++) {
                     if(visited[i].x == p.x && visited[i].y == p.y) {
                         circular = true;
                         break;
                     }
                 }
             }
             visited[visited_positions] = p;
             visited_positions++;
         }

         bool is_circular() {
             return circular;
         }

 };

 class Robot {
     private:
         Point position;
         Direction direction;
         Path path;

     public:
         Robot() {
             position.x = 0;
             position.y = 0;
             direction = NORTH;
         }

         void turn_left() {
             direction = static_cast<Direction>((direction + 3) % 4);
         }

         void turn_right() {
             direction = static_cast<Direction>((direction + 1) % 4);
         }

         void forward() {
             switch (direction) {
                 case NORTH:
                     position.y++;
                     break;
                 case EAST:
                     position.x++;
                     break;
                 case SOUTH:
                     position.y--;
                     break;
                 case WEST:
                     position.x--;
                     break;
             }
             path.add_point(position);
         }

         Point get_position() {
             return position;
         }

         bool has_gone_in_a_loop() {
             return path.is_circular();
         } };

 int main() {

     int test_cases;
     cin >> test_cases;

     string instruction_string;

     for(int tc = 0; tc != test_cases; tc++) {
         cin >> instruction_string;
         Robot skundi;

         for(size_t i = 0; i < instruction_string.size(); i++) {
             switch(instruction_string[i]) {
                 case 'H':
                     skundi.turn_right();
                     break;
                 case 'V':
                     skundi.turn_left();
                     break;
                 case 'F':
                     skundi.forward();
                     break;
             }
         }
         if(skundi.has_gone_in_a_loop()) {
             cout << "Circular" << endl;
         }
         else {
             cout << "OK" << endl;
         }
     }
     return 0; }

This is a homework assignment and i would be grateful for any hints. (please no giveaways :D) These are the valgrind errors i am getting.

Memcheck, a memory error detector
Invalid read of size 8
Using Valgrind:

**HEAP SUMMARY:**
in use at exit: 16,352 bytes in 1 blocks
total heap usage: 14 allocs, 13 frees, 28,907 bytes allocated
16,352 bytes in 1 blocks are possibly lost in loss record 1 of 1

at 0xX: operator new(unsigned long) (vg_replace_malloc.c:298....)
by 0xX: std::string::_Rep::_S_create(unsigned long, unsigned long, std::allocator const&) (in /usr/lib64/libstdc++.so.6.0.13)
by 0xX: std::string::_Rep::_M_clone(std::allocator const&, unsigned long) (in /usr/lib64/libstdc++.so.6.0.13)

by 0xX: std::string::reserve(unsigned long) (in /usr/lib64/libstdc++)
by 0xX: std::basic_istream >& std::operator>>, std::allocator >(std::basic_istream >&, std::basic_string, std::allocator >&) (in /usr/lib64/libstdc++)

**LEAK SUMMARY:**
definitely lost: 0 bytes in 0 blocks
indirectly lost: 0 bytes in 0 blocks
possibly lost: 16,355 bytes in 1 blocks
still reachable: 0 bytes in 0 blocks
suppressed: 0 bytes in 0 blocks
For counts of detected and suppressed errors, rerun with: -v
ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 6 from 6)

Answer 1

This is not strictly a memory leak, though you can view it as one (that's why it appears as "possibly lost").

Here's a minimal scenario that replicates the issue:

static int *global_data = nullptr;
int main(int, char**)
{
    global_data = new int{9}; // allocated for the duration of the application
                              // we rely on the program exitting for deallocation
}

In this case, the memory is never lost (because you still have a pointer pointing to it). It is also never deallocated, so whether the data is a leak or not is debatable (and something that has been debated again and again on various forums).

That is why valgrind takes the middle ground on this one and says "possibly lost" (it is up to you to decide if this is a leak or not, depending on what you are trying to do).

In your concrete example, what is "possibly lost" is internal data of the stl implementation. There is nothing to worry about.