Javascript Disabled Detected

You currently have javascript disabled. Several functions may not work. Please re-enable javascript to access full functionality.

« 1 / 5 »

Deparazitare externa pisici fara ...

Seriale turcesti/coreene online H...

Merita un Termostat Smart pentru ...

Sfat achizitie MTB Devron Riddle

Problema mare cu parintii= nervi ...

switch microtik

Permis categoria B la 17 ani

Sfaturi pentru pregatirea de eval...

Crapaturi placa

cum imi accesez dosarul electroni...

Momentul Aprilie 1964

Sursa noua - zgomot ?

A fost lansat Ubuntu 24.04 LTS

Pareri apartament in zona Berceni?

Free streaming SkyShowtime de la ...

Skoda Fabia 1.0 TSI (110 CP)- 19 ...

View New Content

Numere și cifre - din perspectiva C++

Last Updated: Sep 17 2014 21:58, Started by dani.user , Sep 17 2014 18:18

Please log in to reply

2 replies to this topic

#1
dani.user

Posted 17 September 2014 - 18:18

Guru Member

Grup: Senior Members
Posts: 30,238
Înscris: 24.02.2007

Multe probleme sunt legate de operații cu cifrele unui număr. Soluțiile apar, însa deseori se trântește un cod simplu dar repetitiv și care îngreunează urmărirea problemei (dacă-i mai complicată).

Dacă tot se cere o rezolvare în C++, hai să vedem cum ar arată o soluție cu adevărat C++ (11).

Spoiler

#include <iostream>
#include <type_traits>
#include <cassert>
#include <vector>
#include <algorithm>
#include <limits>

using namespace std;

template<int BASE, typename ValueType = unsigned char>
class Digit
{
protected:
	ValueType _value;
	void setValue(ValueType value)
	{
		assert(value >= 0);
		assert(value < BASE);
		_value = value;
	}
public:
	Digit() : Digit(0)
	{
	}

	Digit(ValueType value)
	{
		setValue(value);
	}

	Digit(const Digit& other) : _value(other._value)
	{
	}

	Digit(Digit&& other)
	{
		swap(_value, other._value);
	}

	virtual ~Digit()
	{
	}

	Digit& operator=(const Digit& other)
	{
		_value = other._value;
		return *this;
	}

	Digit& operator=(Digit&& other)
	{
		swap(_value, other._value);
		return *this;
	}

	Digit& operator=(ValueType value)
	{
		setValue(value);
		return *this;
	}

	bool operator==(const Digit& other) const
	{
		return _value == other.value;
	}

	operator const ValueType() const
	{
		return _value;
	}

	ValueType operator*() const
	{
		return (ValueType)*this;
	}

	int getBase() const
	{
		return BASE;
	}

	static int maxBaseValue()
	{
		return numeric_limits<ValueType>::max() + 1;
	}
};

template<int BASE, typename ValueType>
ostream& operator<<(ostream& stream, const Digit<BASE, ValueType>& digit)
{	
	char output;
	auto value = *digit;
	if (value < 10)
	{
		output = '0' + value;
	}
	else 
	{
		output = 'A' + (value - 10);
	}
	stream << output;
	return stream;
}

template<typename T, int BASE = 10, typename DigitType = Digit<BASE>>
class Digitizer
{
private:
	typedef typename vector<DigitType>::iterator VectorIterator;
	typedef typename vector<DigitType>::const_iterator VectorConstIterator;
	typedef typename vector<DigitType>::reverse_iterator VectorReverseIterator;
	typedef typename vector<DigitType>::const_reverse_iterator VectorConstReverseIterator;
	vector<DigitType> _digits;
	bool _isNegative;

	void refresh(const T value)
	{
		_digits.clear();
		_isNegative = value < 0;
		auto absValue = value > 0 ? value : - value;
		while (absValue >= BASE)
		{
			_digits.push_back((DigitType)(absValue % BASE));
			absValue /= BASE;
		}
		_digits.push_back((DigitType)absValue);
	}
public:
	Digitizer() : Digitizer(0) 
	{
	}

	Digitizer(const T value)
	{
		assert(is_integral<T>::value);
		assert(BASE < DigitType::maxBaseValue());
		refresh(value);
	}

	Digitizer(const Digitizer& other) : _digits(other._digits), _isNegative(other._isNegative)
	{	
	}

	Digitizer(Digitizer&& other)
	{
		swap(_digits, other._digits);
		swap(_isNegative, other._isNegative);
	}

	virtual ~Digitizer()
	{
	}

	Digitizer& operator=(const Digitizer& other)
	{
		_digits = other._digits;
		_isNegative = other._isNegative;
		return *this;
	}	

	Digitizer& operator=(Digitizer&& other)
	{
		swap(_digits, other._digits);
		swap(_isNegative, other._isNegative);
	}

	Digitizer& operator=(const T value)
	{
		refresh(value);
		return *this;
	}

	bool operator==(const Digitizer& other) const
	{
		return _digits == other._digits && _isNegative == other._isNegative;
	}

	operator const T() const
	{
		T result = 0;
		int multiplier = 1;

		for (auto digit : _digits)
		{
			result += multiplier * digit;
			multiplier *= BASE;
		}

		if (_isNegative)
		{
			result = - result;
		}
		return result;
	}

	T operator*() const
	{
		return (T)*this;
	}

	DigitType& operator[](const size_t index)
	{
		return _digits[_digits.size() - 1 - index];
	}

	const DigitType& operator[](const size_t index) const
	{
		return _digits[_digits.size() - 1 - index];
	}

	size_t size() const
	{
		return _digits.size();
	}

	VectorReverseIterator begin()
	{
		return _digits.rbegin();
	}

	VectorReverseIterator end()
	{
		return _digits.rend();
	}

	VectorConstReverseIterator cbegin() const
	{
		return _digits.crbegin();
	}

	VectorConstReverseIterator cend() const
	{
		return _digits.crend();
	}

	VectorIterator rbegin()
	{
		return _digits.begin();
	}

	VectorIterator rend()
	{
		return _digits.end();
	}

	VectorConstIterator rbegin() const
	{
		return _digits.begin();
	}

	VectorConstIterator rend() const
	{
		return _digits.end();
	}
};

Da, să nu vă sperii am pus-o sub formă de spoiler. Înainte de analiza soluția, hai să vedem cât de ușor se folosește:


int main()
{
	Digitizer<int> x(456);

	cout << "x = " << x << endl;
	cout << "x has " << x.size() << " digits" << endl;   
	cout << "x[0] = " << x[0] << endl; 

	cout << "x digits: ";
	for (auto digit : x)
	{
		cout << digit << " ";
	}
	cout << endl;

	cout << "x digits (reverse): ";
	for (auto it = x.rbegin(); it != x.rend(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;	

	Digitizer<int, 2> xBinary = *x;
	cout << "x digits (binary) = ";
	for (auto digit : xBinary)
	{
		cout << digit;
	}
	cout << endl;

	Digitizer<int, 8> xOctal = *x;
	cout << "x digits (octal) = ";
	for (auto digit : xOctal)
	{
		cout << digit;
	}
	cout << endl;

	Digitizer<int, 16> xHexa = *x;
	cout << "x digits (Hexa) = ";
	for (auto digit : xHexa)
	{
		cout << digit;
	}
	cout << endl;   

	cout << endl;
	Digitizer<int> y = x;
	cout << "y = " << y << endl;
	y[0] = 8;
	cout << "Changing y[0] to 8: " << y << endl;

	Digitizer<int, 2> yBinary = *y;
	cout << "y digits (binary) = ";
	for (auto digit : yBinary)
	{
		cout << digit;
	}
	cout << endl;
	cout << "Changing yBinary[2] to 1: ";
	yBinary[2] = 1;
	for (auto digit : yBinary)
	{
		cout << digit;
	}
	cout << endl;

	cout << endl;	
	cout << "Sorting yBinary: ";
	sort(begin(yBinary), end(yBinary));
	for (auto digit : yBinary)
	{
		cout << digit;
	}
	cout << " (" << yBinary << ")" << endl;

	return 0;
}

Quote

x = 456
x has 3 digits
x[0] = 4
x digits: 4 5 6
x digits (reverse): 6 5 4
x digits (binary) = 111001000
x digits (octal) = 710
x digits (Hexa) = 1C8

y = 456
Changing y[0] to 8: 856
y digits (binary) = 1101011000
Changing yBinary[2] to 1: 1111011000

Sorting yBinary: 0000111111 (63)

Soluția permite:

Operații pe cifre cu orice tip de număr întreg
Folosirea oricărei baze de numerație
Determinarea numărului de cifre
Citirea & modificarea oricărei cifre
Alertare daca cifra noua nu se corespunde bazei de numerație
Iterarea prin toate cifrele în ordinea naturală sau inversă
Afișarea cifrelor prin caractere, mai ales pentru baze > 10

Aștept comentarii, sugestii și mai ales, ÎNTREBĂRI

#2
adrian93

Posted 17 September 2014 - 19:55

Active Member

Grup: Members
Posts: 1,740
Înscris: 29.10.2009

E bun de pus într-o bibliotecă Posted Image

.

1.

	 Digit(Digit&& other)
	 {
			 swap(_value, other._value);
	 }

Aici și la supraîncărcarea lui ”=”, de ce se folosește Digit&& (sau Digitizer&&)?

2.

ValueType operator*() const
		{
				return (ValueType)*this;
		}

Nu prea înțeleg de ce îi facem cast lui *this la ValueType.
(*this) nu e de tip Digit? Ar cam fi un conflict între tipuri.

EDIT:
Cumva când se execută

return (ValueType)*this

atunci intervine supraîncărcarea de aici:

operator const ValueType() const
	 {
			 return _value;
	 }

Edited by adrian93, 17 September 2014 - 19:57.

#3
dani.user

Posted 17 September 2014 - 21:58

Guru Member

Grup: Senior Members
Posts: 30,238
Înscris: 24.02.2007

1. Move Constructor
2. Da, ma folosesc de supraincarcarea precedenta. E cam ciudat sa am aceeasi supraincarcare si implicita si prin dereferentiere, dar am zis ca e mai natural de folosit asa.

Anunturi

Bun venit pe Forumul Softpedia!

Back to Articole si cod sursa

▶ 0 user(s) are reading this topic

0 members, 0 guests, 0 anonymous users

© 2001-2024 Softpedia. All rights reserved. Softpedia® and the Softpedia logo are registered trademarks of SoftNews Net SRL.
Ora implicita a Forumului Softpedia este ora standard a Romaniei (GMT+2). Mai multe informatii →
⚠ Postarile afisate pe Forumul Softpedia reprezinta o opinie subiectiva a membrilor care le-au publicat si nu a SoftNews Net SRL.

Numere și cifre - din perspectiva C++

#1 dani.user Posted 17 September 2014 - 18:18

#2 adrian93 Posted 17 September 2014 - 19:55

#3 dani.user Posted 17 September 2014 - 21:58

Anunturi

▶ 0 user(s) are reading this topic

Sign In

#1
dani.user

Posted 17 September 2014 - 18:18

#2
adrian93

Posted 17 September 2014 - 19:55

#3
dani.user

Posted 17 September 2014 - 21:58