vect2 · Multi line

▶ Aprender vect2 (Multi line) paso a paso · explicación de vect2

Otras versiones: One line · Orden del main · one line · Orden del main · multi line · Cristi

Código línea a línea

Tres columnas: el código, el trozo del subject o del main que obliga a escribir esa línea, y el por qué.

vect2.hpp
CódigoSubjectPor qué
#pragma onceQue el .hpp no se incluya dos veces.
#include <iostream>printable with the << operatorstd::ostream para el << que imprime. El main usa std::cout y solo incluye vect2.hpp.
class vect2Create a class vect2La clase.
{
private:x e y solo los toca la propia clase.
int x;vector of dimension 2 containing intsDimensión 2 → dos ints. Este es v[0].
int y;vector of dimension 2 containing intsEste es v[1].
public:You will find a main in this directory that must work with your class.Todo lo que usa el main.
// ---------- forma canónica ----------
vect2() : x(0), y(0) {}vect2 v1; // 0, 0Sin nada → {0, 0}. Lista de inicialización: x(0) = x empieza en 0.
vect2(int a, int b) : x(a), y(b) {}vect2 v2(1, 2); // 1, 2Con dos números → {1, 2}.
vect2(const vect2& o) : x(o.x), y(o.y) {}const vect2 v3(v2);
vect2 v4 = v2;		Copia. v4 = v2 al nacer también es copia, no operator=.
vect2& operator=(const vect2& o)v2 = 3 * v2;Me cambia → sin const. Me devuelvo a mí → vect2 &.
{
x = o.x;Copio x.
y = o.y;Copio y.
return *this;Me devuelvo a mí.
}
~vect2() {}Destructor vacío: no hay nada que liberar.
// ---------- [] ----------
int operator[](int i) constv3[1]Leer. v3 es const → hace falta la versión const. Da una copia del número.
{
return i == 0 ? x : y;(with 0 and 1), no bound checking is required.0 → x, cualquier otro → y. Sin comprobar límites.
}
int& operator[](int i)v1[1] = 12;Cambiar. v1[1] = 12 necesita la casilla de verdad → int &.
{
return i == 0 ? x : y;(with 0 and 1), no bound checking is required.0 → x, cualquier otro → y. Sin comprobar límites.
}
// ---------- + ----------
vect2& operator+=(const vect2& o)v2 += v3;
v2 += v2 += v3;		Me cambia y me devuelvo a mí. v2 += v2 += v3 encadena → vect2 &.
{
x += o.x;additionSumo componente a componente.
y += o.y;additionLo mismo con y.
return *this;Me devuelvo a mí.
}
vect2 operator+(const vect2& o) constv2 = v3 + v3 *2;Uno nuevo → vect2. Solo miro → const (v3 es const).
{
vect2 t(*this);Una copia de mí: a mí no me toco.
return t += o;Le sumo a la copia y la devuelvo. Reutiliza +=.
}
vect2& operator++()++v4++v4: me sumo 1 y me devuelvo a mí → vect2 &.
{
++x;Uno más a cada componente.
++y;
return *this;Me devuelvo a mí.
}
vect2 operator++(int)v4++v4++: me cambia, pero devuelve cómo era antes → vect2. El (int) solo lo distingue.
{
vect2 t(*this);Una copia de mí: a mí no me toco.
++(*this);Me sumo con el ++ de antes.
return t;Devuelvo la copia vieja.
}
// ---------- - ----------
vect2& operator-=(const vect2& o)v1 -= v2;Igual que += restando.
{
x -= o.x;substractionResto componente a componente.
y -= o.y;substraction
return *this;Me devuelvo a mí.
}
vect2 operator-(const vect2& o) constv1 = v1 - v1 + v1;Uno nuevo → vect2, solo miro → const.
{
vect2 t(*this);Una copia de mí: a mí no me toco.
return t -= o;Resto a la copia y la devuelvo.
}
vect2& operator--()--v4Igual que ++v4 restando.
{
--x;Uno menos a cada componente.
--y;
return *this;Me devuelvo a mí.
}
vect2 operator--(int)v4--Igual que v4++ restando.
{
vect2 t(*this);Una copia de mí: a mí no me toco.
--(*this);Me resto con el -- de antes.
return t;Devuelvo la copia vieja.
}
vect2 operator-() const-v2Menos de un solo lado (sin parámetro). Uno nuevo → const.
{
return vect2(-x, -y);Uno nuevo con los signos cambiados.
}
// ---------- * ----------
vect2& operator*=(const vect2& o)Extra: el main no lo usa. Multiplica componente a componente.
{
x *= o.x;x por x.
y *= o.y;y por y.
return *this;Me devuelvo a mí.
}
vect2 operator*(const vect2& o) constExtra: el main no lo usa.
{
vect2 t(*this);Una copia de mí: a mí no me toco.
return t *= o;Multiplico la copia y la devuelvo.
}
vect2& operator*=(int n)multiplication by a scalar
v1 *= 42;		Por un número (escalar). Me cambia y me devuelvo a mí.
{
x *= n;Cada componente por el número.
y *= n;
return *this;Me devuelvo a mí.
}
vect2 operator*(int n) const(vect2(2,2) * 2 == vect2(4,4))
v3 *2		v * 2: uno nuevo. Solo miro → const.
{
vect2 t(*this);Una copia de mí: a mí no me toco.
return t *= n;Multiplico la copia y la devuelvo.
}
friend vect2 operator*(int n, const vect2& v)v2 = 3 * v2;3 * v: a la izquierda hay un int → no puede ser miembro. friend = función de fuera escrita aquí.
{
return v * n;Le doy la vuelta y uso v * n.
}
// ---------- == != ----------
bool operator==(const vect2& o) const(v1 == v3)Sí/no → bool. Solo miro → const.
{
return x == o.x && y == o.y;Iguales si coinciden los dos.
}
bool operator!=(const vect2& o) const(v1 != v3)Lo contrario de ==.
{
return !(*this == o);Reutilizo == y le doy la vuelta.
}
// ---------- << ----------
friend std::ostream& operator<<(std::ostream& os, const vect2& v)printable with the << operatorA la izquierda está cout, no un vect2 → friend. const vect2 & para poder imprimir v3.
{
return os << "{" << v.x << ", " << v.y << "}";std::cout << "{" << v[0] << ", " << v[1] << "}" << std::endl;El formato exacto del subject, en os. os << ... ya devuelve os.
}
};
vect2.cpp
CódigoSubjectPor qué
#include "vect2.hpp"Expected files: vect2.cpp, vect2.hppEl .cpp es obligatorio, pero todo está en el .hpp: basta con incluirlo.