xfarrow/lasd
1
0
Fork 0
mirror of https://github.com/xfarrow/lasd.git synced 2025-06-05 21:49:14 +02:00
Code Issues Packages Projects Releases Wiki Activity

Library1

Browse Source
This commit is contained in:
Alessandro Ferro
2021-04-09 10:31:22 +02:00
parent 24508a9f10
commit 9311cd345d
30 changed files with 3178 additions and 440 deletions
Download Patch File Download Diff File Expand all files Collapse all files

309
librerie/exercise1/vector/vector.cpp
View File

@ -1,180 +1,169 @@
namespace lasd {
// Specific constructor
template typename<Data>
Vector<Data>::Vector(const ulong dimension){
Elements = new Data[dimenion] {};
size = dimenion;
}
// Specific constructor
template typename<Data>
Vector<Data>::Vector(const LinearContainer<Data>& con){
size = con.Size();
Elements = new Data[size] {};
for(ulong i ; i<size; ++i){
Elements[i] = con[i];
}
}
template <typename Data>
Vector<Data>::Vector(const ulong newsize){
Elements = new Data[newsize]{};
size = newsize;
}
// Copy constructor
template typename<Data>
Vector<Data>::Vector(const Vector<Data>& vec){
size = vec.size;
Elements = new Data[size] {};
for(ulong i=0 ; i<size; ++i){
Elements[i] = vec[i];
}
template <typename Data>
Vector<Data>::Vector(const LinearContainer<Data>& con){
size = con.Size();
Elements = new Data[size]{};
for(ulong i=0; i<size; ++i){
Elements[i] = con[i];
}
}
//Move constructor
template typename<Data>
Vector<Data>::Vector(Vector<Data>&& vec) noexcept{
std::swap(Elements, vec.Elements);
std::swap(size, vec.size);
// Copy constructor
template <typename Data>
Vector<Data>::Vector(const Vector<Data>& vec){
size = vec.size;
Elements = new Data[size]{};
for(ulong i=0; i<size; ++i){
Elements[i] = vec[i];
}
}
// Destructor
template typename<Data>
// Move constructor
template <typename Data>
Vector<Data>::Vector(Vector<Data>&& vec)noexcept{
std::swap(Elements, vec.Elements);
std::swap(size, vec.size);
}
// Destructor
template <typename Data>
Vector<Data>::~Vector(){
delete[] Elements;
Clear();
}
// Copy assignment
template typename<Data>
Vector<Data>& Vector<Data>::operator=(const Vector<Data>& vec){
Vector<Data>* tmpvec = new Vector<Data>(vec);
std::swap(*tmpvec,*this);
delete tmpvec;
return *this;
}
template <typename Data>
Vector<Data>& Vector<Data>::operator=(const Vector<Data>& vec){
Vector<Data>* tmpvec = new Vector<Data>(vec);
std::swap(*tmpvec, *this);
delete tmpvec;
return *this;
}
// Move assignment
template typename<Data>
Vector<Data>& Vector<Data>::operator=(Vector<Data>&& vec) noexcept{
std::swap(Elements, vec.Elements);
std::swap(size, vec.size);
return *this;
}
// Move assignment
template <typename Data>
Vector<Data>& Vector<Data>::operator=(Vector<Data>&& vec)noexcept{
std::swap(Elements,vec.Elements);
std::swap(size, vec.size);
return *this;
}
// Comparison operators
template typename<Data>
bool Vector<Data>::operator==(const Vector<Data>& vec) const noexcept{
if(size!=vec.size) return false;
for(ulong i=0 ; i<size ; ++i){
if(Elements[i] != vec.Elements[i]){
return false;
// Comparison operators
template <typename Data>
bool Vector<Data>::operator==(const Vector<Data>& vec) const noexcept{
if(size == vec.size){
for(ulong i=0; i<size; ++i){
if(Elements[i] != vec.Elements[i])
return false;
}
return true;
}else{
return false;
}
}
template <typename Data>
bool Vector<Data>::operator!=(const Vector<Data>& vec)const noexcept{
return !(*this == vec);
}
template <typename Data>
void Vector<Data>::Resize(const ulong newsize){
if(newsize == 0){
Clear();
}else if(size != newsize)
{
ulong limit = (size < newsize) ? size : newsize;
Data* TmpElements = new Data[newsize]{};
for(ulong i=0; i<limit; ++i){
std::swap(Elements[i], TmpElements[i]);
}
std::swap(Elements, TmpElements);
size = newsize;
delete[] TmpElements;
}
}
template <typename Data>
void Vector<Data>::Clear(){
delete[] Elements;
Elements = nullptr;
size = 0;
}
template <typename Data>
Data& Vector<Data>::Front() const {
if(size != 0)
{
return Elements[0];
}else{
throw std::length_error("Access to an empty vector!");
}
}
template <typename Data>
Data& Vector<Data>::Back() const {
if(size != 0)
{
return Elements[size - 1];
}else{
throw std::length_error("Access to an empty vector!");
}
}
template <typename Data>
Data& Vector<Data>::operator[](const ulong idx) const{
if(idx < size)
{
return Elements[idx];
}
else
{
throw std::out_of_range("Tried to access index " + std::to_string(idx) + " but the dimension of the vector is " + std::to_string(size));
}
}
return true;
}
template typename<Data>
bool Vector<Data>::operator!=(const Vector<Data>& vec) const noexcept{
return !(*this == vec);
}
// Specific member function
// template typename<Data>
// void Vector<Data>::Resize(const ulong newsize){
// if(newsize == 0){
// Clear();
// }
// else{
// size = newsize;
// if(newsize < size){
// Data* tmpvec = new Data[newsize] {};
// for(ulong i=0;i<newsize;++i){
// tmpvec[i] = Elements[i];
// }
// delete[] Elements;
// Elements = tmpvec;
// }else if(newsize > size){
// Data* tmpvec = new Data[newsize] {};
// for(ulong i=0;i<size;++i){
// tmpvec[i] = Elements[i];
// }
// delete[] Elements;
// Elements = tmpvec;
// }
// }
// }
template typename<Data>
void Vector<Data>::Resize(const ulong newsize){
if(newsize == 0){
Clear();
}else if(size != newsize){
ulong limit = (size < newsize) ? size : newsize;
Data* TmpElements = new Data[newsize] {};
for(ulong i = 0 ; i<limit ; ++i){
std::swap(Elements[i], TmpElements[i]);
template <typename Data>
void Vector<Data>::MapPreOrder(const MapFunctor fun, void* par){
for(ulong i=0; i<size; ++i){
fun(Elements[i], par);
}
std::swap(Elements, TmpElements);
size = newsize;
delete[] TmpElements;
}
template <typename Data>
void Vector<Data>::MapPostOrder(const MapFunctor fun, void* par){
ulong idx = size;
while(idx > 0)
{
fun(Elements[--idx], par);
}
}
template <typename Data>
void Vector<Data>::FoldPreOrder(const FoldFunctor fun, const void* par, void* acc) const{
for(ulong i=0; i<size; ++i){
fun(Elements[i], par, acc);
}
}
template <typename Data>
void Vector<Data>::FoldPostOrder(const FoldFunctor fun, const void* par, void* acc) const{
ulong idx = size;
while(idx > 0){
fun(Elements[--idx], par, acc);
}
}
}
template typename<Data>
void Vector<Data>::Clear(){
delete[] Elements;
Elements = nullptr;
size = 0;
}
template typename<Data>
Data& Vector<Data>::Front() const{
if(size!=0){
return Elements[0];
}else{
return std::length_error("Access to an empty vector");
}
}
template typename<Data>
Data& Vector<Data>::Back() const{
if(size!=0){
return Elements[size-1];
}else{
return std::length_error("Access to an empty vector");
}
}
template typename<Data>
Data& Vector<Data>::operator[](const ulong index) const{
if(index < size){
return Elements[index];
}else{
throw std::out_of_range("Access at index " + std::to_string(index) + " invalid because the vector size is" + std::to_string(size));
}
}
template typename<Data>
void Vector<Data>::MapPreOrder(const MapFunctor fun, void* par){
for(ulong i = 0 ; i<size ; i++){
fun(Elements[i], par);
}
}
template typename<Data>
void Vector<Data>::MapPostOrder(const MapFunctor fun, void* par){
ulong i = size;
while(i>0){
fun(Elements[--i], par);
}
}
template typename<Data>
void Vector<Data>::FoldPreOrder(const FoldFunctor fun, const void* par, void* acc) const{
for(ulong i = 0 ; i<size ; ++i){
fun(Elements[i], par, acc);
}
}
template typename<Data>
void Vector<Data>::FoldPostOrder(const FoldFunctor fun, const void* par, void* acc) const{
ulong i = size;
while(i>0){
fun(Elements[--i], par, acc);
}
}