在C++中用Class画一个圆

Question

我目前正在编写一个程序，我必须从一个类（数据结构）中绘制三个圆形，该类将在控制台中显示为 output。

我的程序遇到的问题是我的代码可以编译，但是 output 变得疯狂并且没有画圆圈。

我还是 C++ 的新手，如果有人能帮我解决这个问题，我将不胜感激。

我当前的代码：

////// Circle.h
#include <iostream>
#include <stdlib.h>
#include <sstream>
#include <time.h>
#include <cmath>

using namespace std;

class Circle
{
private:
    char type;
    int serialNumber = 0;
    double radius = 0.0;
    double density = 0.0;

public:
    Circle(char, int, double);
    Circle(char, int, double, double);
    ~Circle();

    void setType(char);
    void setSerialNumber(int);
    void setRadius(double);
    void setDensity(double);

    char getType() const;
    int getSerialNumber() const;
    double getRadius() const;
    double getDensity() const;
};

////// Circle.cpp
// #include "Circle.h"

    Circle::Circle(char c, int s, double r)
    {
        type = c;
        serialNumber = s;
        radius = r;
    }

    Circle::Circle(char c, int s, double r, double d)
    {
        type = c;
        serialNumber = s;
        radius = r;
        density = d;
    }

    Circle::~Circle()
    {
        cout << "Shapes deleted!" << endl;
    }

    void Circle::setType(char c)
    {
        if(c == 'S' || c == 'C')
            type = c;
    }

    void Circle::setSerialNumber(int s)
    {
        if(s > 0)
            serialNumber = s;
    }

    void Circle::setRadius(double r)
    {
        if(r > 0)
            radius = r;
    }

    void Circle::setDensity(double d)
    {
        if(d > 0)
            density = d;
    }

    char Circle::getType() const
    {
        return type;
    }

    int Circle::getSerialNumber() const
    {
        return serialNumber;
    }

    double Circle::getRadius() const
    {
        return radius;
    }

    double Circle::getDensity() const
    {
        return density;
    }

////// main.cpp
// #include "Circle.h"

void drawAll(Circle *[], int);
void drawType(Circle *);
void drawCircle(Circle *);
void drawSpray(Circle *);
void deleteAll(Circle *[], int);

/// For 'C' type the system should display a circle.
/// For 'S' type the system displays a spray pattern just like those used in Microsoft Paint.

int main(int argc, char** argv)
{
    const int SIZE = 3;
    Circle * arrCircle[SIZE] = {nullptr};

    arrCircle[0] = new Circle('C', 1001, 20);

    /// Create a Circle whose serial number is 1001 and the radius is 20.

    /// Type 'C' indicates Circle type.

    arrCircle[1] = new Circle('S', 1002, 25, 30);

    /// Create a Spray whose serial number is 1002, the radius is 25, and the density is 30%.

    /// Type 'S' indicates Spray type.

    arrCircle[2] = new Circle('S', 1003, 40, 80);

    /// Create a Spray whose serial number is 1003, the radius is 40, and the density is 80%.

    drawAll(arrCircle, SIZE);

    /// Draw all shapes. The function uses a for loop to display the circles and sprays in arrCircle.

    deleteAll(arrCircle, SIZE);

    /// Delete all shapes.

    return 0;
}

void drawAll(Circle *arr[], int SIZE)
{
    for(int i = 0; i < SIZE; i++)
        if(arr[i] != nullptr)
        {
            cout << "Circle #" << arr[i]->getSerialNumber() << endl;
            drawType(arr[i]);
        }
}

void drawType(Circle *p)
{
    if(p->getType() == 'C')
        drawCircle(p);

    else if(p->getType() == 'S')
        drawSpray(p);
}

void drawCircle(Circle *p)
{
    double r = p->getRadius();
    int x = 0;
    int y = 0;
    int rto = 2;

    for(int i = 0; i <= 40; i++)
    {
        for(int j = 0; j <= 40; i++)
        {
            x = abs(i - 20);
            y = abs(j - 20);
            r = pow(pow(x, rto) + pow(y, rto), 0.5);

            if(19.5 < r && r < 20.5)
                cout << "* ";
            else
                cout << "  ";
        }

        cout << endl;
    }

}

void drawSpray(Circle *p)
{
    double d = p->getDensity();
    int x = 0;
    int y = 0;
    int rto = 2;

    for(int i = 0; i <= 80; i++)
    {
        for(int j = 0; j <= 80; i++)
        {
            x = abs(i - 30);
            y = abs(j - 30);
            d = pow(pow(x, rto) + pow(y, rto), 0.5);

            if(19.5 < d && d < 20.5)
                cout << "* ";
            else
                cout << "  ";
        }

        cout << endl;
    }
}

void deleteAll(Circle *arr[], int SIZE)
{
    for(int i = 0; i < SIZE; i++)
    {
        if(arr[i] != nullptr)
            delete arr[i];
    }
}

我当前的 Output：

Circle #1001

                       * * * * * * * * *

预期 Output：（示例）

Circle #1001

                        *************
                    **                 **
                 **                       **
               *                             *
             **                               **
            *                                   *
           *                                     *
          *                                       *
          *                                       *
          *                                       *
          *                                       *
          *                                       *
          *                                       *
          *                                       *
           *                                     *
            *                                   *
             **                               **
               *                             *
                 **                       **
                    **                 **
                        *************

Circle #1002

                              ***************
                         ***                   ***
                      **                           **
                    *                                 *
                  *                                     *
                **                                       **
               *                                           *
              *                                             *
             *                                               *
            **                                               **
            *                                                 *
            *                                                 *
            *                                                 *
            *                                                 *
            *                                                 *
            *                                                 *
            **                                               **
             *                                               *
              *                                             *
               *                                           *
                **                                       **
                  *                                     *
                    *                                 *
                      **                           **
                         ***                   ***
                              ***************

Circle #1003

                                                    *****************                                                   
                                             ***                         ***                                            
                                         **                                   **                                        
                                      *                                           *                                     
                                   **                                               **                                  
                                 *                                                     *                                
                               *                                                         *                              
                             *                                                             *                            
                           **                                                               **                          
                          *                                                                   *                         
                         *                                                                     *                        
                        *                                                                       *                       
                       *                                                                         *                      
                      *                                                                           *                     
                     *                                                                             *                    
                     *                                                                             *                    
                    *                                                                               *                   
                    *                                                                               *                   
                    *                                                                               *                   
                    *                                                                               *                   
                    *                                                                               *                   
                    *                                                                               *                   
                    *                                                                               *                   
                    *                                                                               *                   
                    *                                                                               *                   
                     *                                                                             *                    
                     *                                                                             *                    
                      *                                                                           *                     
                       *                                                                         *                      
                        *                                                                       *                       
                         *                                                                     *                        
                          *                                                                   *                         
                           **                                                               **                          
                             *                                                             *                            
                               *                                                         *                              
                                 *                                                     *                                
                                   **                                               **                                  
                                      *                                           *                                     
                                         **                                   **                                        
                                             ***                         ***                                            
                                                    ***************** 

Answer 1

这是一个简单的算法，它可能对简单的数学有帮助

#include <iostream>

#include <图形.h>

诠释主要（）{

initgraph();
setcolorRGB(23, 143, 44);
int j = 400;
int r = 50; // this is the radius
for (int i = 200;i < 800;i++) {
    for (int j = 200;j < 800;j++) {
        int p = int(sqrt((pow(i-350,2))+(pow(j-350,2)))); // this is the distance between two points
        if (r == p) {
            putpixel(j,i);
        }
    }
}

}