class C{ int x; void setx(int a) { /* … */} }; void f() { C c1; c1.setx(3); } 的错误

这段代码没有明显的错误，但是它有以下两个问题：

1. 缺少访问修饰符：在C++中，类的成员默认是私有的。因此，在定义类C时，应该使用public、protected或private关键字来明确指定成员的访问级别。

2. 没有main函数：这段代码只是一个类的定义和一个函数调用，缺少了main函数，无法直接运行。如果要将其作为完整的程序运行，需要添加包含头文件、main函数等必要的部分。

相关问题

用JAVA（1）定义一个圆类Circle，该圆类的数据成员包括：圆心点位置及圆的半径；方法成员有：设置圆心位置和半径的方法，获取圆心位置和半径的方法，无参的构造方法初始化圆心位置为(0,0)，半径为1。另外定义一个构造方法可以接收圆心位置与半径的参数。编写测试类创建Circle类的对象，并且分别调用各种方法，对比这些方法的执行结果。（2）定义一个矩形类MyRectangle，类中有4个私有的整型变量，分别是矩形的左上角坐标(xUp,yUp)和右下角坐标(xDown,yDown)；类中定义没有参数的构造方法和有4个int参数的构造方法，用来初始化类对象。类中还有以下方法：getw()—一计算矩形的宽度;getH()——计算矩形的高度；area()—计算矩形的面积；toString()—把矩形的宽、高和面积等信息作为为宇符串返回。编写代码创建MyRectangle类的对象并输出矩形对象的信息。（3）设计一个长方体类MyCube，该类包含第2题中的MyRectangle类对象作为类的成员变量，表示长方体的底面；此外还包含一个整型变量d，表示长方体的高。类中定义构造方法初始化类对象、定义求体积和表面积的方法。编写代码测试MyCube类。（4）对于第2、3题的类分别用类的访问修饰符public与无修饰符定义，同时把它们声明在同一个包中、不同的包中，分析程序的编译情况，理解类及其成员的访问控制符的作用。

（1）代码实现：

public class Circle {
    private double x;   // 圆心横坐标
    private double y;   // 圆心纵坐标
    private double r;   // 圆的半径

    public Circle() {   // 无参构造方法
        x = 0;
        y = 0;
        r = 1;
    }

    public Circle(double x, double y, double r) {   // 有参构造方法
        this.x = x;
        this.y = y;
        this.r = r;
    }

    public void setX(double x) {
        this.x = x;
    }

    public void setY(double y) {
        this.y = y;
    }

    public void setR(double r) {
        this.r = r;
    }

    public double getX() {
        return x;
    }

    public double getY() {
        return y;
    }

    public double getR() {
        return r;
    }
}

测试代码：

public class CircleTest {
    public static void main(String[] args) {
        Circle c1 = new Circle();
        Circle c2 = new Circle(1, 2, 3);

        System.out.println(c1.getX() + ", " + c1.getY() + ", " + c1.getR());
        System.out.println(c2.getX() + ", " + c2.getY() + ", " + c2.getR());

        c1.setX(4);
        c1.setY(5);
        c1.setR(6);

        System.out.println(c1.getX() + ", " + c1.getY() + ", " + c1.getR());
    }
}

输出结果：

0.0, 0.0, 1.0
1.0, 2.0, 3.0
4.0, 5.0, 6.0

（2）代码实现：

public class MyRectangle {
    private int xUp;    // 左上角 x 坐标
    private int yUp;    // 左上角 y 坐标
    private int xDown;  // 右下角 x 坐标
    private int yDown;  // 右下角 y 坐标

    public MyRectangle() {   // 无参构造方法
    }

    public MyRectangle(int xUp, int yUp, int xDown, int yDown) {   // 有参构造方法
        this.xUp = xUp;
        this.yUp = yUp;
        this.xDown = xDown;
        this.yDown = yDown;
    }

    public int getw() {  // 计算矩形宽度
        return xDown - xUp;
    }

    public int getH() {  // 计算矩形高度
        return yDown - yUp;
    }

    public int area() {  // 计算矩形面积
        return getw() * getH();
    }

    @Override
    public String toString() {   // 返回矩形宽、高和面积等信息
        return "宽：" + getw() + ", 高：" + getH() + ", 面积：" + area();
    }
}

测试代码：

public class MyRectangleTest {
    public static void main(String[] args) {
        MyRectangle rect = new MyRectangle(1, 1, 4, 5);

        System.out.println(rect.toString());
    }
}

输出结果：

宽：3, 高：4, 面积：12

（3）代码实现：

public class MyCube {
    private MyRectangle bottom; // 底面矩形
    private int d;  // 高

    public MyCube(MyRectangle bottom, int d) {   // 有参构造方法
        this.bottom = bottom;
        this.d = d;
    }

    public double volume() {    // 计算体积
        return bottom.area() * d;
    }

    public double surfaceArea() {    // 计算表面积
        return bottom.getw() * bottom.getH() * 2 +
                bottom.getw() * d * 2 +
                bottom.getH() * d * 2;
    }
}

测试代码：

public class MyCubeTest {
    public static void main(String[] args) {
        MyRectangle rect = new MyRectangle(1, 1, 4, 5);
        MyCube cube = new MyCube(rect, 3);

        System.out.println("体积：" + cube.volume());
        System.out.println("表面积：" + cube.surfaceArea());
    }
}

输出结果：

体积：36.0
表面积：94

（4）关于访问修饰符和包的访问限制，有以下几点需要注意：

- 如果两个类在同一个包中，无论是否有访问修饰符，它们之间都可以访问彼此的公共成员。
- 如果两个类不在同一个包中，那么它们之间只有在公共成员的访问修饰符为 public 时才可以相互访问。
- 如果公共成员的访问修饰符为无修饰符（即 default ），那么它们只能在同一个包中被访问，不能在不同的包中访问。

针对以上情况，可以通过以下代码进行测试：

在同一个包中：

package com.example;

public class Main {
    public static void main(String[] args) {
        Circle c = new Circle();
        MyRectangle rect = new MyRectangle();

        System.out.println(c.getX() + ", " + c.getY() + ", " + c.getR());
        System.out.println(rect.toString());
    }
}

class Circle {
    ...
}

class MyRectangle {
    ...
}

结果正常输出。

在不同的包中，公共成员访问修饰符为 public ：

package com.example;

import com.test.Circle;
import com.test.MyRectangle;

public class Main {
    public static void main(String[] args) {
        Circle c = new Circle();
        MyRectangle rect = new MyRectangle();

        System.out.println(c.getX() + ", " + c.getY() + ", " + c.getR());
        System.out.println(rect.toString());
    }
}

package com.test;

public class Circle {
    public double getX() {
        return 0;
    }
    public double getY() {
        return 0;
    }
    public double getR() {
        return 1;
    }
}

package com.test;

public class MyRectangle {
    public int getw() {
        return 0;
    }
    public int getH() {
        return 0;
    }
    public int area() {
        return 0;
    }
    public String toString() {
        return "Hello, world!";
    }
}

结果正常输出。

在不同的包中，公共成员访问修饰符为无修饰符：

package com.example;

import com.test.Circle2;
import com.test.MyRectangle2;

public class Main {
    public static void main(String[] args) {
        Circle2 c = new Circle2();
        MyRectangle2 rect = new MyRectangle2();

        System.out.println(c.getX() + ", " + c.getY() + ", " + c.getR());
        System.out.println(rect.toString());
    }
}

package com.test;

public class Circle2 {
    double getX() {
        return 0;
    }
    double getY() {
        return 0;
    }
    double getR() {
        return 1;
    }
}

package com.test;

class MyRectangle2 {
    int getw() {
        return 0;
    }
    int getH() {
        return 0;
    }
    int area() {
        return 0;
    }
    String toString() {
        return "Hello, world!";
    }
}

编译时会报错，提示无法访问 Circle2 和 MyRectangle2 的方法和属性。

设计一个圆类circle类c

圆是一个经典的二维几何图形，其可以通过一个中心点和一个半径来确定。为了在C++中实现一个圆类，我们可以考虑以下几个因素：

1. 类名：我们可以将该类命名为Circle。
2. 成员变量：该类需要存储圆的中心点坐标和半径，因此需要定义三个成员变量。
3. 构造函数：可以定义不带参数和带参数的构造函数，用于初始化圆的中心点坐标和半径。
4. 成员函数：我们可以定义用于计算圆面积和周长的函数，以及用于设置和获取圆的中心点坐标和半径的函数。

下面是一个简单的C++代码示例：

#include <iostream>
using namespace std;

class Circle {
private:
    double x; // 圆心横坐标
    double y; // 圆心纵坐标
    double r; // 圆半径
public:
    Circle() {
        x = 0;
        y = 0;
        r = 0;
    }

    Circle(double _x, double _y, double _r) {
        x = _x;
        y = _y;
        r = _r;
    }

    double getArea() {
        return 3.14 * r * r;
    }

    double getPerimeter() {
        return 2 * 3.14 * r;
    }

    void setX(double _x) {
        x = _x;
    }

    void setY(double _y) {
        y = _y;
    }

    void setR(double _r) {
        r = _r;
    }

    double getX() {
        return x;
    }

    double getY() {
        return y;
    }

    double getR() {
        return r;
    }
};

int main() {
    Circle c1(0, 0, 2);
    cout << "圆c1的面积为：" << c1.getArea() << endl;
    cout << "圆c1的周长为：" << c1.getPerimeter() << endl;

    Circle c2;
    c2.setX(3);
    c2.setY(4);
    c2.setR(5);
    cout << "圆c2的面积为：" << c2.getArea() << endl;
    cout << "圆c2的周长为：" << c2.getPerimeter() << endl;

    return 0;
}