C / C++ / MFC

/* Find endpoint of line with given angle*/
void find_endpoint (double angle, int* x, int* y)
{
  assert (angle >= 0 && angle < 360);
  if (angle >= 315 || angle <= 45) //end point on right side
  {
    *x = LOCAL_MAP_NUM_X_CELLS;
    *y = (int)round((1 + sin (angle * DEG_TO_RAD)) * LOCAL_MAP_NUM_Y_CELLS / 2);
  }
  else if (angle <= 135) //endpoint on top side 
  {
    *y = LOCAL_MAP_NUM_Y_CELLS;
    *x = (int)round((1 + cos (angle * DEG_TO_RAD)) * LOCAL_MAP_NUM_X_CELLS / 2);
  }
  else if (angle < 225) //endpoint of left side
  {
    *x = 0;
    *y = (int)round((1 + sin (angle * DEG_TO_RAD)) * LOCAL_MAP_NUM_Y_CELLS / 2);
  }
  else //endpoint of bottom side
  {
    *y = 0;
    *x = (int)round((1 + cos (angle * DEG_TO_RAD)) * LOCAL_MAP_NUM_X_CELLS / 2);
  }
}

// a point in matrix
struct pt {
  int x;
  int y;
};

void bresenham (int x0, int y0, int x1, int y1, std::vector<pt>& cell)
{
  int dx = abs (x1 - x0);
  int sx = x0 < x1 ? 1 : -1;
  int dy = -abs (y1 - y0);
  int sy = y0 < y1 ? 1 : -1;
  int error = dx + dy;

  while (1)
  {
    cell.push_back ({ x0, y0 });
    if (x0 == x1 && y0 == y1)
      break;
    int e2 = 2 * error;
    if (e2 >= dy)
    {
      if (x0 == x1)
        break;
      error = error + dy;
      x0 = x0 + sx;
    }
    if (e2 <= dx)
    {
      if (y0 == y1)
        break;
      error = error + dx;
      y0 = y0 + sy;
    }
  }
}

int main (int argc, char **argv)
{
  int x1, y1;
  std::vector<pt> cells;

  //First quadrant, angle < 45
  find_endpoint (30., &x1, &y1);
  bresenham (100, 100, x1, y1, cells);
  cout << "Angle 30 degrees. End point: "<<x1 << ',' << y1 << endl;
  print_cells (cells);
  cout << endl;
//...

Gulshan Negi wrote:

performance in each language

• a blank then set was_blank = 1;
• not a blank then, depending on the was_blank flag increment the word count (or do nothing), eventually clear the flag: was_blank = 0;
  
  "In testa che avete, Signor di Ceprano?"
  -- Rigoletto

#include <stdargs>
void ProcessCommand (char* command, ...)
{
  va_list params; //opaque structure needed to process variable arguments lists

  va_start (params, command); //initialize with the last fixed argument before ellipsis

  // You need to know how many arguments to expect. Assume that args_count function tells you that
  // args_count is your function not some standard function
  int narg=args_count(command);
  for (i=0; i<narg; i++)
  {
    //Get next argument
    QString* pstr = va_arg (params, (QString*));

    // do something with the string
  }
  va_end(params); //cleanup

void ProcessCommand (char* command, int count, ...)

void ProcessCommand (char *command, std::vector<QString*> verify)
{
  for (auto& pstr : verify)
  {
    //do something with it
  }
}

;;;; //this is valid

while (i>0); //spurious semi
 {
   //this is not looped
 }

Quote:

Also, a very popular beginner mistake

int main()
{
  {}
  std::cout << "Hello World!\n";
  {}
}