Resizing


Create

Some objects require a Create function that allocates memory. For instance, suppose you have an Array class. If the Array class has a constructor that takes the size of the array, you can set the size of the array at the moment you create the object. On the other hand, if you call the default constructor the array will be empty, then the Create function can be called to create the array and the set the size of the array. If there are any elements in the array before calling Create, then a call to Create will destroy all previous elements in the array.
Algunos objetos requieren una función Create para alocar memoria. Por ejemplo, suponga que usted tiene una clase Array. Si la clase Array tiene un constructor que toma el tamaño del arreglo, usted puede fijar el tamaño del arreglo en el momento de crear el objeto. Por otro lago, si usted llama el constructor de defecto el arreglo estará vacío, entonces la función Create puede ser llamada para crear el arreglo y fijar el tamaño del arreglo. Si hay algún elemento en el arreglo antes de llamar Create, entonces una llamada a Create destruirá todos los elementos previos en el arreglo.

Delete

A Delete function is used to Delete all information stored in a object and free the memory used by the object. In fact, after calling Delete the object must be equal to a just made empty object.
Una función Delete es usada para Eliminar toda la información almacenada en un objeto y liberar la memoria usada por el objeto. De hecho, después de llamar Delete el objeto debe ser igual a un objeto vacío acabo de hacer.

Resizing

When using dynamic memory it is necessary to change the size of an array. To do this, you should:
  1. Request a new array of the new size
  2. Copy the existing elements from the original array to the new array
  3. Release (or free) the memory of the original array
  4. Set new array as the original one

Cuando se usa la memoria dinámica es necesario cambiar el tamaño de un arreglo. Para hacer esto, usted puede:
  1. Solicitar un arreglo del nuevo tamaño
  2. Copiar los elementos existentes desde el arreglo original al nuevo arreglo
  3. Liberar la memoria del arreglo original
  4. Fijar el nuevo arreglo como el arreglo original

Exception

When arrays or dynamic memory is used in a program, it is possible to access an invalid memory location. For instance, if an array has a size of three, the valid indexes are: 0, 1, and 2. The next figures show the exception or assertion generated for this type of error. To fix this error, it is necessary to set a Break point in the program by making click in the bar of the left of the code. Once the program is executing you should use F10 and F11 to find out which line is producing the error.
Cuando se usan arreglos o memoria dinámica en un programa es posible acceder una ubicación de memoria inválida usando un índice incorrecto. Por ejemplo, si un arreglo tiene un tamaño de tres, los índices pueden ser: 0, 1, y 2. Las figuras siguientes muestran la excepción o aserción que se generan con este tipo de error. Para corregir este error, es necesario ubicar un Break point en el programa haciendo clic en la barra de la izquierda del código. Una vez que el programa se ejecuta se usa F10 y F11 para ubicar con precisión la línea que produce el error.

Exception

Assertion

Tip
When you store text in an array of characters, the last location of the array has a character known as the null terminator. Therefore, it is necessary to have an extra location for this character. However, if you have an array of integer values (int) or double values, it is not necessary to have this extra location, and instead you must have an extra variable to store how many element can be stored in the array.
Cuando se almacena texto se usa un arreglo de letra, en el cual la última casilla del arreglo tiene un caracter conocido como el terminador nulo. Por lo tanto es necesario tener una casilla extra para este caracter. Sin embargo, si se tiene un arreglo de valores enteros (int) o de valores de punto flotante (double), no es necesario tener una casilla extra, y en su lugar se debe tener una variable que guarde cuantos elementos se puede almacenar en el arreglo.

Problem 1
Modify the MyArray class so that it support the command Create, Delete, and Resize as shown.
Modifique la clase MyArray para que esta soporte el comando de Create, Delete y Resize como se muestra.

MyArray.h
#pragma once
class MyArray
{
public:
     MyArray(void);
     MyArray(int count);
     ~MyArray(void);
     bool Create(int size);
     void Delete();
     bool Resize(int newSize);
     double *data;
private:
     int count;
};

MyArray.cpp
#include "StdAfx.h"
#include "MyArray.h"


MyArray::MyArray(void)
{
     data = NULL;
     count = 0;
}

MyArray::MyArray(int count)
{
     data = new double[count];
     // if (data == NULL) throw L"No enough memory";
     if (data != NULL)
     {
          this->count = count;
     }
     else
     {
          this->count = 0;
     }

}

MyArray::~MyArray(void)
{
     if (data != NULL) delete [] data;
}

bool MyArray::Create(int count)
{
     Delete();
     data = new double[count];
     if (data == NULL) return false;
     this->count = count;
}

void MyArray::Delete()
{
     if (data != NULL)
     {
          delete [] data;
          data = NULL;
     }
     count = 0;
}

bool MyArray::Resize(int newSize)
{
     //___________________________________1. Create a new array of the new size
     double *tmp = new double[newSize];
     if (tmp == NULL) return false;
     //___________________________________ 2. Copy previous elements
     const int new_count = MINIMUM(count, newSize);
     for(int i = 0; i < new_count; i++) tmp[i] = data[i];
     delete [] data;//_________________________ 3. Release the original array
     data = tmp; //__________________________ 4. Set the data to the new array
     this->count = newSize;
     return true;
}

Space.cpp
...

void Space::Window_Open(Win::Event& e)
{
     MyArray x(3);

     int i;
     for(i = 0; i<3; i++) x.data[i] = 2.0*i+1.0;

     x.Resize(5);
     x.data[3] = -3;
     x.data[4] = -4;

     wstring text;
     for(i = 0; i<5; i++)
     {
          Sys::Format(text, L"%g\r\n", x.data[i]);
          tbxOutput.Text += text;
     }
     tbxOutput.Text += L"+++++++++++++++++\r\n";
     x.Resize(3);
     for(i = 0; i < 3; i++)
     {
          Sys::Format(text, L"%g\r\n", x.data[i]);
          tbxOutput.Text += text;
     }
}

MyArrayResize

Problem 2
Add the MyText class to the Space project. Implement the Set and Get functions to set and get the respective text as shown. Remember that text is an array of characters and that the last character is the null terminator characters '\0'. You may use the function wcslen to compute the length of any string, and the function wcscpy to copy text from variable to another variable. Do not forget to include the MyText.h file in your Space.h file.
Agregue la clase MyText al proyecto Space. Implemente las funciones Set y Get para fijar y retraer el texto respectivamente como se muestra. Recuerde que el texto es un arreglo de letras y que el último carácter es el terminador nulo '\0'. Usted puede usar la función wcslen para calcular la longitud de cualquier texto, y la función wcscpy_s para copiar texto de una variable a otra. No se olvide de incluir el archivo MyText.h en el archivo Space.h

MyText.h
#pragma once
class MyText
{
public:
     MyText(void);
     ~MyText(void);
     wchar_t* Get();
     void Set(const wchar_t* text);
private:
     wchar_t* data;
};

MyText.cpp
#include "StdAfx.h"
#include "MyText.h"

MyText::MyText(void)
{
}

MyText::~MyText(void)
{
}

wchar_t* MyText::Get()
{
}

void MyText::Set(const wchar_t* text)
{
}

Space.cpp
...

void Space::Window_Open(Win::Event& e)
{
     MyText tx;
     tx.Set(L"Hello");
     this->Text = tx.Get();
}

MyTextBasic

Tip
Do not forget to use [] instead of () when creating an array using the command new.
No se olvide de usar [] en lugar de () cuando cree un arreglo usando el comando new.

Problem 3
Compute manually the output of the code, and then test the code in your computer. Suppose that the MyText class is the same of the previous problem.
Calcule manualmente la salida del código, y entonces pruebe el código en su computadora. Suponga que la clase MyText es la misma del problema previo.

Space.cpp
...

void Space::Window_Open(Win::Event& e)
{
     MyText a, b;
     a.Set(L"Hello");
     b.Set(L"Hola");
     this->MessageBox(a.Get(), b.Get(), MB_OK);
}


Problem 4
Modify your MyText class by adding another constructor as shown. This constructor may save one line of code when using the class.
Modifique su clase MyText agregando otro constructor como se muestra. Este constructor puede ahorrar una línea de código cuando se usa esta clase.

MyText.h
#pragma once
class MyText
{
public:
     MyText(void);
     MyText(const wchar_t* text);
     ~MyText(void);
     wchar_t* Get();
     void Set(const wchar_t* text);
private:
     wchar_t* data;
};

Space.cpp
...

void Space::Window_Open(Win::Event& e)
{
     MyText x(L"Hola");
     MyText y;
     y.Set(L"Hello");
     y.Set(L"ONE");
     this->Text = x.Get();
     this->Text += y.Get();
}

MyTextSecondConstructor

Problem 5
Modify your MyText class by adding the functions MakeLowerCase and MakeUpperCase. You may use the functions toupper and tolower than convert the case of one single character.
Modifique su clase MyText agregando las funciones MakeLowerCase y MakeUpperCase. Usted debe usar las funciones toupper and tolower para convertir a mayúsculas o minúsculas respectivamente.

Space.cpp
...

void Space::Window_Open(Win::Event& e)
{
     MyText m, n;
     m.Set(L"one ");
     n.Set(L"TWO ");
     m.MakeUpperCase();
     n.MakeLowerCase();
     this->Text = m.Get();
     this->Text += n.Get();
}


MakeLowerCase

Problem 6
Compute the output of the following code using the MyText class of the previous problem.
Calcule la salda del código siguiente usando la clase MyText del problema anterior.

Space.cpp
...

void Space::Window_Open(Win::Event& e)
{
     MyText x(L"Hola"), y(L"hello");
     y.MakeUpperCase();
     this->Text = y.Get();
     this->Text += x.Get();
}


Problem 7
Modify your MyText class by adding the function ReplaceChar. The functions must take two parameters: the original character and the new character. The function returns the number of replacements.
Modifique su clase MyText agregando la función ReplaceChar. La función debe tomar dos parámetros: la letra original y la nueva letra. La función regresa el número de letras remplazadas.

MyTextReplaceChar

MyText.h
#pragma once
class MyText
{
public:
     MyText(void);
     MyText(const wchar_t* text);
     ~MyText(void);
     wchar_t* Get();
     void Set(const wchar_t* text);
     void MakeUpperCase();
     void MakeLowerCase();
     int ReplaceChar(wchar_t original_character, wchar_t new_character);
private:
     wchar_t* data;
};

Space.cpp
...

void Space::Window_Open(Win::Event& e)
{
     MyText z(L"obuelito");
     const int numb_replacements = z.ReplaceChar('o', 'A');
     this->Text = z.Get();
     this->Text += Sys::Convert::ToString(numb_replacements);
}


Problem 8
Modify your MyText class by adding the function CountChar. The functions must take one parameter: the character to be found. The function returns the number of found characters.
Modifique su clase MyText agregando la función CountChar. La función debe tomar un parámetro: la letra que se quiere contar. La función regresa el número de caracteres encontrados.

MyText.h
#pragma once
class MyText
{
public:
     MyText(void);
     MyText(const wchar_t* text);
     ~MyText(void);
     wchar_t* Get();
     void Set(const wchar_t* text);
     void MakeUpperCase();
     void MakeLowerCase();
     int ReplaceChar(wchar_t original_character, wchar_t new_character);
     int CountChar(wchar_t character);
private:
     wchar_t* data;
};


Space.cpp
...
void Space::Window_Open(Win::Event& e)
{
     MyText c(L"xhxexllox");
     int n = c.CountChar('x');
     int m = c.CountChar('X');
     this->Text = Sys::Convert::ToString(n);
     this->Text += L" ";
     this->Text += Sys::Convert::ToString(m);
}


MyTextCountChar

Problem 9
Compute the output of the following code using the MyText class of the previous problem, and then test it with your class implementation.
Calcule la salda del código siguiente usando la clase MyText del problema anterior, y entonces pruebe la implementación de su clase.

Space.cpp
...

void Space::Window_Open(Win::Event& e)
{
     MyText x(L"XhXexllxoxx");
     int n = x.CountChar('x');
     int m = x.CountChar('X');
     this->Text = Sys::Convert::ToString(n);
     this->Text += L" ";
     this->Text += Sys::Convert::ToString(m);
}


Problem 10
Modify your MyText class by adding the function DeleteAt. The functions must take one parameter: the position of the character to be deleted (from 0 to len-1). The function returns true if successful. Do not forget to reduce the size of data.
Modifique su clase MyText agregando la función DeleteAt. La función debe tomar un parámetro: la posición de la letra que se quiere borrar (desde 0 a len-1). La función regresa true si se ejecuta con éxito. No se olvide de reducir el tamaño de data.

MyText.h
#pragma once
class MyText
{
public:
     MyText(void);
     MyText(const wchar_t* text);
     ~MyText(void);
     wchar_t* Get();
     void Set(const wchar_t* text);
     void MakeUpperCase();
     void MakeLowerCase();
     int ReplaceChar(wchar_t original_character, wchar_t new_character);
     int CountChar(wchar_t character);
     bool DeleteAt(int position);
private:
     wchar_t* data;
};

Space.cpp
...

void Space::Window_Open(Win::Event& e)
{
     MyText x(L"abcdefgh");
     if (x.DeleteAt(2) == true)
     {
          this->Text = x.Get();
     }
}

MyTextDeleteAt

Problem 11
Compute the output of the following code using the MyText class of the previous problem, and then test it with your class implementation.
Calcule la salda del código siguiente usando la clase MyText del problema anterior, y entonces pruebe la implementación de su clase.

Space.cpp
...

void Space::Window_Open(Win::Event& e)
{
     MyText x(L"0123456789");
     if (x.DeleteAt(9) == true)
     {
          this->Text = x.Get();
          this->Text += L">";
          if (x.DeleteAt(2) == true)
          {
               this->Text += x.Get();
          }
     }
}


Problem 12
Modify your MyText class by adding the function InsertAt. The functions must take two parameters: the position of the character to be inserted (from 0 to len-1) and the new character. The function returns true if successful.
Modifique su clase MyText agregando la función InsertAt. La función debe tomar dos parámetros: la posición de la letra que se quiere insertar (desde 0 a len-1) y la nueva letra. La función regresa true si se ejecuta con éxito.

MyText.h
#pragma once
class MyText
{
public:
     MyText(void);
     MyText(const wchar_t* text);
     ~MyText(void);
     wchar_t* Get();
     void Set(const wchar_t* text);
     void MakeUpperCase();
     void MakeLowerCase();
     int ReplaceChar(wchar_t original_character, wchar_t new_character);
     int CountChar(wchar_t character);
     bool DeleteAt(int position);
     bool InsertAt(int position, wchar_t character);
private:
     wchar_t* data;
};

Space.cpp
...
void Space::Window_Open(Win::Event& e)
{
     MyText x(L"abdef");
     x.InsertAt(2, 'C');
     this->Text = x.Get();
}

MyTestInsertAt

Problem 13
Compute the output of the following code using the MyText class of the previous problem, and then test it with your class implementation.
Calcule la salda del código siguiente usando la clase MyText del problema anterior, y entonces pruebe la implementación de su clase.

Space.cpp
...

void Space::Window_Open(Win::Event& e)
{
     MyText x(L"0123568");
     if (x.InsertAt(4, '4') == true)
     {
          this->Text = x.Get();
          this->Text += L">";
          if (x.InsertAt(7, '7') == true)
          {
               this->Text += x.Get();
          }
     }
}


Problem 14
Modify your MyText class by adding the function DeleteChar. The functions must take one parameter: the character to be deleted. The function returns the number of characters deleted.
Modifique su clase MyText agregando la función DeleteChar. La función debe tomar un parámetro: la letra que se quiere borrar. La función regresa el número de letras borradas.

MyText.h
#pragma once
class MyText
{
public:
     MyText(void);
     MyText(const wchar_t* text);
     ~MyText(void);
     wchar_t* Get();
     void Set(const wchar_t* text);
     void MakeUpperCase();
     void MakeLowerCase();
     int ReplaceChar(wchar_t original_character, wchar_t new_character);
     int CountChar(wchar_t character);
     int DeleteChar(wchar_t character);
private:
     wchar_t* data;
};

MyText.cpp
...

int MyText::DeleteChar(wchar_t character)
{
     const int count = CountChar(character);
     ...
     //______________________________________ 1. Create the new shorter data memory
     const int len = wcslen(data);
     ...
     //______________________________________ 2. Copy the characters, skipping the respective character
     for(int i = 0, j = 0; i<len; i++)
     {
          ...
     //_____________________________________ 3. Free the previous string
     ...
     //_____________________________________ 4. Set the new data
     ...
     return count;
}

Space.cpp
...

void Space::Window_Open(Win::Event& e)
{
     MyText z(L"mErromrm");
     const int numb_deletions = z.DeleteChar('m');
     this->Text = z.Get();
     this->Text += Sys::Convert::ToString(numb_deletions);
}

MyTextDeleteChar

Problem 15
Compute the output of the following code using the MyText class of the previous problem, and then test it with your class implementation.
Calcule la salda del código siguiente usando la clase MyText del problema anterior, y entonces pruebe la implementación de su clase.

Space.cpp
...
void Space::Window_Open(Win::Event& e)
{
     MyText a(L"holla"), b(L"xhxexllox");
     int n = a.ReplaceChar('o', 'e');
     n += a.ReplaceChar('a', 'o');
     n += b.DeleteChar('x');
     n += b.ReplaceChar('h', 'H');
     this->Text = a.Get();
     this->Text += Sys::Convert::ToString(n);
     this->Text += b.Get();
}


Problem 16
Modify your MyText class by modifying the functions MakeLowerCase and MakeUpperCase. You must add a private member function called ChangeCase(bool toLowerCase), and call this private function from MakeLowerCase and MakeUpperCase.
Modifique su clase MyText agregando modificando las funciones MakeLowerCase y MakeUpperCase. Usted debe agregar una función miembro privada llamada ChangeCase(bool toLowerCase), y llamar esta función privada desde MakeLowerCase y MakeUpperCase.

Problem 17
Modify your MyArray class by adding the functions: GetCount and CountEqual. The GetCount function returns the total number of elements in the array. The CountEqual function must take one parameter: the value to be found, and returns the number of values that are equal to the specified value.
Modifique su clase MyArray agregando las funciones: GetCount y CountEqual. La función GetCount regresa el número total de elementos en el arreglo. La función CountEqual toma un parámetro: el valor que se quiere encontrar, y regresa el número de valores encontrados que son iguales al valor especificado.

MyArrayEqualCount

Space.cpp
...
void Space::Window_Open(Win::Event& e)
{
     MyArray x(4);
     int i;
     for(i = 0; i < 3; i++)
     {
          x.data[i] = i+1;
     }
     x.data[3] = 1;
     Display(x);
     this->Text = Sys::Convert::ToString(x.CountEqual(1));
}

void Space::Display(MyArray& myArray)
{
     const int count = myArray.GetCount();
     wstring text;
     for(int i = 0; i < count ; i++)
     {
          Sys::Format(text, L"x[%d] = %g\r\n", i, myArray.data[i]);
          tbxOutput.Text += text;
     }
}


Problem 18
Compute the output of the following code using the MyArray class of the previous problem, and then test it with your class implementation.
Calcule la salda del código siguiente usando la clase MyArray del problema anterior, y entonces pruebe la implementación de su clase.

Space.cpp
...

void Space::Window_Open(Win::Event& e)
{
     MyArray x(10), y(5);
     int i;
     for(i = 0; i < 10; i++) x.data[i] = i%3;
     for(i = 0; i < 5; i++) y.data[i] = i%3;
     Display(x);
     this->Text = Sys::Convert::ToString(x.CountEqual(2));
     this->Text += L":";
     this->Text += Sys::Convert::ToString(y.CountEqual(2));
}

void Space::Display(MyArray& myArray)
{
     const int count = myArray.GetCount();
     wstring text;
     for(int i = 0; i < count ; i++)
     {
          Sys::Format(text, L"x[%d] = %g\r\n", i, myArray.data[i]);
          tbxOutput.Text += text;
     }
}

Space.h
#pragma once //______________________________________ Space.h
#include "resource.h"
#include "ComplexNumb.h"
#include "MyArray.h"
#include "MyText.h"
#include "MyPoint.h"
#include "RandomDay.h"
class Space: public Win::Dialog
{
public:
     Space()
     {
     }
     ~Space()
     {
     }
     void Display(MyArray& myArray);
protected:
     ...
};


Problem 19
Modify your MyArray class by adding the function InsertAt. The functions must take two parameters: the position of the value to be inserted (from 0 to len-1) and the new value. The function returns true if successful.
Modifique su clase MyArray agregando la función InsertAt. La función debe tomar dos parámetros: la posición del valor que se quiere insertar (desde 0 a len-1) y el nuevo valor. La función regresa true si se ejecuta con éxito.

Space.cpp
...

void Space::Window_Open(Win::Event& e)
{
     MyArray x(10);
     int i;
     for(i = 0; i < 10; i++) x.data[i] = i+1;
     x.InserAt(5, 22.22);
     Display(x);
}
...


MyTextInsertAt

Problem 20
Compute the output of the following code using the MyArray class of the previous problem, and then test it with your class implementation.
Calcule la salda del código siguiente usando la clase MyArray del problema anterior, y entonces pruebe la implementación de su clase.

Space.cpp
...

void Space::Window_Open(Win::Event& e)
{
     MyArray x(10);
     int i;
     for(i = 0; i < 10; i++) x.data[i] = i+1;
     x.InserAt(5, 22.22);
     x.InserAt(5, 33.33);
     x.InserAt(5, 44.44);
     Display(x);
}
...


Problem 21
Modify your MyArray class by adding the function DeleteAt. The functions must take one parameter: the position of the value to be deleted (from 0 to size-1). The function returns true if successful.
Modifique su clase MyArray agregando la función DeleteAt. La función debe tomar un parámetro: la posición del valor que se quiere borrar (desde 0 a tamaño-1). La función regresa true si se ejecuta con éxito.

Space.cpp
...

void Space::Window_Open(Win::Event& e)
{
     MyArray x(10);
     int i;
     for(i = 0; i < 10; i++) x.data[i] = i+1;
     x.DeleteAt(5);
     Display(x);
}
...

MyArrayDeleteAt

Problem 22
Compute the output of the following code using the MyArray class of the previous problem, and then test it with your class implementation.
Calcule la salda del código siguiente usando la clase MyArray del problema anterior, y entonces pruebe la implementación de su clase.

Space.cpp
...

void Space::Window_Open(Win::Event& e)
{
     MyArray x(10);
     int i;
     for(i = 0; i < 10; i++) x.data[i] = i+1;
     x.DeleteAt(5);
     x.DeleteAt(5);
     x.DeleteAt(5);
     Display(x);
}
...

© Copyright 2000-2019 Wintempla selo. All Rights Reserved. Sep 05 2019. Home