C / C++ / MFC

library BoxWriter
{
    interface ILine : IDispatch 
    {
        [propget, id(8), helpstring("property m_lCount")] HRESULT m_lCount([out, retval] long *pVal);
    };
    interface IPrinter : IDispatch
    {
        [propget, id(1), helpstring("property m_line")] HRESULT m_line([optional, defaultvalue ("")] BSTR strLine, [out, retval] ILine* *pVal);
    };
};

Dim printer As New BoxWriter.PRINTER
printer.Connect("192.168.1.3")
MsgBox(m_printer.m_line.m_lCount)    ‘ <—crashes here

An unhandled exception of type 'System.AccessViolationException' occurred in demo.exe
Additional information: Attempted to read or write protected memory. This is often an indication that other memory is corrupt.

STDMETHODIMP CPrinter::get_m_line(BSTR bstrLine, ILine **pVal)
{ 
    AFX_MANAGE_STATE(AfxGetStaticModuleState())

    CString strLine = (LPCTSTR)_bstr_t (bstrLine);
    CComObject <CLine>* pLine = GetLine (strLine);

    if (!pLine) {
        return E_INVALIDARG;
    }

    * pVal = pLine;

    return S_OK;
}

int main()
{
	int size = 5;
	
	Shape** shapes = new Shape*[size];

	Point* centre = new Point(5,5);
	Rectangle* rectangle1 = new Rectangle(*centre, 4, 3);
	shapes[0] = rectangle1;
	
	shapes[1] = new Rectangle (*new Point(10, -10), 4, 4);

	Rectangle* rectangle3 = new Square(*new Point(-8.5,-10), 2.5);
	shapes[2] = rectangle3;

	Square* square2 = new Square (*new Point(-1,-1), 1.5);
	shapes[3] = square2;
	
	Circle* circle = new Circle(*new Point(100,100), 25.4);
	shapes[4] = circle;

	cout << "\n11111111111111111111111111\n";
 
	for (int i = 0; i < size; ++i)
		shapes[i] -> display();

	cout << "\n22222222222222222222222222\n";

	cout << "\nthe area of the first rectangle is: ";
	cout << rectangle1->area() << endl;

	cout << "It is a square, the area is: ";
	Square* square = dynamic_cast<Square*> (rectangle3);
	cout << square->area() << endl;	

	cout << "the perimeter of the circle is: ";
	cout << circle->perimeter() << endl;	

	cout << "\n33333333333333333333333333\n";

	cout << "\nThe four vertices of the first rectangle are: (clockwise from top-left)\n";
	rectangle1->printFourVertices();

	cout << "\nThe four vertices of the third rectangle are:\n";
	rectangle3->printFourVertices();

	cout << "\n44444444444444444444444444\n";

	rectangle1->reflectX();

	shapes[2] -> translate(1.5, 3);

	shapes[4] -> translate(-100,-100);

	cout << "\nAfter reflection and translation, here are the moved shapes:\n" ;
	for (int i = 0; i < size; ++i)
		shapes[i] -> display();
	
	cout << "\n55555555555555555555555555\n";
 
	cout << "\nNow, the four vertices of the first rectangle are:\n";
	rectangle1->printFourVertices();
 
	cout << "\nNow, the four vertices of the third rectangle are:\n";
	rectangle3->printFourVertices();

	cout << "\n66666666666666666666666666\n\n";
 
	for (int i = 0; i < size; ++i)
		cout << shapes[i] -> area() << endl;

	// From the following statements, understand how setLength() and setWidth()
	// work for rectangles and squares.

	cout << "\n777777777777777777777777777\n";

	shapes[1] -> display();
	dynamic_cast<Rectangle*> (shapes[1]) -> setLength(8.2);
	cout << "\nAfter setLength(8.2), the rectangle is: ";
	shapes[1] -> display();
	dynamic_cast<Rectangle*> (shapes[1]) -> setWidth(5);
	cout << "\nAfter setWidth(5), the rectangle is: ";
	shapes[1] -> display();

	square2 -> display();
	square2 -> setLength(8.2);
	cout << "\nAfter setLength(8.2), the rectangle is: ";
	square2 -> display();
	square2 -> setWidth(5);
	cout << "\nAfter setWidth(5), the rectangle is: ";
	square2 -> display();

	system("pause");
	return 0;
}


/*
11111111111111111111111111

Rectangle:
        Centre: (5, 5)
        Length: 4
        Width: 3

Rectangle:
        Centre: (10, -10)
        Length: 4
        Width: 4

Square:
        Centre: (-8.5, -10)
        Side Length: 2.5

Square:
        Centre: (-1, -1)
        Side Length: 1.5

Circle:
        Centre: (100, 100)
        Radius: 25.4

22222222222222222222222222

the area of the first rectangle is: 12
It is a square, the area is: 6.25
the perimeter of the circle is: 159.512

33333333333333333333333333

The four vertices of the first rectangle are: (clockwise from top-left)
(3, 6.5)
(7, 6.5)
(7, 3.5)
(3, 3.5)

The four vertices of the third rectangle are:
(-9.75, -8.75)
(-7.25, -8.75)
(-7.25, -11.25)
(-9.75, -11.25)

44444444444444444444444444

After reflection and translation, here are the moved shapes:

Rectangle:
        Centre: (5, -5)
        Length: 4
        Width: 3

Rectangle:
        Centre: (10, -10)
        Length: 4
        Width: 4

Square:
        Centre: (-7, -7)
        Side Length: 2.5

Square:
        Centre: (-1, -1)
        Side Length: 1.5

Circle:
        Centre: (0, 0)
        Radius: 25.4

55555555555555555555555555

Now, the four vertices of the first rectangle are:
(3, -3.5)
(7, -3.5)
(7, -6.5)
(3, -6.5)

Now, the four vertices of the third rectangle are:
(-8.25, -5.75)
(-5.75, -5.75)
(-5.75, -8.25)
(-8.25, -8.25)

66666666666666666666666666

12
16
6.25
2.25
2025.8

777777777777777777777777777

Rectangle:
        Centre: (10, -10)
        Length: 4
        Width: 4

After setLength(8.2), the rectangle is:
Rectangle:
        Centre: (10, -10)
        Length: 8.2
        Width: 4

After setWidth(5), the rectangle is:
Rectangle:
        Centre: (10, -10)
        Length: 8.2
        Width: 5

Square:
        Centre: (-1, -1)
        Side Length: 1.5

After setLength(8.2), the rectangle is:
Square:
        Centre: (-1, -1)
        Side Length: 8.2

After setWidth(5), the rectangle is:
Square:
        Centre: (-1, -1)
        Side Length: 5
*/

// jianger.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
# include<iostream>
# include<cmath>
# include<string>

using namespace std;
class Point
{
private:
	double x;
	double y;
public:
	Point();
	Point(const double &x,const double &y);
	void setX(const double &x);
	void setY(const double &y);
	double getX()const;
	double getY()const;
	double DisFromOrigin()const;
	virtual void translate(const double &xDis, const double &yDis);
	void reflectX(); // chnage my private members
	void reflectY();
	virtual void PrintName()const;
};
Point::Point()
{
	x=0;
	y=0;
}
Point::	Point(const double &x,const double &y)
{
	this->x=x;
	this->y=y;
}
void  Point::setX(const double &x)
{
	this->x=x;
	this->y=y;
}
void Point:: setY(const double &y)
{
	this->y =y;
}
double Point:: getX()const
{
	return x;
}
double Point:: getY()const
{
	return y;
}
double  Point::DisFromOrigin()const
{
	return (sqrt(x*x + y*y));
}
void Point:: translate(const double &xDis, const double &yDis)
{
	double a;
	double b;
	a = this->x + xDis;
	b= this->y + yDis;
	this->x= a;
	this->y=b;
}
void Point::reflectX()
{
	this->y = -1 *y;
}
void Point::reflectY()
{
	this->x= -1*x;
}
void Point::PrintName()const
{
	cout<<"Point ("<<getX()<<" , "<<getY()<<")"<<endl;
}
class Shape
{
public:
	virtual double Peri()const=0;
	virtual void PrintName()const=0;
	virtual void translate(double x1,double y1)=0;
	virtual void reflectX()=0;
	virtual void reflectY()=0;
	virtual double getArea()const=0;
	virtual double getPeri()=0;
	virtual string getName()const=0;
}
class Circle:public Shape
{

public:
	Circle();
	Circle(const Point &p, const double &r);
	double getR()const;
	void setR(const double &r);
	virtual double getPeri()const;
    virtual void PrintName()const;
	virtual void translate(const double &x1, const double  &y1);
	virtual void reflectX();
    virtual void reflectY();
    virtual double getArea()const;
   virtual string getName()const;
protected:
	Point center;
	string name;
	double radius;
	 

};
Circle::Circle()
{
	name = "Circle";
	center = Point(0,0);
	radius = 1;
}
Circle::Circle(const Point &p, const double &r)
{
	name = "Circle";
	this->center= p;
	this->radius=r;
}

double Circle::getPeri()const
{
	return (2*3.14*getR());
}
double Circle::getR()const
{
	return radius;
}
void Circle::setR(const double &r)
{
	this->radius = r;
}
 void Circle:: PrintName()const
 {
	 cout<<"Circle"<<endl;
 }
 void Circle::translate(const double &x1, const double &y1)
 {
	 this->center.translate(x1 , y1);
 }
void Circle::reflectX()
{
	this->center.reflectX();
}
void Circle::reflectY()
{
	this->center.reflectY();
}
double Circle::getArea()const
{
	return (3.14*this->getR()*this->getR());
}
string Circle::getName()const
{
	return this->name;
}
class Rectangle:public Shape
{
private:
	double len;
	double width;
	Point center;
	string name;
public:
	Rectangle();
	Rectangle(const Point &p, const double &len , const double &width);
	void setLen(double len);
	void setWid(double width);
	double getLen()const;
	double getWid()const;
	virtual double getPeri()const;
	virtual void PrintName()const;
	virtual void translate(const double &x1, const double  &y1);
	virtual void reflectX();
	virtual void reflectY();
	virtual double getArea()const;
	virtual string getName()const;
};
Rectangle::Rectangle()
{
	len =1;
	width=1;
	this->name = "Rectangle";
	center = Point(0,0);
}

Rectangle::	Rectangle(const Point &p, const double &len , const double &width)
{
	this->name ="Rectangle";
	this->center = p;
	this->len = len;
	this->width = width;
}
double Rectangle:: getPeri()const
{
	return (2*getLen() + 2*getWid());
}
void Rectangle::PrintName()const
{
	cout<<"Rectangle"<<endl;
}
void Rectangle::translate(const double &x1, const double  &y1)
{
	this->center.translate(x1, y1);
}
void Rectangle::reflectX()
{
	this->center.reflectX();
}
void Rectangle::reflectY()
{
	this->center.reflectY();
}
double Rectangle::getArea()const
{
	return(getLen()*getWid());
}
string Rectangle::getName()const 
{
	return name;
}
void Rectangle::setLen(double len)
{
	this->len = len;
}
void Rectangle::setWid(double width)
{
	this->width = width;
}
double Rectangle::getLen()const
{
	return len;
}
double Rectangle::getWid()const
{
	return width;
}
class Square:public Rectangle
{
private:
	Point center;
	string name;
	double side;
public:
	Square();
	Square(const double &side);
	void setSide(const double &side);
	double getSide()const;
	virtual double getPeri()const;
	virtual void PrintName()const;
	virtual void translate(const double &x1, const double  &y1);
	virtual void reflectX();
	virtual void reflectY();
	virtual double getArea()const;
	virtual string getName()const;
};
Square::Square()
{
	side=0;
}
Square::Square(const double &side)
{
	this->side = side;
}
void Square::setSide(const double &side)
{
	this->side = side;
	this->Rectangle::setLen(side);
	this->Rectangle::setWid(side);
}
double Square::getSide()const
{
	return this->Rectangle::getLen();
}
double Square:: getPeri()const
{
	return(this->Rectangle::getLen()* 4);
}
void Square::PrintName()const
{
	cout<<"Square"<<endl;
}
void Square::translate(const double &x1, const double  &y1)
{
	this->Rectangle::translate(x1, y1);
}
void Square::reflectX()
{
	this->Rectangle::reflectX();
}
void Square::reflectY()
{
	this->Rectangle::reflectY();
}
double Square::getArea()const
{
	return(this->Rectangle::getLen()* this->Rectangle::getLen());
}
string Square::getName()const
{
	return name;
}

int _tmain(int argc, _TCHAR* argv[])
{
	int size = 5;
	
	Shape** shapes = new Shape*[size];

	Point* centre = new Point(5,5);
	Rectangle* rectangle1 = new Rectangle(*centre, 4, 3);// it means that this can not be abstract class!!! coz it is calling object of itself so no virtual functions
	shapes[0] = rectangle1;
	
	shapes[1] = new Rectangle (*new Point(10, -10), 4, 4);

	Rectangle* rectangle3 = new Square(*new Point(-8.5,-10), 2.5);
	shapes[2] = rectangle3;

	Square* square2 = new Square (*new Point(-1,-1), 1.5);
	shapes[3] = square2;
	
	Circle* circle = new Circle(*new Point(100,100), 25.4);
	shapes[4] = circle;

	cout << "\n11111111111111111111111111\n";
 
	for (int i = 0; i < size; ++i)
		shapes[i] -> display();

	return 0;
}

char * buffer = "World!Hello, ";

char * buffer = "Hello, World!";

namespace CommonTools
  {
 /// Code by Shepel' Nikolay E., Moscow, Russia, published at 22 July 2017, http://www.codeproject.com.
#ifdef DEBUG
  uint32_t scroll_raw_buffer_last_rounds = 0;
#endif

  void scroll_raw_buffer (void *data , const uint32_t buffer_size, uint32_t distance)
  {
#ifdef DEBUG
    scroll_raw_buffer_last_rounds = 0; // Statistics about rounds...
#endif
    // Для реализации скроллинга необходим двойной запас по размеру буффера,
    // т.е. buffer_size<(UINT_MAX/2) если использовать в функции 32х разрядные
    // переменные, иначе можем выскачить за их максимальный размер, если
    // надо будет буффер сместить влево на 1.

    // WARNING!!!
    // We need double reserve for addressing buffer elements (buffer_size<(UINT_MAX/2)).
    // Otherwise we can get register overflow while scrolling buffer with
    // size>=INT_MAX to the left with distance==1
    if (buffer_size >= INT_MAX)
      throw CommonTools::Errors::Simple (CommonTools::Errors::StE_Overflow, __PLACE__);

    if ( (!data) || (buffer_size < 2)) return;
    distance %= buffer_size;
    if (!distance) return;
    TRAP_in_DEBUG (distance >= buffer_size, msg_interror)

    uint8_t *buf = (uint8_t *) data;
    const uint32_t shift_value = distance;



#ifdef DEBUG
    static const size_t max_stack_buffer = 256;
#else
    static const size_t max_stack_buffer = 1024;
#endif

    // If buffer size is quite small we can use the simplest way...
    if (buffer_size <= max_stack_buffer)
      {
        uint8_t *tmp_buf = (uint8_t *) alloca (buffer_size);
        memcpy (tmp_buf, buf, buffer_size);

        memcpy (buf + shift_value, tmp_buf, buffer_size - shift_value);
        memcpy (buf, tmp_buf + buffer_size - shift_value, shift_value);
        return;
      }

#ifdef DEBUG
    scroll_raw_buffer_last_rounds = 1;
#endif

    uint32_t bytes_left = buffer_size, bytes_per_round = 0;
    uint32_t total_rounds = 0;
    uint32_t round_number = 1; // [1...total_rounds]
    uint8_t  *next_data_buffer = 0;
    uint32_t dest_index;
#ifdef DEBUG
    const uint8_t * const out_of_buffer = buf + buffer_size;
#endif

    do // Starting "merry-go-round"
      {
        {
          const uint32_t round_start_offset = round_number - 1;
          dest_index = round_start_offset;
          if (dest_index >= buffer_size) dest_index -= buffer_size;
          uint8_t next_data = buf[dest_index];
          do
            {
              dest_index += shift_value; if (dest_index >= buffer_size) dest_index -= buffer_size;
              register uint8_t &destination = buf [dest_index];
              swap (destination, next_data);
              bytes_left--;
            }
          while (dest_index != round_start_offset);
        }

        if (!bytes_left) // If it was last round (or the single one) we finish here...
          break;
        if (round_number == 1)
          {
            bytes_per_round = buffer_size - bytes_left;
            total_rounds = buffer_size / bytes_per_round;
#ifdef DEBUG
            scroll_raw_buffer_last_rounds = total_rounds;
#endif
            // The residue of division must be zero !!!
            TRAP_in_DEBUG (buffer_size % bytes_per_round, msg_bogus_state)
          }
        round_number++;

        // If we come here so multiple rounds are required  for scroll operation
        // I think it is because buffer length and distance have common dividors... (I'm not strong in mathematics)
        // We can use some sort of optimisation in this case. We can move blocks of data.
        // The size of such blocks are limited by common dividors mensioned before...

        if (!next_data_buffer) // The temporary buffer for blocks operation.
          next_data_buffer = (uint8_t *) alloca (max_stack_buffer);

        // The code in cycle below is usefull if block_size>1.
        // We check this indirectly by means of condition in "for()" statement below.
        // Otherwise this cycle will be skipped and upper cycle
        // will be used with single byte code.
        for (;round_number  < total_rounds;) //the same condition as if we use "(total_rounds-round_number+1)>1" but less operations are required
          {
            const uint32_t rounds_left = total_rounds - round_number + 1;
            // Activating block move
            const size_t block_size = min_ct (max_stack_buffer, rounds_left);
            const uint32_t round_start_offset = round_number - 1;
            dest_index = round_start_offset;
            if (dest_index >= buffer_size) dest_index -= buffer_size;

            TRAP_in_DEBUG (buf + dest_index + block_size >= out_of_buffer, msg_interror)
            memcpy (next_data_buffer, buf + dest_index, block_size);
            TRAP_in_DEBUG (bytes_left < bytes_per_round*block_size, msg_interror)
            do // block move DO
              {
                dest_index += shift_value; if (dest_index >= buffer_size) dest_index -= buffer_size;
                register uint8_t *destination = buf + dest_index;

/**
        If region to copy overlaps the end of main buffer, special copy
        routine is required (see below).
        But this is never happens, because after the end of the buffer
        the beggining  starts. The beggining element is moved at the
        firstest step in upper cycle. The algo is designed that it is
        impossible if some byte is moved twice.
        So I left this commented (disabled) block (I am not sure that
        it is works good because it is never tested):
**/
/*
                if (destination + block_size > out_of_buffer)
                  {
                    const uint32_t part1 = out_of_buffer-destination;
                    TRAP_in_DEBUG (part1>block_size,msg_interror)
                    memswap (destination,next_data_buffer,part1);
                    const uint32_t part2 = block_size-part1;
                    memswap (buf,next_data_buffer+part1,part2);
                  }
                else
*/
              memswap (destination, next_data_buffer, block_size);
              } // EOF block move DO
            while (dest_index != round_start_offset);
            bytes_left -= bytes_per_round * block_size;
            round_number += block_size;
          } // EOF for (;round_number  < total_rounds;)
      } // Do "merry-go-round"
    while (bytes_left > 0);

    return;
  }

} // namespace CommonTools