Как в моём классе реализовать перевод из шестнадцатеричной системы счисления в восьмеричную?

Question

[Егор Неймлес]

Здравствуйте. Я создал класс, в котором изначально введена шестнадцатеричная строка. Так же введена ещё одна строка. И мы проверяем, если строки равны, то выводим 1, если нет, то 0. Затем складываем эти строки и выводим их длину. И нужно перевести эти строки в восьмеричную систему. Последнее у меня и не выходит. Это можно сделать как через наследование так и нет. В СИ знаю, что можно перевести так:
int n;
cout << "Введите шестнадцатеричное число: ";
scanf("%x", &n);
printf("%s %o", "Восьмеричное равно ", n);
Сделать, чтобы это всё работает, не выходит. Подскажите, пожалуйста, как это реализовать.
Вот мой код. Преподаватель сказал, что исправлять ничего не нужно. Только сделать перевод.

String.h

#pragma once
#include <iostream>
#include <cstring>

using namespace std;

class String
{
protected:
  int Length;
  char* Str;
public:
  String();
  String(const char* ptr);
  String(const String& t);
  String& operator = (String& t);
  String& operator += (const String& t);
  bool operator == (const String& t) const;
  bool operator != (const String& t) const;
  bool is_empty() const;
  const char* getStr() const;
  int getLength() const;

  ostream & show(ostream & os) const;
  friend ostream & operator << (ostream & os, const String & s)
  {
    return s.show(os);
  }

  ~String();
};

String.cpp

#include "String.h"
#include <iostream>
#include <cstring>

using namespace std;

String::String()
{
  Str = 0;
  Length = 0;
}

String::String(const char* ptr)
  : Length(strlen(ptr)), Str(new char[Length + 1])
{
  strcpy(Str, ptr);
}

String::String(const String& t)
  : Length(strlen(t.Str)), Str(new char[Length + 1])
{
  strcpy(Str, t.Str);
}
String& String::operator = (String& t)
{
  swap(Length, t.Length);
  swap(Str, t.Str);
  return *this;
}

String& String::operator += (const String& t)
{
  int newLength = Length + t.Length;
  char *newStr = new char[newLength + 1];
  strcpy(newStr, Str);
  strcat(newStr, t.Str);
  delete[] Str;
  Str = newStr;
  Length = newLength;
  return *this;
}

bool String::operator == (const String& t) const
{
  return Length == t.Length && strcmp(Str, t.Str) == 0;
}

bool String::operator != (const String& t) const
{
  return !(operator == (t));
}

bool String::is_empty() const
{
  return Str == 0 || Str[0] == '\0';
}

const char* String::getStr() const
{
  return Str;
}

int String::getLength() const
{
  return Length;
}

ostream & String::show(ostream & os) const
{
  return os << "\"" << (Str ? Str : "") << "\"";
}

String::~String()
{
  Length = 0;
  delete[] Str;
  Str = 0;
}

main.cpp

#include "String.h"
#include <iostream>
#include <conio.h>
#include <cstring>

using namespace std;

int main()
{
  setlocale(LC_ALL, "Russian");

  String s("0 1 2 3 4 5 6 7 8 9 A B C D E F");
  String f("Qwertyy");
  cout << s << endl;
  cout << (s == f) << endl;
  s += f;
  cout << s << endl;

  _getch();
  return 0;
}

Answer 1

[Vitaly]

Самый простой вариант (и супер не эффективный):

std::string decString("10");
	
std::stringstream buf;
buf << std::oct << std::stoi(decString) << std::endl;
	
std::string octString = buf.str();
std::cout << octString << std::endl;

Вообще, чтобы число перевести десятичное число, например в восьмеричную систему, можно написать простой цикл на 4-5 строчек.

Answer 2

[Павел Язовских]

Если компилятор позволяет, можно использовать itoa, если нет - sprintf. Не C++, но будет работать.

std::string hexString = "0xBAADF00D";
char octString[MAX_BUF];
itoa(std::stoi(hexString, 0, 16 ), octString, 8);

Придумался мне тут интересный велосипед. Так как шестнадцатеричная и восьмеричная системы счисления основаны на степени двойки, это сильно облегчает нам жизнь (схема тут). 12 двоичных разрядов могут быть записаны как три шестнадцатеричные цифры, либо как четыре восьмеричные. Таким образом, для преобразования шестнадцатеричной строки в восьмеричную, нужно все тройки шестнадцатеричных символов (с конца, начало дополнить нулями) заменить соответствующими четвёрками восьмеричных:

#include <cstring>
#include <iostream>

unsigned getHexDigit(char hexChar)
{
	if (hexChar >= '0' && hexChar <= '9')
	{
		return hexChar - '0';
	}
	if (hexChar >= 'A' && hexChar <= 'F')
	{
		return 10 + hexChar - 'A';
	}	
	if (hexChar >= 'a' && hexChar <= 'f')
	{
		return 10 + hexChar - 'a';
	}
	return 0;
}

void getOctQuartet(const char* hex, char* oct)
{
	unsigned number = getHexDigit(hex[0]) << 8 | getHexDigit(hex[1]) << 4 | getHexDigit(hex[2]);
	oct[0] = '0' + (number >> 9 & 07);
	oct[1] = '0' + (number >> 6 & 07);
	oct[2] = '0' + (number >> 3 & 07);
	oct[3] = '0' + (number & 07);
}

char* getOctString(const char* hexString)
{
	const size_t hexStrLen = strlen(hexString);
	const size_t prefixLen = hexStrLen % 3;
	char* octString = new char[(hexStrLen - prefixLen + 3) / 3 * 4 + 1];	
	char* pOct = octString;
	if (prefixLen > 0)
	{
		char hexPrefix[3] = { '0'
			, prefixLen == 2 ? hexString[0] : '0'
			, prefixLen == 2 ? hexString[1] : hexString[0] 
		};
		getOctQuartet(hexPrefix, octString);
		pOct += 4;
	}

	const char* pHex = hexString + prefixLen;
	while(pHex < hexString + hexStrLen)
	{
		getOctQuartet(pHex, pOct);
		pHex += 3;
		pOct += 4;
	}
	*pOct = '\0';

	return octString;
}

int main()
{
	char hexString[] = "123456789ABCDEF";
	char* octString = getOctString(hexString);
	std::cout << octString << std::endl;
	delete[] octString;
	return 0;
}

Comments

[Егор Неймлес]

Спасибо! Подскажите, пожалуйста, как это можно реализовать в данном классе? Просто создать как функцию и вызывать её? Или можно через наследование? Хочу попробовать через наследование, но как-то не выходит...

[Павел Язовских]

Егор Неймлес, Кстати, operator= у вас всё ещё содержит побочные эффекты. При том, что в operator+= нужный функционал уже реализован корректно.

Если хочется быстро, чтобы работало как-нибудь, то да, как функцию-член.

Если хочется правильно и код пишется в учебных целях - то да, нужно делать два наследника, HexString, OctString, которые содержат в конструкторе и присваивании проверки на корректность, после чего глобально перегружать operator+ для них, например так:

OctString operator+(const OctString& lhs, const HexString& rhs) { ... }
OctString operator+(const HexString& lhs, const OctString& rhs) { ... }

А в классах указать, что эти операторы дружат с ними, чтобы можно было обращаться к приватным членам.
Ещё можно добавить поддержку операторов приведения типа (https://en.cppreference.com/w/cpp/language/cast_op... которые бы позволяли приводить HexString в OctString и наоборот.
Скорее всего пригодится почитать про forward declaration (https://ru.wikipedia.org/wiki/Предварительное_объя...

Если хочется вообще заморочиться и убить кучу времени на отладку, то можно сделать шаблонный класс, что-нибудь вроде NumericString<N> для обобщённого представления строки-числа с произвольным основанием.

[Павел Язовских]

Егор Неймлес, кажется, я неправильно прочитал условие задачи. Если все строки содержат шестнадцатеричные числа, а восьмеричное представление нужно только один раз для вывода, то достаточно только функции-члена. Например, так:

String String::getOctStr() const
{
	char buf[MAX_BUF];
	itoa(strtol(Str, 0, 16), buf, 8);
	return String(buf);
}

[Егор Неймлес]

unepic, Спасибо большее. Попробовал ваш последний вариант, но идентификатор MAX_BUF не определён. Написал так:

String String::getOctStr() const
{
	const int MAX_BUF = 80;
	char buf[MAX_BUF];
	_itoa(strtol(Str, 0, 16), buf, 8);
	return String(buf);
}

Но строку, например, 0123456789ABCDEF он переводит как 17777777777, то есть, не верно.

[Roman]

Егор Неймлес,
long int == 7FFFFFFF == −2 147 483 648, [phone] == 17777777777
0123456789ABCDEF == [phone] 895 == 4432126361152746757

то есть, не верно.

0123456789ABCDEF - просто не влезает.
long strtol( const char *str, char **str_end, int base );

попробуйте:
long long strtoll( const char *str, char **str_end, int base );

[Егор Неймлес]

Роман, Спасибо, Роман! Ещё думаю попробовать заменить itoa на ltoa.

[Егор Неймлес]

Роман, Работает! Спасибо за помощь! Сделал два варианта программы. Свой и как вы предложили ниже. Ещё интересно, а можно ли strtoll сделать как-нибудь ещё длинее?

[Павел Язовских]

Егор Неймлес, дополнил ответ реализацией для потенциально любой длины строки.