[已解决]point类 里要用line类 但是line类 也要用point类 ，有先后问题会报错怎么解决

2207122216

问题：point类 里要用line类  但是line类 也要用point类 ，有先后问题会报错怎么解决



定义一个 point 类，表示二维平面的一个点。
从中派生一个 line 类，由两个点确定一条直线。以成员函数形式实现以下功能：
1. 点到直线距离
2. 直线间距离（相交距离为 0）
3. 点在平面上的投影点
4. 直线与直线的交点。哈达马积

1. #include <iostream>  
   
2. #include <cmath>  
   
3.   
   
4. class Point {  
   
5. public:  
   
6.     double x, y;  
   
7.   
   
8.     Point(double x = 0, double y = 0) : x(x), y(y) {}  
   
9.   
   
10.     double distanceToLine(const Line& line) const {  
    
11.         // 计算点到直线的距离  
    
12.         double px = x;  
    
13.         double py = y;  
    
14.         double ax = line.p1.x;  
    
15.         double ay = line.p1.y;  
    
16.         double bx = line.p2.x;  
    
17.         double by = line.p2.y;  
    
18.         double numerator = fabs((by - ay) * px - (bx - ax) * py + bx * ay - by * ax);  
    
19.         double denominator = sqrt((bx - ax) * (bx - ax) + (by - ay) * (by - ay));  
    
20.         return numerator / denominator;  
    
21.     }  
    
22. };  
    
23.   
    
24. class Line {  
    
25. public:  
    
26.     Point p1, p2;  
    
27.   
    
28.     Line(const Point& p1, const Point& p2) : p1(p1), p2(p2) {}  
    
29.   
    
30.     double distanceToLine(const Line& otherLine) const {  
    
31.         // 计算两条直线之间的距离（相交距离为0）  
    
32.         double ax = p1.x;  
    
33.         double ay = p1.y;  
    
34.         double bx = p2.x;  
    
35.         double by = p2.y;  
    
36.         double px = otherLine.p1.x;  
    
37.         double py = otherLine.p1.y;  
    
38.         double qx = otherLine.p2.x;  
    
39.         double qy = otherLine.p2.y;  
    
40.         double denominator = (qy - py) * (bx - ax) - (qx - px) * (by - ay);  
    
41.         if (denominator == 0) {  
    
42.             // 两条直线平行或重合，相交距离为0  
    
43.             return 0;  
    
44.         } else {  
    
45.             // 两条直线相交，计算交点坐标并返回距离  
    
46.             double t = ((qx - px) * (ay - py) - (qy - py) * (ax - px)) / denominator;  
    
47.             Point intersectionPoint(ax + t * (bx - ax), ay + t * (by - ay));  
    
48.             return intersectionPoint.distanceToLine(otherLine);  
    
49.         }  
    
50.     }  
    
51.   
    
52.     Point projection(const Point& point) const {  
    
53.         // 计算点在平面上的投影点  
    
54.         double ax = p1.x;  
    
55.         double ay = p1.y;  
    
56.         double bx = p2.x;  
    
57.         double by = p2.y;  
    
58.         double px = point.x;  
    
59.         double py = point.y;  
    
60.         double t = ((px - ax) * (bx - ax) + (py - ay) * (by - ay)) / ((bx - ax) * (bx - ax) + (by - ay) * (by - ay));  
    
61.         Point projectionPoint(ax + t * (bx - ax), ay + t * (by - ay));  
    
62.         return projectionPoint;  
    
63.     }  
    
64. };

复制代码

最佳答案

月排行榜 / 总排行榜

isdkz

2023-10-29 19:22:27

问题的原因是在point类中使用了line类，而在line类中又使用了point类，导致了循环依赖问题。解决这个问题的方法是使用前向声明（forward declaration）来解决类之间的依赖关系。

在point类的定义之前，添加line类的前向声明：

class Line;

这样就可以在point类中使用line类了。而在line类中使用point类时，由于point类的定义已经在line类的定义之后，所以不会出现依赖问题。

修改后的代码如下：

#include <iostream>
#include <cmath>

class Line; // 前向声明

class Point {
public:
    double x, y;

    Point(double x = 0, double y = 0) : x(x), y(y) {}

    double distanceToLine(const Line& line) const {
        // 计算点到直线的距离
        double px = x;
        double py = y;
        double ax = line.p1.x;
        double ay = line.p1.y;
        double bx = line.p2.x;
        double by = line.p2.y;
        double numerator = fabs((by - ay) * px - (bx - ax) * py + bx * ay - by * ax);
        double denominator = sqrt((bx - ax) * (bx - ax) + (by - ay) * (by - ay));
        return numerator / denominator;
    }
};

class Line {
public:
    Point p1, p2;

    Line(const Point& p1, const Point& p2) : p1(p1), p2(p2) {}

    double distanceToLine(const Line& otherLine) const {
        // 计算两条直线之间的距离（相交距离为0）
        double ax = p1.x;
        double ay = p1.y;
        double bx = p2.x;
        double by = p2.y;
        double px = otherLine.p1.x;
        double py = otherLine.p1.y;
        double qx = otherLine.p2.x;
        double qy = otherLine.p2.y;
        double denominator = (qy - py) * (bx - ax) - (qx - px) * (by - ay);
        if (denominator == 0) {
            // 两条直线平行或重合，相交距离为0
            return 0;
        } else {
            // 两条直线相交，计算交点坐标并返回距离
            double t = ((qx - px) * (ay - py) - (qy - py) * (ax - px)) / denominator;
            Point intersectionPoint(ax + t * (bx - ax), ay + t * (by - ay));
            return intersectionPoint.distanceToLine(otherLine);
        }
    }

    Point projection(const Point& point) const {
        // 计算点在平面上的投影点
        double ax = p1.x;
        double ay = p1.y;
        double bx = p2.x;
        double by = p2.y;
        double px = point.x;
        double py = point.y;
        double t = ((px - ax) * (bx - ax) + (py - ay) * (by - ay)) / ((bx - ax) * (bx - ax) + (by - ay) * (by - ay));
        Point projectionPoint(ax + t * (bx - ax), ay + t * (by - ay));
        return projectionPoint;
    }
};

跳转到最佳答案楼层

isdkz

问题的原因是在point类中使用了line类，而在line类中又使用了point类，导致了循环依赖问题。解决这个问题的方法是使用前向声明（forward declaration）来解决类之间的依赖关系。

在point类的定义之前，添加line类的前向声明：

class Line;

这样就可以在point类中使用line类了。而在line类中使用point类时，由于point类的定义已经在line类的定义之后，所以不会出现依赖问题。

修改后的代码如下：

#include <iostream>
#include <cmath>

class Line; // 前向声明

class Point {
public:
    double x, y;

    Point(double x = 0, double y = 0) : x(x), y(y) {}

    double distanceToLine(const Line& line) const {
        // 计算点到直线的距离
        double px = x;
        double py = y;
        double ax = line.p1.x;
        double ay = line.p1.y;
        double bx = line.p2.x;
        double by = line.p2.y;
        double numerator = fabs((by - ay) * px - (bx - ax) * py + bx * ay - by * ax);
        double denominator = sqrt((bx - ax) * (bx - ax) + (by - ay) * (by - ay));
        return numerator / denominator;
    }
};

class Line {
public:
    Point p1, p2;

    Line(const Point& p1, const Point& p2) : p1(p1), p2(p2) {}

    double distanceToLine(const Line& otherLine) const {
        // 计算两条直线之间的距离（相交距离为0）
        double ax = p1.x;
        double ay = p1.y;
        double bx = p2.x;
        double by = p2.y;
        double px = otherLine.p1.x;
        double py = otherLine.p1.y;
        double qx = otherLine.p2.x;
        double qy = otherLine.p2.y;
        double denominator = (qy - py) * (bx - ax) - (qx - px) * (by - ay);
        if (denominator == 0) {
            // 两条直线平行或重合，相交距离为0
            return 0;
        } else {
            // 两条直线相交，计算交点坐标并返回距离
            double t = ((qx - px) * (ay - py) - (qy - py) * (ax - px)) / denominator;
            Point intersectionPoint(ax + t * (bx - ax), ay + t * (by - ay));
            return intersectionPoint.distanceToLine(otherLine);
        }
    }

    Point projection(const Point& point) const {
        // 计算点在平面上的投影点
        double ax = p1.x;
        double ay = p1.y;
        double bx = p2.x;
        double by = p2.y;
        double px = point.x;
        double py = point.y;
        double t = ((px - ax) * (bx - ax) + (py - ay) * (by - ay)) / ((bx - ax) * (bx - ax) + (by - ay) * (by - ay));
        Point projectionPoint(ax + t * (bx - ax), ay + t * (by - ay));
        return projectionPoint;
    }
};

陶远航

你的代码中存在一个问题，那就是在定义Point类的时候，你试图使用Line类，但是在这个时候Line类还没有被定义。这就导致了编译器报错。这是一个常见的问题，通常被称为“循环依赖”或“循环引用”。

解决这个问题的一种方法是使用前向声明。前向声明就是在实际定义一个类之前先声明它。这样，编译器就知道这个类的存在，而不需要知道它的所有细节。在你的代码中，你可以在Point类定义之前添加一个Line类的前向声明。

这是修改后的代码：

1. #include <iostream>
   
2. #include <cmath>
   
3. 
   
4. class Line;  // 前向声明
   
5. 
   
6. class Point {
   
7. public:
   
8.     double x, y;
   
9. 
   
10.     Point(double x = 0, double y = 0) : x(x), y(y) {}
    
11. 
    
12.     double distanceToLine(const Line& line) const;
    
13. };
    
14. 
    
15. class Line {
    
16. public:
    
17.     Point p1, p2;
    
18. 
    
19.     Line(const Point& p1, const Point& p2) : p1(p1), p2(p2) {}
    
20. 
    
21.     // ... 其他成员函数 ...
    
22. };
    
23. 
    
24. // 现在我们可以在Point类外部定义distanceToLine函数
    
25. double Point::distanceToLine(const Line& line) const {
    
26.     // ... 计算点到直线的距离 ...
    
27. }
    

复制代码

注意，由于前向声明只告诉编译器Line是一个类，而不提供任何关于这个类的详细信息，所以在Point类中我们不能定义任何需要知道Line类内部结构的函数。因此，我们需要在Point类外部定义distanceToLine函数，这时Line类已经被完全定义了。
请注意，本回答来自GPT-4
如果问题已经解决，请设置最佳答案

Mike_python小

这个问题可以通过前向声明解决。在 point 类和 line 类的定义中，互相引用了对方的类名，导致编译器无法确定类的大小，从而报错。

为了解决这个问题，可以在 point 类的定义之前加上 line 类的前向声明，这样编译器就能够知道 line 类的存在，并分配足够的空间。具体实现如下：

2. class Line; // 前向声明
4. class Point {
5. public:
6.     double x, y;
8.     Point(double x = 0, double y = 0) : x(x), y(y) {}
10.     double distanceToLine(const Line& line) const;
11.     Point projection(const Line& line) const;
12. };
14. class Line {
15. public:
16.     Point p1, p2;
18.     Line(const Point& p1, const Point& p2) : p1(p1), p2(p2) {}
20.     double distanceToLine(const Line& otherLine) const;
21.     Point intersection(const Line& otherLine) const;
22. };

复制代码

在 point 类中，我们使用了 line 类的引用，但是由于我们提前声明了 line 类，所以编译器不会出现先后顺序的问题。

在 line 类中也可以使用 point 类的引用，同样也不会出现问题。

球一个最佳答案谢谢啦！这对我非常重要！