[已解决]类内定义了一个私有成员的IMGAE对象，在public里面定义了一个调用该对象的

猪猪虾

这个坎。。。。
我定义的Mainplane.h文件 里面的静态成员static IMAGE imgMyplane;所以在Mainplane.cpp的文件头做了类外的声明
然后在成员函数getImage_Myplane里面返回这个对象，我也尝试了不定义静态的情况，一样的直接崩溃,在主程序
GameMain.cpp文件调用到这个getImage_Myplane的时候  。。。。





Mainplane.h文件

1. #pragma once
   
2. #include<graphics.h>
   
3. #include<cstring>
   
4. #include<vector>
   
5. //#include "GameMain.h"
   
6. using namespace std;
   
7. class GameMain;
   
8. 
   
9. class MyPlane
   
10. {
    
11. public:
    
12.         MyPlane();
    
13.         //static IMAGE getImages();    //私有成员可以在public里面，通过函数来间接访问和修改
    
14.         void Move(int dx, int dy);
    
15.         static IMAGE getImage_Myplane();
    
16. 
    
17. 
    
18.         int My_current_posiX;
    
19.         int My_current_posiY;
    
20.         int width;
    
21.         int height;
    
22. 
    
23. private:
    
24.         static IMAGE imgMyplane;
    
25.         GameMain *GM;
    
26. };
    

复制代码

Mainplane.cpp文件

1. #pragma once
   
2. #include<graphics.h>
   
3. #include<cstring>
   
4. #include<vector>
   
5. #include "MyPlane.h"
   
6. #include "GameMain.h"
   
7. using namespace std;
   
8. 
   
9. //静态成员，需要在类外进行声明
   
10. IMAGE MyPlane::imgMyplane;  // 这一行为 imgMyplane 分配内存空间
    
11. 
    
12. //`MyPlane` 类在头文件 `MyPlane.h` 中声明，而 `imgMyplane` 的定义位于与类实现相关联的源文件
    
13. //`MyPlane.cpp` 中。这样，您就解决了 `LNK2001` 错误。
    
14. //如果您将所有代码放在同一个文件中，那么只需在类定义之后添加 `IMAGE MyPlane::imgMyplane; ` 这一行即可。
    
15. //IMAGE MyPlane::imgMyplane;  // 这一行为 imgMyplane 分配内存空间
    
16. 
    
17. 
    
18. MyPlane::MyPlane()
    
19. {
    
20.         width = 100;
    
21.         height = 125;
    
22.         loadimage(&imgMyplane, "E:/2022上/Leecode_April/plane/image/me1.png");
    
23. 
    
24.         //初始化飞机的位置在图像的正下方的中心
    
25.        
    
26.         My_current_posiX = GM->rows / 2 - width / 2;
    
27.         My_current_posiY = GM->cols - height;
    
28. }
    
29. 
    
30. 
    
31. IMAGE MyPlane::getImage_Myplane()
    
32. {
    
33.         return imgMyplane;
    
34. }
    
35. 
    
36. void MyPlane::Move(int dx, int dy)
    
37. {
    
38.        
    
39.         My_current_posiX += dx;
    
40.         My_current_posiY += dy;
    
41. 
    
42.         //判断是否超出了边界,还要考虑飞机本身的宽度
    
43.         if (My_current_posiX > (GM->rows - width / 2) || My_current_posiX < width / 2)
    
44.         {
    
45.                 My_current_posiX -= dx;
    
46.         }
    
47. 
    
48.         if (My_current_posiX > (GM->cols - height / 2) || My_current_posiX < height / 2)
    
49.         {
    
50.                 My_current_posiY -= dy;
    
51.         }
    
52. }
    

复制代码

GameMain.h文件

1. #pragma once
   
2. #include<graphics.h>
   
3. #include<cstring>
   
4. #include<vector>
   
5. //#include<MyPlane.h> 如果这里这么用，会发现 当前.h文件和MyPlane.h文件的彼此头文件相互包含，会报错
   
6. class MyPlane;  //告诉编译器，需要这个类，其他功能结构都没变
   
7. using namespace std;
   
8. 
   
9. class GameMain
   
10. {
    
11. 
    
12.         friend class MyPlane;
    
13. public:
    
14.         //构造函数  用于初始化参数，游戏界面设置
    
15. 
    
16.         GameMain();
    
17. 
    
18.         //游戏界面初始化
    
19.         void init();
    
20.         void paly(); // 开始游戏
    
21.         int* getBgSize();
    
22. 
    
23.         int rows;
    
24.         int cols;
    
25. 
    
26. private:
    
27.         void keyEvent();  //按键控制
    
28.         void updateWindow();  //渲染界面
    
29. 
    
30. private:
    
31.         bool update;
    
32.         // 添加这一行,这样其他地方调用这个类的时候，就不用每次都申明，不同地方申明，还是不同的对象，无法
    
33.         //实现同时操作一辆飞机
    
34.         MyPlane *MP;
    
35. 
    
36.         //背景图像参数
    
37.         IMAGE imgBg;  //背景图片
    
38. };
    

复制代码

GameMain.cpp文件

1. #include "GameMain.h"
   
2. #include "MyPlane.h"
   
3. #include "Bullet.h"
   
4. #include<stdlib.h>
   
5. #include <time.h>
   
6. #include<graphics.h>
   
7. #include <conio.h>
   
8. #include"iostream"
   
9. #include"string"
   
10. #include "fstream"
    
11. //音效
    
12. #include<mmsystem.h>
    
13. #pragma comment(lib,"winmm.lib")
    
14. #pragma comment(lib,"WINMM.LIB")
    
15. 
    
16. using namespace std;
    
17. 
    
18. GameMain::GameMain()
    
19. {
    
20.         //将游戏界面的宽度指定成背景图片的显示宽度
    
21.         rows = 438;
    
22.         cols = 675;
    
23. }
    
24. 
    
25. void GameMain::init()
    
26. {
    
27.         //播放背景音乐
    
28.         mciSendString("play E:/2022上/res/bg.mp3 repeat", 0, 0, 0);
    
29. 
    
30.         //创建游戏窗口
    
31.         *initgraph(rows, cols);
    
32. 
    
33.         //加载背景图片
    
34.         loadimage(&imgBg, "E:/2022上/Leecode_April/plane/image/background.png");
    
35. 
    
36.         update = true;
    
37. }
    
38. 
    
39. void GameMain::paly()
    
40. {
    
41.         init();
    
42. 
    
43.         while (1)
    
44.         {
    
45.                 BeginBatchDraw();
    
46.                 //接收用户的输入
    
47.                 keyEvent();
    
48. 
    
49.                 //更新游戏画面
    
50.                 updateWindow();
    
51.                 system("pause");
    
52.                 EndBatchDraw();
    
53.         }
    
54. }
    
55. 
    
56. int* GameMain::getBgSize()
    
57. {
    
58.         int num[] = { rows ,cols };
    
59.         int* ptr = new int[2];
    
60.         for (int i = 0; i < 2; i++) {
    
61.                 ptr[i] = num[i];
    
62.         }
    
63.         return ptr;
    
64. }
    
65. 
    
66. 
    
67. void GameMain::keyEvent()
    
68. {
    
69.         unsigned char ch;
    
70.         int dx = 0;
    
71.         int dy = 0;
    
72. 
    
73.         //判断当前有没有按键输入,如果他没有按键输入，程序正常执行
    
74.         if (_kbhit()) {
    
75.                 ch = _getch();
    
76. 
    
77.                 //按下字母，返回的就是字母，按下的是方向键
    
78.                 //上，先后返回: 224 72  下：224 80   左:75 224,75  右：224 77
    
79.                 if (ch == 224) {
    
80.                         ch = _getch();
    
81.                         switch (ch) {
    
82.                         case 72:
    
83.                                 dy = 1;
    
84.                                 break;
    
85.                         case 80:
    
86.                                 dy = -1;
    
87.                                 break;
    
88.                         case 75:
    
89.                                 dx = -1;
    
90.                                 break;
    
91.                         case 77:
    
92.                                 dx = 1;
    
93.                                 break;
    
94.                         default:
    
95.                                 break;
    
96.                         }
    
97.                 }
    
98.         }
    
99.         if (dx != 0 || dy != 0)  //左右移动
    
100.         {
     
101. //                MyPlane MP;
     
102.                 MP->Move(dx,dy);
     
103.                 update = true;
     
104.         }
     
105. }
     
106. 
     
107. void GameMain::updateWindow()
     
108. {
     
109.         putimage(0, 0, &imgBg);
     
110. 
     
111.         BeginBatchDraw();
     
112.         //绘制我方飞机
     
113.         //MyPlane MP;
     
114.         IMAGE TEMP_my;
     
115.         TEMP_my = MP->getImage_Myplane();
     
116.         putimage(MP->My_current_posiX, MP->My_current_posiY, &TEMP_my);
     
117. 
     
118. 
     
119.         //绘制子弹
     
120.         Bullet BT;
     
121.         IMAGE TEMP_BT;
     
122.         TEMP_BT = BT.getImage_Bullet();
     
123.         putimage(MP->My_current_posiX, MP->My_current_posiY, &TEMP_BT);
     
124. 
     
125.         EndBatchDraw();
     
126. }
     
127. 
     

复制代码

最佳答案

月排行榜 / 总排行榜

isdkz

2023-5-1 20:14:15

猪猪虾 发表于 2023-5-1 21:02
按照您说得改了一下，我把暂时用不到的子程序都注释掉了，报的错还是一样的，太难了。。

根据您提供的代码，我注意到了一个问题。在  GameMain::updateWindow()  函数中，您在绘制子弹时使用了一个临时的  Bullet  对象，而这个对象并没有被正确地初始化。您需要将子弹对象加入到一个容器中（如  vector ），并在游戏主循环中对这些子弹进行更新和绘制。

首先，您需要在  GameMain  类中添加一个  vector  容器来存储子弹对象：

1. #include <vector>
   
2. #include "Bullet.h"
   
3. 
   
4. class GameMain {
   
5.     // ...
   
6. private:
   
7.     // ...
   
8.     std::vector<Bullet> bullets;  // 添加子弹容器
   
9. };
   

复制代码

然后，在游戏主循环中，您可以创建子弹并将它们添加到  bullets  容器中。在此之后，您需要在  GameMain::updateWindow()  函数中迭代  bullets  容器，并更新和绘制每个子弹：

1. void GameMain::updateWindow() {
   
2.     putimage(0, 0, &imgBg);
   
3. 
   
4.     BeginBatchDraw();
   
5. 
   
6.     // 绘制我方飞机
   
7.     IMAGE TEMP_my;
   
8.     TEMP_my = MP->getImage_Myplane();
   
9.     putimage(MP->My_current_posiX, MP->My_current_posiY, &TEMP_my);
   
10. 
    
11.     // 绘制子弹
    
12.     for (Bullet& bullet : bullets) {
    
13.         bullet.update();  // 更新子弹位置
    
14.         IMAGE TEMP_BT;
    
15.         TEMP_BT = bullet.getImage_Bullet();
    
16.         putimage(bullet.getPosX(), bullet.getPosY(), &TEMP_BT);
    
17.     }
    
18. 
    
19.     EndBatchDraw();
    
20. }
    

复制代码

这里需要注意的是，您还需要在  Bullet  类中添加一个更新子弹位置的函数（例如， update() ）以及获取子弹位置的函数（例如， getPosX()  和  getPosY() ）。

希望这些建议能帮助您解决问题。如果您还有其他问题或疑问，请随时告诉我。

跳转到最佳答案楼层

isdkz

猪猪虾 发表于 2023-5-1 21:02
按照您说得改了一下，我把暂时用不到的子程序都注释掉了，报的错还是一样的，太难了。。

根据您提供的代码，我注意到了一个问题。在  GameMain::updateWindow()  函数中，您在绘制子弹时使用了一个临时的  Bullet  对象，而这个对象并没有被正确地初始化。您需要将子弹对象加入到一个容器中（如  vector ），并在游戏主循环中对这些子弹进行更新和绘制。

首先，您需要在  GameMain  类中添加一个  vector  容器来存储子弹对象：

1. #include <vector>
   
2. #include "Bullet.h"
   
3. 
   
4. class GameMain {
   
5.     // ...
   
6. private:
   
7.     // ...
   
8.     std::vector<Bullet> bullets;  // 添加子弹容器
   
9. };
   

复制代码

然后，在游戏主循环中，您可以创建子弹并将它们添加到  bullets  容器中。在此之后，您需要在  GameMain::updateWindow()  函数中迭代  bullets  容器，并更新和绘制每个子弹：

1. void GameMain::updateWindow() {
   
2.     putimage(0, 0, &imgBg);
   
3. 
   
4.     BeginBatchDraw();
   
5. 
   
6.     // 绘制我方飞机
   
7.     IMAGE TEMP_my;
   
8.     TEMP_my = MP->getImage_Myplane();
   
9.     putimage(MP->My_current_posiX, MP->My_current_posiY, &TEMP_my);
   
10. 
    
11.     // 绘制子弹
    
12.     for (Bullet& bullet : bullets) {
    
13.         bullet.update();  // 更新子弹位置
    
14.         IMAGE TEMP_BT;
    
15.         TEMP_BT = bullet.getImage_Bullet();
    
16.         putimage(bullet.getPosX(), bullet.getPosY(), &TEMP_BT);
    
17.     }
    
18. 
    
19.     EndBatchDraw();
    
20. }
    

复制代码

这里需要注意的是，您还需要在  Bullet  类中添加一个更新子弹位置的函数（例如， update() ）以及获取子弹位置的函数（例如， getPosX()  和  getPosY() ）。

希望这些建议能帮助您解决问题。如果您还有其他问题或疑问，请随时告诉我。

isdkz

代码不完整

猪猪虾

isdkz 发表于 2023-5-1 20:17
代码不完整

补了一下，刚卡壳了

陶远航

根据您提供的信息，我无法确定导致程序崩溃的确切原因，但是可以提供一些可能导致崩溃的问题。

在Mainplane.cpp文件中，MyPlane::GM指针没有分配内存。您需要在MyPlane的构造函数中为其分配内存。如果没有分配内存，当您在Mainplane.cpp中调用MyPlane类的成员函数时，该指针将指向未知的内存地址，从而导致程序崩溃。例如，在MyPlane构造函数中添加以下代码：

1. MyPlane::MyPlane()
   
2. {
   
3.         GM = new GameMain; // 分配内存
   
4.         // ... 其他代码 ...
   
5. }

复制代码

无法确定您是否正确地链接了库文件。如果您在链接库文件时出现问题，程序可能无法正常运行。您可以通过检查链接器输出或查看Visual Studio的“输出”窗口来检查是否存在任何错误或警告消息。

您的代码中可能存在内存泄漏或未定义的行为。例如，如果您在GameMain类的成员函数中创建动态分配的内存，并忘记在使用完毕后释放该内存，则可能导致内存泄漏。这可能会导致程序在一段时间后崩溃。要解决这个问题，您可以使用内存分析器工具，如Valgrind，在运行时检查您的程序是否存在内存泄漏或未定义的行为。

您的代码可能存在逻辑错误。例如，在您的MyPlane类中，如果您在Move()函数中检查当前位置是否超出边界时，使用了错误的变量（如cols而不是rows），则可能导致逻辑错误。您可以通过使用调试器逐行执行代码来检查逻辑错误。

希望这些信息对您有所帮助。

isdkz

猪猪虾 发表于 2023-5-1 20:18
补了一下，刚卡壳了

[b]从你的代码来看，你在  MyPlane  类的构造函数中使用了  GameMain  类的指针  GM 。但是，你没有初始化这个指针，所以在访问  GM->rows  和  GM->cols  时可能会导致程序崩溃。你需要在  MyPlane  类的构造函数中接收一个  GameMain  类的指针，并将其赋给  GM 。以下是修改后的建议代码：

MyPlane.h文件

1. class MyPlane
   
2. {
   
3. public:
   
4.     MyPlane(GameMain *gm);  // 将 GameMain 类的指针作为参数传递给构造函数
   
5.     ...
   
6. private:
   
7.     ...
   
8.     GameMain *GM;
   
9. };
   

复制代码

Mainplane.cpp文件

1. MyPlane::MyPlane(GameMain *gm) : GM(gm)
   
2. {
   
3.     width = 100;
   
4.     height = 125;
   
5.     loadimage(&imgMyplane, "E:/2022上/Leecode_April/plane/image/me1.png");
   
6. 
   
7.     //初始化飞机的位置在图像的正下方的中心
   
8.     My_current_posiX = GM->rows / 2 - width / 2;
   
9.     My_current_posiY = GM->cols - height;
   
10. }
    

复制代码

接下来，你需要在  GameMain  类中创建  MyPlane  类的实例时传递一个  GameMain  类的指针。你可以修改  GameMain  类的构造函数来实现这一点：

GameMain.h文件

1. class GameMain
   
2. {
   
3.     ...
   
4. public:
   
5.     GameMain();
   
6.     ...
   
7. private:
   
8.     ...
   
9.     MyPlane *MP;
   
10.     ...
    
11. };
    

复制代码

GameMain.cpp文件

1. GameMain::GameMain()
   
2. {
   
3.     //将游戏界面的宽度指定成背景图片的显示宽度
   
4.     rows = 438;
   
5.     cols = 675;
   
6.     MP = new MyPlane(this);  // 在创建 MyPlane 实例时传递 GameMain 类的指针
   
7. }
   

复制代码

注意，你需要在  GameMain  类的析构函数中删除  MyPlane  类的实例以避免内存泄漏。在  GameMain  类中添加一个析构函数，并在其中删除  MP ：

GameMain.h文件

1. class GameMain
   
2. {
   
3.     ...
   
4. public:
   
5.     ~GameMain();  // 添加析构函数
   
6.     ...
   
7. };
   

复制代码

GameMain.cpp文件

1. GameMain::~GameMain()
   
2. {
   
3.     delete MP;  // 删除 MyPlane 实例
   
4. }
   

复制代码

这些更改应该可以解决你的程序崩溃问题。请尝试修改你的代码，并测试是否可以正常运行。[/b]

陶远航

根据提供的代码，我注意到在 Mainplane.cpp 文件中，MyPlane 类的静态成员 imgMyplane 进行了类外的声明，但是没有进行定义。

在头文件 Mainplane.h 中，我们只能看到静态成员的声明，但是没有找到对应的定义。因此，可能会在链接时出现错误。

解决此问题的方法是在 Mainplane.cpp 文件中添加如下代码，对静态成员进行定义：

1. IMAGE MyPlane::imgMyplane;

复制代码

此外，我还注意到在 MyPlane 类的构造函数中，初始化了一个指向 GameMain 类对象的指针 GM，但是并没有为其分配内存空间。因此，需要在 GameMain 类的构造函数中，为 MyPlane 类对象的指针 MP 分配内存空间，如下所示：

1. GameMain::GameMain()
   
2. {
   
3.     // 将游戏界面的宽度指定成背景图片的显示宽度
   
4.     rows = 438;
   
5.     cols = 675;
   
6. 
   
7.     // 为 MyPlane 类对象的指针 MP 分配内存空间
   
8.     MP = new MyPlane();
   
9. }

复制代码

最后，我建议您检查一下代码中是否存在其他可能导致崩溃的问题，例如是否对指针进行了非法操作等。

猪猪虾

isdkz 发表于 2023-5-1 20:25
从你的代码来看，你在  MyPlane  类的构造函数中使用了  GameMain  类的指针  GM 。但是，你没有初始化这 ...

按照您说得改了一下，我把暂时用不到的子程序都注释掉了，报的错还是一样的，太难了。。

1. #pragma once
   
2. #include<graphics.h>
   
3. #include<cstring>
   
4. #include<vector>
   
5. //#include "GameMain.h"
   
6. using namespace std;
   
7. class GameMain;
   
8. 
   
9. class MyPlane
   
10. {
    
11. public:
    
12.         MyPlane(GameMain* gm);  //  MyPlane  类的构造函数中使用了 GameMain 类的指针  GM 。但是，你没有初始化这个指针
    
13.         //static IMAGE getImages();    //私有成员可以在public里面，通过函数来间接访问和修改
    
14.         void Move(int dx, int dy);
    
15.         static IMAGE getImage_Myplane();
    
16. 
    
17.         int My_current_posiX;
    
18.         int My_current_posiY;
    
19.         int width;
    
20.         int height;
    
21. 
    
22. private:
    
23.         static IMAGE imgMyplane;
    
24.         GameMain *GM;
    
25. };

复制代码

1. #pragma once
   
2. #include<graphics.h>
   
3. #include<cstring>
   
4. #include<vector>
   
5. #include "MyPlane.h"
   
6. #include "GameMain.h"
   
7. 
   
8. using namespace std;
   
9. 
   
10. //静态成员，需要在类外进行声明
    
11. IMAGE MyPlane::imgMyplane;  // 这一行为 imgMyplane 分配内存空间
    
12. 
    
13. //`MyPlane` 类在头文件 `MyPlane.h` 中声明，而 `imgMyplane` 的定义位于与类实现相关联的源文件
    
14. //`MyPlane.cpp` 中。这样，您就解决了 `LNK2001` 错误。
    
15. //如果您将所有代码放在同一个文件中，那么只需在类定义之后添加 `IMAGE MyPlane::imgMyplane; ` 这一行即可。
    
16. //IMAGE MyPlane::imgMyplane;  // 这一行为 imgMyplane 分配内存空间
    
17. 
    
18. 
    
19. MyPlane::MyPlane(GameMain* gm):GM(gm)
    
20. {
    
21.         width = 100;
    
22.         height = 125;
    
23.         loadimage(&imgMyplane, "E:/2022上/Leecode_April/plane/image/me1.png");
    
24. 
    
25.         //初始化飞机的位置在图像的正下方的中心
    
26.        
    
27.         My_current_posiX = GM->rows / 2 - width / 2;
    
28.         My_current_posiY = GM->cols - height;
    
29. }
    
30. 
    
31. IMAGE MyPlane::getImage_Myplane()
    
32. {
    
33.         return imgMyplane;
    
34. }
    
35. 
    
36. void MyPlane::Move(int dx, int dy)
    
37. {
    
38.        
    
39.         My_current_posiX += dx;
    
40.         My_current_posiY += dy;
    
41. 
    
42.         //判断是否超出了边界,还要考虑飞机本身的宽度
    
43.         if (My_current_posiX > (GM->rows - width / 2) || My_current_posiX < width / 2)
    
44.         {
    
45.                 My_current_posiX -= dx;
    
46.         }
    
47. 
    
48.         if (My_current_posiX > (GM->cols - height / 2) || My_current_posiX < height / 2)
    
49.         {
    
50.                 My_current_posiY -= dy;
    
51.         }
    
52. }
    

复制代码

1. #pragma once
   
2. #include<graphics.h>
   
3. #include<cstring>
   
4. #include<vector>
   
5. //#include<MyPlane.h> 如果这里这么用，会发现 当前.h文件和MyPlane.h文件的彼此头文件相互包含，会报错
   
6. class MyPlane;  //告诉编译器，需要这个类，其他功能结构都没变
   
7. using namespace std;
   
8. 
   
9. class GameMain
   
10. {
    
11. public:
    
12.         //构造函数  用于初始化参数，游戏界面设置
    
13. 
    
14.         GameMain();
    
15. 
    
16.         //注意，你需要在  GameMain  类的析构函数中删除  MyPlane  
    
17.    //类的实例*以避免内存泄漏。在  GameMain  类中添加一个析构函数，并在其中删除  MP ：GameMain.h文件
    
18.         ~GameMain();  // 添加析构函数
    
19.         //游戏界面初始化
    
20.         void init();
    
21.         void paly(); // 开始游戏
    
22.         int* getBgSize();
    
23. 
    
24.         int rows;
    
25.         int cols;
    
26. 
    
27. private:
    
28.         void keyEvent();  //按键控制
    
29.         void updateWindow();  //渲染界面
    
30. 
    
31. private:
    
32.         bool update;
    
33. 
    
34.         // 添加这一行,这样其他地方调用这个类的时候，就不用每次都申明，不同地方申明，还是不同的对象，无法
    
35.         //实现同时操作一辆飞机
    
36.         MyPlane *MP;
    
37. 
    
38.         //背景图像参数
    
39.         IMAGE imgBg;  //背景图片
    
40. };
    

复制代码

1. #include "GameMain.h"
   
2. #include "MyPlane.h"
   
3. #include "Bullet.h"
   
4. #include<stdlib.h>
   
5. #include <time.h>
   
6. #include<graphics.h>
   
7. #include <conio.h>
   
8. #include"iostream"
   
9. #include"string"
   
10. #include "fstream"
    
11. //音效
    
12. #include<mmsystem.h>
    
13. #pragma comment(lib,"winmm.lib")
    
14. #pragma comment(lib,"WINMM.LIB")
    
15. 
    
16. using namespace std;
    
17. 
    
18. GameMain::GameMain()
    
19. {
    
20.         MP = new MyPlane(this);  // 在创建 MyPlane 实例时传递 GameMain 类的指针
    
21.         // 为 MyPlane 类对象的指针 MP 分配内存空间
    
22.         //MP = new MyPlane();
    
23.         //将游戏界面的宽度指定成背景图片的显示宽度
    
24.         rows = 438;
    
25.         cols = 675;
    
26. }
    
27. 
    
28. //析构函数主要作用就是释放资源, 避免内存泄漏
    
29. GameMain::~GameMain()
    
30. {
    
31.         delete MP;  // 删除 MyPlane 实例
    
32. }
    
33. 
    
34. void GameMain::init()
    
35. {
    
36.         //播放背景音乐
    
37.         mciSendString("play E:/2022上/res/bg.mp3 repeat", 0, 0, 0);
    
38. 
    
39.         //创建游戏窗口
    
40.         *initgraph(rows, cols);
    
41. 
    
42.         //加载背景图片
    
43.         loadimage(&imgBg, "E:/2022上/Leecode_April/plane/image/background.png");
    
44. 
    
45.         update = true;
    
46. }
    
47. 
    
48. void GameMain::paly()
    
49. {
    
50.         init();
    
51. 
    
52.         while (1)
    
53.         {
    
54.                 BeginBatchDraw();
    
55.                 //接收用户的输入
    
56.                 //keyEvent();
    
57. 
    
58.                 //更新游戏画面
    
59.                 updateWindow();
    
60.                 system("pause");
    
61.                 EndBatchDraw();
    
62.         }
    
63. }
    
64. 
    
65. //int* GameMain::getBgSize()
    
66. //{
    
67. //        int num[] = { rows ,cols };
    
68. //        int* ptr = new int[2];
    
69. //        for (int i = 0; i < 2; i++) {
    
70. //                ptr[i] = num[i];
    
71. //        }
    
72. //        return ptr;
    
73. //}
    
74. 
    
75. 
    
76. //void GameMain::keyEvent()
    
77. //{
    
78. //        unsigned char ch;
    
79. //        int dx = 0;
    
80. //        int dy = 0;
    
81. //
    
82. //        //判断当前有没有按键输入,如果他没有按键输入，程序正常执行
    
83. //        if (_kbhit()) {
    
84. //                ch = _getch();
    
85. //
    
86. //                //按下字母，返回的就是字母，按下的是方向键
    
87. //                //上，先后返回: 224 72  下：224 80   左:75 224,75  右：224 77
    
88. //                if (ch == 224) {
    
89. //                        ch = _getch();
    
90. //                        switch (ch) {
    
91. //                        case 72:
    
92. //                                dy = 1;
    
93. //                                break;
    
94. //                        case 80:
    
95. //                                dy = -1;
    
96. //                                break;
    
97. //                        case 75:
    
98. //                                dx = -1;
    
99. //                                break;
    
100. //                        case 77:
     
101. //                                dx = 1;
     
102. //                                break;
     
103. //                        default:
     
104. //                                break;
     
105. //                        }
     
106. //                }
     
107. //        }
     
108. //        if (dx != 0 || dy != 0)  //左右移动
     
109. //        {
     
110. ////                MyPlane MP;
     
111. //        //        MP->Move(dx,dy);
     
112. //                update = true;
     
113. //        }
     
114. //}
     
115. 
     
116. void GameMain::updateWindow()
     
117. {
     
118.         putimage(0, 0, &imgBg);
     
119. 
     
120.         BeginBatchDraw();
     
121. 
     
122.         //绘制我方飞机
     
123.         //MyPlane MP;
     
124.         IMAGE TEMP_my;
     
125.         TEMP_my = MP->getImage_Myplane();
     
126.         putimage(MP->My_current_posiX, MP->My_current_posiY, &TEMP_my);
     
127. 
     
128.         //绘制子弹
     
129.         Bullet BT;
     
130.         IMAGE TEMP_BT;
     
131.         TEMP_BT = BT.getImage_Bullet();
     
132.         putimage(MP->My_current_posiX, MP->My_current_posiY, &TEMP_BT);
     
133. 
     
134.         EndBatchDraw();
     
135. }
     
136. 
     

复制代码

猪猪虾

isdkz 发表于 2023-5-1 22:02
根据您提供的代码，我注意到了一个问题。在  GameMain::updateWindow()  函数中，您在绘制子弹时使用了一 ...

谢谢，解决了

猪猪虾

陶远航 发表于 2023-5-1 20:21
根据您提供的信息，我无法确定导致程序崩溃的确切原因，但是可以提供一些可能导致崩溃的问题。

在Mainpl ...

忘了表示感谢了，谢谢