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; }

这是一项家庭作业，我会很感激任何提示。（请不要赠品：D）这些是我得到的valgrind错误。

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

这不是严格意义上的内存泄漏，但您可以将其视为一个（这就是为什么它看起来“可能丢失”）。

这是复制问题的最小方案：

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
}

在这种情况下，内存永远不会丢失（因为你仍然有一个指向它的指针）。它也永远不会被释放，因此数据是否泄漏是值得商榷的（在各种论坛上反复讨论的事情）。

这就是为什么valgrind在这个问题上占据中间地位并说“可能会丢失”（由你来决定这是否是泄漏，取决于你想要做什么）。

在您的具体示例中，“可能丢失”的内容是stl实现的内部数据。没有什么可担心的。

C ++ Robot，家庭作业 - 由于内存泄漏而导致valgrind错误。真的需要一些提示

1 个答案: