Nested For Loop in C++

Question

Hello I am a relatively new programmer with C++. I had a question about my code

I have a point 2d class that has a double x and y.

I am trying the following nested loop:

Point2D Dec(float t)
{
    Point2D Temp;
    vector<Point2D>Bcopy=H->B;
    for(int p=0;p<Bcopy.size()-1;p++){
       for(int l=p;l<Bcopy.size();l++){
           Temp=(1-t)*Bcopy.at[p][l-1]+t*Bcopy.at[p+1][l-1];
       }
    }
    return Temp;
}

So essentially there is another class that has a vector with point 2d B and H is the pointer to it. These are storing the points from mouse interaction etc and drawing them. So i just created a copy of it and then did the above nested loop and then I use the points to draw them too.

I keep getting the following two errors:

std::vector<Point2D,std::allocator<-Ty>>::at':function call missing argument list;use'&std::vector<Point2D,std::allocator<_Ty>>:at' to create a pointer to member

and

subscript requires array or pointer.

Both these errors are for the line

Temp=(1-t)*Bcopy.at[p][l-1]+t*Bcopy.at[p+1][l-1]

in the code

I have tried many different things and I either keep getting more errors or just these two. I tried to google and understand the errors but couldn't really. Any help would be much appreciated

Thank you

EDIT After much playing around

I did the following:

vector<2D>NewBcopy; 
 double Rx=0 ,Ry=0; 
 for(int p=0;p<Bcopy.size()-1;p++){ 
 for(int l=p;l<Bcopy.size();l++){ 
 if(l==p)
 {Newcopy.at(l)=Bcopy.at(l); 
 }
 else 
 {Rx=(1-t)*Bcopy.at(p).x+t*Bcopy.at(p+1).x; 
 Ry=(1-t)*Bcopy.at(p).y+t*Bcopy.at(p+1]).y:
 }
 Temp.x=Rx;
 Temp.y=Ry;
 }
 }
 return Temp;
 }

Answer 1

You should first start learning C++ before you start difficult algorithms. Your (non-working) code should look more like this.

#include <vector>
using std::vector;

struct Point2D
{
    double x, y;
};

Point2D Dec(double t)
{
    Point2D Temp;
    vector<Point2D> Bcopy = H->B; // Fails: what is H?
    for (auto p = 0; p < Bcopy.size() - 1; p++)
    {
        for (auto l = p; l < Bcopy.size(); l++)
        {
            // Fails: Bcopy is not 2-dimensional
            Temp = (1 - t) * Bcopy[p][l - 1] + t * Bcopy[p + 1][l - 1];
        }
    }
    vector<Point2D> NewBcopy;
    double Rx = 0, Ry = 0;
    for (auto p = 0; p < Bcopy.size() - 1; p++)
    {
        for (auto l = p; l < Bcopy.size(); l++)
        {
            if (l == p)
            {
                NewBcopy[l] = Bcopy[l];
            }
            else
            {
                Rx = (1 - t)*Bcopy[p].x + t*Bcopy[p + 1].x;
                Ry = (1 - t)*Bcopy[p].y + t*Bcopy[p + 1].y;
            }
            Temp.x = Rx;
            Temp.y = Ry;
        }
    }
    return Temp;
}

Answer 2

You can expand your class representing a 2D point by adding some functions that perform mathematical operations between points and scalars. A minimal example is something like this:

class Point2D
{
public:
    double x, y;

    Point2D(double xx = 0.0, double yy = 0.0) : x{xx}, y{yy} {}
};

Point2D operator*(const Point2D &p, double s)
{
    return Point2D{p.x * s, p.y *s};
}

Point2D operator+(const Point2D &a, const Point2D &b)
{
    return Point2D{a.x + b.x, a.y + b.y};
}

After that, implementing algorithms like the De Castleljau is a bit more easy. The following is a possible (unoptimized) implementation:

Point2D De_Casteljau(std::vector<Point2D> B, double t)
{
    for ( int i = 0; i < B.size() - 1; ++i )
    {
        for ( int j = 0; j < B.size() - 1 - i ; ++j )
        {
            B[j] = B[j] * (1.0 - t) + B[j + 1] * t;
        }
    }
    return B[0];
}

I tested it with this simple program:

#include <iostream>
#include <vector>
#include <iomanip>

//... include here the preceding snippets... 

int main()
{
    using std::setw;
    std::vector<Point2D> B {
        {0,0}, {0,1}, {2,1}, {2,2}
    };

    std::cout << "   t      x       y\n";
    for ( double i = 0; i <= 1.0; i += 0.1 )
    {
        auto p = De_Casteljau(B, i);
        std::cout << std::fixed << std::setprecision(2) << setw(6) << i
                  << std::setprecision(4) << setw(8) << p.x
                  << setw(8) << p.y << '\n';
    }
    return 0;
}

which gave the following results:

   t      x       y
  0.00  0.0000  0.0000
  0.10  0.0560  0.2720
  0.20  0.2080  0.4960
  0.30  0.4320  0.6840
  0.40  0.7040  0.8480
  0.50  1.0000  1.0000
  0.60  1.2960  1.1520
  0.70  1.5680  1.3160
  0.80  1.7920  1.5040
  0.90  1.9440  1.7280
  1.00  2.0000  2.0000