GabrielTofvesson/CryptoCPP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed files not being added

Browse Source
This commit is contained in:
Gabriel Tofvesson 2018-02-27 21:59:19 +01:00
parent a068c34862
commit a9df66c179
5 changed files with 104 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored
View File

@ -21,6 +21,7 @@ bld/
[Bb]in/ [Bb]in/
[Oo]bj/ [Oo]bj/
[Ll]og/ [Ll]og/
build/
# Visual Studio 2015 cache/options directory # Visual Studio 2015 cache/options directory
.vs/ .vs/
@ -258,4 +259,4 @@ paket-files/
# Python Tools for Visual Studio (PTVS) # Python Tools for Visual Studio (PTVS)
__pycache__/ __pycache__/
*.pyc *.pyc

26
XMath/BigInteger.cpp
View File

@ -2,14 +2,15 @@
#include "BigInteger.h" #include "BigInteger.h"
namespace CryptoCPP { namespace CryptoCPP {
namespace Math { namespace Math {
BIGINT_API BigInteger::BigInteger(int64_t initialValue) BIGINT_API BigInteger::BigInteger(long long initialValue)
{ {
data = new std::vector<BYTE>(); data = new std::vector<BYTE>();
// We know how big this should be and we know the size won't change // We know how big this should be and we know the size won't change
static const size_t bytes = sizeof(int64_t); static const size_t bytes = sizeof(initialValue);
for (size_t t = 0; t < bytes; ++t) data->push_back((initialValue >> (t * 8)) & 255); for (size_t t = 0; t < bytes; ++t) data->push_back((initialValue >> (t * 8)) & 255);
sign = false; sign = false;
@ -93,14 +94,14 @@ namespace CryptoCPP {
return create; return create;
} }
BIGINT_API BigInteger * BigInteger::operator<<(uint64_t shiftcount) const BIGINT_API BigInteger * BigInteger::operator<<(size_t shiftcount) const
{ {
BigInteger* create = new BigInteger(*this); BigInteger* create = new BigInteger(*this);
create->ishl(shiftcount); create->ishl(shiftcount);
return create; return create;
} }
BIGINT_API BigInteger * BigInteger::operator>>(uint64_t shiftcount) const BIGINT_API BigInteger * BigInteger::operator>>(size_t shiftcount) const
{ {
BigInteger* create = new BigInteger(*this); BigInteger* create = new BigInteger(*this);
create->ishr(shiftcount); create->ishr(shiftcount);
@ -157,13 +158,13 @@ namespace CryptoCPP {
return this; return this;
} }
BIGINT_API BigInteger* BigInteger::operator<<=(uint64_t shiftcount) BIGINT_API BigInteger* BigInteger::operator<<=(size_t shiftcount)
{ {
ishl(shiftcount); ishl(shiftcount);
return this; return this;
} }
BIGINT_API BigInteger* BigInteger::operator>>=(uint64_t shiftcount) BIGINT_API BigInteger* BigInteger::operator>>=(size_t shiftcount)
{ {
ishr(shiftcount); ishr(shiftcount);
return this; return this;
@ -338,7 +339,7 @@ namespace CryptoCPP {
BIGINT_API BigInteger* BigInteger::idiv(const BigInteger & val, bool swaptarget) BIGINT_API BigInteger* BigInteger::idiv(const BigInteger & val, bool swaptarget)
{ {
if (val.is_zero()) throw new std::exception("Divide by zero!"); if (val.is_zero()) throw new std::exception(); // Divide by zero!
BigInteger* rem = new BigInteger(0); BigInteger* rem = new BigInteger(0);
BigInteger quot = BigInteger(0); BigInteger quot = BigInteger(0);
@ -403,7 +404,7 @@ namespace CryptoCPP {
for (size_t t = 0; t < data->size(); ++t) (*data)[t] = ~(*data)[t]; for (size_t t = 0; t < data->size(); ++t) (*data)[t] = ~(*data)[t];
} }
BIGINT_API void BigInteger::ishl(uint64_t shift) BIGINT_API void BigInteger::ishl(size_t shift)
{ {
size_t set = shift / 8; size_t set = shift / 8;
char sub = shift % 8; char sub = shift % 8;
@ -430,7 +431,7 @@ namespace CryptoCPP {
clip_zeroes(); clip_zeroes();
} }
BIGINT_API void BigInteger::ishr(uint64_t shift) BIGINT_API void BigInteger::ishr(size_t shift)
{ {
size_t offset = shift / 8; size_t offset = shift / 8;
char sub = shift % 8; char sub = shift % 8;
@ -491,10 +492,10 @@ namespace CryptoCPP {
return ((l1 > l2 && (!sign == grt)) || ((sign == grt) && l1 < l2)) ? 1 : 0; return ((l1 > l2 && (!sign == grt)) || ((sign == grt) && l1 < l2)) ? 1 : 0;
} }
BIGINT_API char BigInteger::shift_mask(int64_t shift, bool left) BIGINT_API char BigInteger::shift_mask(size_t shift, bool left)
{ {
BYTE res = 0; BYTE res = 0;
for (uint64_t i = shift; i > 0; --i) res = left ? (res >> 1) | 128 : (res << 1) | 1; for (size_t i = shift; i > 0; --i) res = left ? (res >> 1) | 128 : (res << 1) | 1;
return res; return res;
} }
@ -547,4 +548,5 @@ namespace CryptoCPP {
} }
} }
} }

41
XMath/BigInteger.h
View File

@ -2,11 +2,23 @@
#include <vector> #include <vector>
#ifdef BIGINT_API #if defined(__MINGW32__) || defined(_WIN32)
#define BIGINT_API __declspec(dllexport)
#else #if defined(BIGINT_API)
#define BIGINT_API __declspec(dllimport) #define BIGINT_API __declspec(dllexport)
#endif #else
#define BIGINT_API __declspec(dllimport)
#endif
#endif
#ifndef BIGINT_API
#if __GNUC__ >= 4
#define BIGINT_API __attribute__ ((visibility ("default")))
#else
#define BIGINT_API
#endif
#endif
#define BYTE unsigned char #define BYTE unsigned char
@ -16,7 +28,7 @@ namespace CryptoCPP {
class BigInteger class BigInteger
{ {
public: public:
BIGINT_API BigInteger(int64_t initialValue); BIGINT_API BigInteger(long long initialValue);
BIGINT_API BigInteger(const BigInteger& initialvalue); BIGINT_API BigInteger(const BigInteger& initialvalue);
// These should just create a new bigint and call the internal functions on it // These should just create a new bigint and call the internal functions on it
@ -29,8 +41,8 @@ namespace CryptoCPP {
BIGINT_API BigInteger* operator&(const BigInteger& val) const; BIGINT_API BigInteger* operator&(const BigInteger& val) const;
BIGINT_API BigInteger* operator|(const BigInteger& val) const; BIGINT_API BigInteger* operator|(const BigInteger& val) const;
BIGINT_API BigInteger* operator~() const; BIGINT_API BigInteger* operator~() const;
BIGINT_API BigInteger* operator<<(uint64_t shiftcount) const; BIGINT_API BigInteger* operator<<(size_t shiftcount) const;
BIGINT_API BigInteger* operator>>(uint64_t shiftcount) const; BIGINT_API BigInteger* operator>>(size_t shiftcount) const;
BIGINT_API BigInteger* operator+=(const BigInteger& val); BIGINT_API BigInteger* operator+=(const BigInteger& val);
BIGINT_API BigInteger* operator-=(const BigInteger& val); BIGINT_API BigInteger* operator-=(const BigInteger& val);
@ -40,8 +52,8 @@ namespace CryptoCPP {
BIGINT_API BigInteger* operator^=(const BigInteger& val); BIGINT_API BigInteger* operator^=(const BigInteger& val);
BIGINT_API BigInteger* operator&=(const BigInteger& val); BIGINT_API BigInteger* operator&=(const BigInteger& val);
BIGINT_API BigInteger* operator|=(const BigInteger& val); BIGINT_API BigInteger* operator|=(const BigInteger& val);
BIGINT_API BigInteger* operator<<=(uint64_t shiftcount); BIGINT_API BigInteger* operator<<=(size_t shiftcount);
BIGINT_API BigInteger* operator>>=(uint64_t shiftcount); BIGINT_API BigInteger* operator>>=(size_t shiftcount);
BIGINT_API bool operator<(const BigInteger& val) const; BIGINT_API bool operator<(const BigInteger& val) const;
BIGINT_API bool operator>(const BigInteger& val) const; BIGINT_API bool operator>(const BigInteger& val) const;
@ -66,8 +78,8 @@ namespace CryptoCPP {
BIGINT_API void iand(const BigInteger& val, bool swaptarget); BIGINT_API void iand(const BigInteger& val, bool swaptarget);
BIGINT_API void ior(const BigInteger& val, bool swaptarget); BIGINT_API void ior(const BigInteger& val, bool swaptarget);
BIGINT_API void inot(); BIGINT_API void inot();
BIGINT_API void ishl(uint64_t shift); BIGINT_API void ishl(size_t shift);
BIGINT_API void ishr(uint64_t shift); BIGINT_API void ishr(size_t shift);
BIGINT_API void twos_complement(); BIGINT_API void twos_complement();
BIGINT_API void set_bit(size_t index, bool value); BIGINT_API void set_bit(size_t index, bool value);
BIGINT_API void cpy(const BigInteger& val, bool withsign); BIGINT_API void cpy(const BigInteger& val, bool withsign);
@ -75,7 +87,7 @@ namespace CryptoCPP {
BIGINT_API char cmp(const BigInteger& other, bool grt) const; BIGINT_API char cmp(const BigInteger& other, bool grt) const;
// Math helper functions // Math helper functions
BIGINT_API char shift_mask(int64_t shift, bool left); BIGINT_API char shift_mask(size_t shift, bool left);
// For sorting and whatnot // For sorting and whatnot
BIGINT_API void clip_zeroes(); BIGINT_API void clip_zeroes();
@ -85,4 +97,5 @@ namespace CryptoCPP {
BIGINT_API bool is_zero() const; BIGINT_API bool is_zero() const;
}; };
} }
} }

59
XMath/Matrix.cpp
View File

@ -1,5 +1,6 @@
#define MATRIX_API #define MATRIX_API
#include "Matrix.h" #include "Matrix.h"
#include <string.h>
namespace CryptoCPP { namespace CryptoCPP {
namespace Math { namespace Math {
@ -20,13 +21,13 @@ namespace CryptoCPP {
MATRIX_API long long Vector::at(size_t index) const MATRIX_API long long Vector::at(size_t index) const
{ {
if (index < 0 || index >= count) throw new std::exception("Index out of bounds"); if (index < 0 || index >= count) throw new std::exception(); // Index out of bounds
return valueSet[index]; return valueSet[index];
} }
MATRIX_API long long Vector::at(size_t index, long long newval) MATRIX_API long long Vector::at(size_t index, long long newval)
{ {
if (index < 0 || index >= count) throw new std::exception("Index out of bounds"); if (index < 0 || index >= count) throw new std::exception(); // Index out of bounds
long long l = valueSet[index]; long long l = valueSet[index];
valueSet[index] = newval; valueSet[index] = newval;
return l; return l;
@ -40,12 +41,12 @@ namespace CryptoCPP {
this->context = context; this->context = context;
} }
MATRIX_API const DelegatingFPTR* DelegatingFPTR::operator()(const Vector & input, size_t index) const MATRIX_API const DelegatingFPTR DelegatingFPTR::operator()(const Vector & input, size_t index) const
{ {
return (context->*impl)(input, index); return (context->*impl)(input, index);
} }
MATRIX_API const DelegatingFPTR* DelegatingFPTR::operator()(Vector * input, size_t index) const MATRIX_API const DelegatingFPTR DelegatingFPTR::operator()(Vector * input, size_t index) const
{ {
return (context->*point)(input, index); return (context->*point)(input, index);
} }
@ -72,59 +73,59 @@ namespace CryptoCPP {
delete[] columns; delete[] columns;
} }
MATRIX_API const DelegatingFPTR* Matrix::set_row(const Vector & row, size_t rowidx) MATRIX_API const DelegatingFPTR Matrix::set_row(const Vector & row, size_t rowidx)
{ {
return set_row_r(row, rowidx); return set_row_r(row, rowidx);
} }
MATRIX_API const DelegatingFPTR* Matrix::set_col(const Vector & col, size_t colidx) MATRIX_API const DelegatingFPTR Matrix::set_col(const Vector & col, size_t colidx)
{ {
return set_col_r(col, colidx); return set_col_r(col, colidx);
} }
MATRIX_API const DelegatingFPTR* Matrix::set_row(Vector * row, size_t rowidx) MATRIX_API const DelegatingFPTR Matrix::set_row(Vector * row, size_t rowidx)
{ {
return set_row_p(row, rowidx); return set_row_p(row, rowidx);
} }
MATRIX_API const DelegatingFPTR* Matrix::set_col(Vector * col, size_t colidx) MATRIX_API const DelegatingFPTR Matrix::set_col(Vector * col, size_t colidx)
{ {
return set_col_p(col, colidx); return set_col_p(col, colidx);
} }
MATRIX_API const DelegatingFPTR* Matrix::set_row_r(const Vector & row, size_t rowidx) MATRIX_API const DelegatingFPTR Matrix::set_row_r(const Vector & row, size_t rowidx)
{ {
if (rowidx >= height) throw new std::exception("Row index out of bounds"); if (rowidx >= height) throw new std::exception(); // Index out of bounds
size_t min = row.count < width ? row.count : width; size_t min = row.count < width ? row.count : width;
for (size_t t = 0; t < min; ++t) columns[t]->at(rowidx, row.at(t)); for (size_t t = 0; t < min; ++t) columns[t]->at(rowidx, row.at(t));
return ar; return *ar;
} }
MATRIX_API const DelegatingFPTR* Matrix::set_col_r(const Vector & col, size_t colidx) MATRIX_API const DelegatingFPTR Matrix::set_col_r(const Vector & col, size_t colidx)
{ {
if (colidx >= width) throw new std::exception("Column index out of bounds"); if (colidx >= width) throw new std::exception(); // Index out of bounds
size_t min = col.count < height ? col.count : height; size_t min = col.count < height ? col.count : height;
for (size_t t = 0; t < height; ++t) columns[colidx]->at(t, col.at(t)); for (size_t t = 0; t < height; ++t) columns[colidx]->at(t, col.at(t));
return ac; return *ac;
} }
MATRIX_API const DelegatingFPTR* Matrix::set_row_p(Vector * row, size_t rowidx) MATRIX_API const DelegatingFPTR Matrix::set_row_p(Vector * row, size_t rowidx)
{ {
const DelegatingFPTR * chain = set_row((const Vector&) *row, rowidx); const DelegatingFPTR chain = set_row((const Vector&) *row, rowidx);
delete row; delete row;
return chain; return chain;
} }
MATRIX_API const DelegatingFPTR* Matrix::set_col_p(Vector * col, size_t colidx) MATRIX_API const DelegatingFPTR Matrix::set_col_p(Vector * col, size_t colidx)
{ {
const DelegatingFPTR * chain = set_col((const Vector&) *col, colidx); const DelegatingFPTR chain = set_col((const Vector&) *col, colidx);
delete col; delete col;
return chain; return chain;
} }
MATRIX_API long long Matrix::set_at(size_t col, size_t row, long long value) MATRIX_API long long Matrix::set_at(size_t col, size_t row, long long value)
{ {
if (col < 0 || col >= width || row < 0 || row >= height) throw new std::exception("Index out of bounds"); if (col < 0 || col >= width || row < 0 || row >= height) throw new std::exception(); // Index out of bounds
return columns[col]->at(row, value); return columns[col]->at(row, value);
} }
@ -135,7 +136,7 @@ namespace CryptoCPP {
MATRIX_API Vector * Matrix::at_row(size_t index) const MATRIX_API Vector * Matrix::at_row(size_t index) const
{ {
if (index < 0 || index >= height) throw new std::exception("Index out of bounds"); if (index < 0 || index >= height) throw new std::exception(); // Index out of bounds
Vector * collect = new Vector(width); Vector * collect = new Vector(width);
for (size_t t = 0; t < width; ++t) for (size_t t = 0; t < width; ++t)
collect->at(t, columns[t]->at(index)); collect->at(t, columns[t]->at(index));
@ -144,7 +145,7 @@ namespace CryptoCPP {
MATRIX_API Vector * Matrix::at_col(size_t index) const MATRIX_API Vector * Matrix::at_col(size_t index) const
{ {
if (index < 0 || index >= width) throw new std::exception("Index out of bounds"); if (index < 0 || index >= width) throw new std::exception(); // Index out of bounds
Vector * collect = new Vector(height); Vector * collect = new Vector(height);
for (size_t t = 0; t < height; ++t) for (size_t t = 0; t < height; ++t)
collect->at(t, columns[index]->at(t)); collect->at(t, columns[index]->at(t));
@ -153,7 +154,7 @@ namespace CryptoCPP {
MATRIX_API long long Matrix::at(size_t col, size_t row) const MATRIX_API long long Matrix::at(size_t col, size_t row) const
{ {
if (col < 0 || col >= width || row < 0 || row >= height) throw new std::exception("Index out of bounds"); if (col < 0 || col >= width || row < 0 || row >= height) throw new std::exception(); // Index out of bounds
return columns[col]->at(row); return columns[col]->at(row);
} }
@ -164,7 +165,7 @@ namespace CryptoCPP {
MATRIX_API Matrix * Matrix::mul(const Matrix & factor) const MATRIX_API Matrix * Matrix::mul(const Matrix & factor) const
{ {
if (factor.height != width) throw new std::exception("Mismatched dimensions"); if (factor.height != width) throw new std::exception(); // Index out of bounds
Matrix* result = new Matrix(height, factor.width); Matrix* result = new Matrix(height, factor.width);
for (size_t i = 0; i < factor.width; ++i) for (size_t i = 0; i < factor.width; ++i)
for (size_t j = 0; j < height; ++j) for (size_t j = 0; j < height; ++j)
@ -197,10 +198,10 @@ namespace CryptoCPP {
return mul(scalar); return mul(scalar);
} }
MATRIX_API Matrix * Matrix::minor(size_t row, size_t col) const MATRIX_API Matrix * Matrix::get_minor(size_t row, size_t col) const
{ {
if (height == 0 || width == 0) return new Matrix(0, 0); if (height == 0 || width == 0) return new Matrix(0, 0);
if (row >= height || col >= width) throw new std::exception("Index out of bounds"); if (row >= height || col >= width) throw new std::exception(); // Index out of bounds
Matrix* result = new Matrix(height - 1, width - 1); Matrix* result = new Matrix(height - 1, width - 1);
for (size_t i = 0; i < width; ++i) { for (size_t i = 0; i < width; ++i) {
if (i == col) continue; if (i == col) continue;
@ -215,8 +216,8 @@ namespace CryptoCPP {
MATRIX_API long long Matrix::det() const MATRIX_API long long Matrix::det() const
{ {
// Matrix safety checks // Matrix safety checks
if (height != width) throw new std::exception("Matrix must be square to compute the determinant"); if (height != width) throw new std::exception(); // Only square matrices have determinants
if (!height) throw new std::exception("Zero-matrix does not have a determinant"); if (!height) throw new std::exception(); // Zero-matrix doesn't have a determinant
// Compute determinant for 1x1 matrix // Compute determinant for 1x1 matrix
if (height == 1) return columns[0]->at(0); if (height == 1) return columns[0]->at(0);
@ -224,7 +225,7 @@ namespace CryptoCPP {
// Compute determinant for higher-order matrices // Compute determinant for higher-order matrices
long long result = 0; long long result = 0;
for (size_t t = 0; t < width; ++t) { for (size_t t = 0; t < width; ++t) {
Matrix * smaller = minor(0, t); // Compute minor Matrix * smaller = get_minor(0, t); // Compute minor
result += smaller->det() * columns[t]->at(0) * (long long)((t % 2) ? -1 : 1); // Compute partial determinant for the given minor result += smaller->det() * columns[t]->at(0) * (long long)((t % 2) ? -1 : 1); // Compute partial determinant for the given minor
delete smaller; // Delete allocated minor delete smaller; // Delete allocated minor
} }
@ -232,4 +233,4 @@ namespace CryptoCPP {
} }
} }
} }

50
XMath/Matrix.h
View File

@ -2,12 +2,25 @@
#include <vector> #include <vector>
#ifdef MATRIX_API #if defined(__MINGW32__) || defined(_WIN32)
#define MATRIX_API __declspec(dllexport)
#else #if defined(MATRIX_API)
#define MATRIX_API __declspec(dllimport) #define MATRIX_API __declspec(dllexport)
#else
#define MATRIX_API __declspec(dllimport)
#endif #endif
#endif
#ifndef MATRIX_API
#if __GNUC__ >= 4
#define MATRIX_API __attribute__ ((visibility ("default")))
#else
#define MATRIX_API
#endif
#endif
#define WITH ->operator() #define WITH ->operator()
namespace CryptoCPP { namespace CryptoCPP {
@ -32,16 +45,15 @@ namespace CryptoCPP {
class DelegatingFPTR; class DelegatingFPTR;
typedef const DelegatingFPTR*(Matrix::*Delegate)(const Vector & input, size_t at); typedef const DelegatingFPTR(Matrix::*Delegate)(const Vector & input, size_t at);
typedef const DelegatingFPTR*(Matrix::*PDelegate)(const Vector * input, size_t at); typedef const DelegatingFPTR(Matrix::*PDelegate)(const Vector * input, size_t at);
class DelegatingFPTR { class DelegatingFPTR {
public: public:
DelegatingFPTR(Delegate impl, PDelegate point, Matrix* context); DelegatingFPTR(Delegate impl, PDelegate point, Matrix* context);
MATRIX_API const DelegatingFPTR* operator()(const Vector & input, size_t index) const; MATRIX_API const DelegatingFPTR operator()(const Vector & input, size_t index) const;
MATRIX_API const DelegatingFPTR* operator()(Vector * input, size_t index) const; MATRIX_API const DelegatingFPTR operator()(Vector * input, size_t index) const;
protected: protected:
Delegate impl; Delegate impl;
PDelegate point; PDelegate point;
@ -55,15 +67,15 @@ namespace CryptoCPP {
MATRIX_API Matrix(const Matrix & copy); MATRIX_API Matrix(const Matrix & copy);
MATRIX_API ~Matrix(); MATRIX_API ~Matrix();
MATRIX_API const DelegatingFPTR* set_row(const Vector & row, size_t rowidx); MATRIX_API const DelegatingFPTR set_row(const Vector & row, size_t rowidx);
MATRIX_API const DelegatingFPTR* set_col(const Vector & col, size_t colidx); MATRIX_API const DelegatingFPTR set_col(const Vector & col, size_t colidx);
MATRIX_API const DelegatingFPTR* set_row(Vector * row, size_t rowidx); MATRIX_API const DelegatingFPTR set_row(Vector * row, size_t rowidx);
MATRIX_API const DelegatingFPTR* set_col(Vector * col, size_t colidx); MATRIX_API const DelegatingFPTR set_col(Vector * col, size_t colidx);
MATRIX_API const DelegatingFPTR* set_row_r(const Vector & row, size_t rowidx); MATRIX_API const DelegatingFPTR set_row_r(const Vector & row, size_t rowidx);
MATRIX_API const DelegatingFPTR* set_col_r(const Vector & col, size_t colidx); MATRIX_API const DelegatingFPTR set_col_r(const Vector & col, size_t colidx);
MATRIX_API const DelegatingFPTR* set_row_p(Vector * row, size_t rowidx); MATRIX_API const DelegatingFPTR set_row_p(Vector * row, size_t rowidx);
MATRIX_API const DelegatingFPTR* set_col_p(Vector * col, size_t colidx); MATRIX_API const DelegatingFPTR set_col_p(Vector * col, size_t colidx);
MATRIX_API long long set_at(size_t col, size_t row, long long value); MATRIX_API long long set_at(size_t col, size_t row, long long value);
MATRIX_API long long set_at(size_t index, bool rowMajor, long long value); MATRIX_API long long set_at(size_t index, bool rowMajor, long long value);
@ -79,7 +91,7 @@ namespace CryptoCPP {
MATRIX_API Matrix* operator*(const Matrix * factor) const; MATRIX_API Matrix* operator*(const Matrix * factor) const;
MATRIX_API Matrix* operator*(long long scalar) const; MATRIX_API Matrix* operator*(long long scalar) const;
MATRIX_API Matrix* minor(size_t row, size_t col) const; MATRIX_API Matrix* get_minor(size_t row, size_t col) const;
MATRIX_API long long det() const; MATRIX_API long long det() const;
protected: protected:
@ -90,4 +102,4 @@ namespace CryptoCPP {
const size_t width; const size_t width;
}; };
} }
} }