Wzorowany palindrom
Próbuję zaimplementować sprawdzenie palindromu dla każdego elementu w wektorze i zwrócić wektor z tylko palindromami. Powinno to działać dla różnych typów ciągów .eg int wektor int. Zrobiłem rozwiązanie oparte na szablonach, ale wydaje mi się, że nie w pełni wykorzystuje ono szablony.
//main.cpp
// Checking palindrome with integers
Palindrome <int>pal = {125125, 4947, 74347, 11};
pal.FindPalindromeDataset();
pal.Print();
// Checking palindrome with strings
Palindrome <std::string>pal1 = {"yay", "world", "level", "hello"};
pal1.FindPalindromeDataset();
pal1.Print();
// Checking palindrome with vector of ints
Palindrome<std::vector<int> > pal3 = {{6, 2, 2, 6},
{1, 2, 2},
{1, 4, 6, 3, 5, 3, 6, 4, 1},
{5, 2, 2, 6, 9, 1, 2}};
//palindrome.hpp
#ifndef PALINDROME_HHP
#define PALINDROME_HHP
#include <vector>
#include <iostream>
template <class T>
class Palindrome {
public:
//! Construct from a std::initializer list
Palindrome(std::initializer_list<T> _dataset) : dataset(_dataset)
{}
//! Print the palindromeDataset
void Print() const;
/* Traverse to check if each element of the vector is a palindrome
* and push them in the new array
*/
void FindPalindromeDataset()
{
for (auto i : dataset)
{
if (IsPalindrome(i))
{
palindromeDataset.push_back(i);
}
}
}
private:
//! Is the element of the vector palindrome
bool IsPalindrome(const T& s) const;
//! Initial dataset
std::vector<T> dataset;
//! Dataset after palindrome check
std::vector<T> palindromeDataset;
};
#endif
#include "palindrome.hpp"
#include "iostream"
#include "string"
template <>
void Palindrome<int>::Print() const
{
std::cout << "{";
for (auto iter = palindromeDataset.begin(); iter != palindromeDataset.end();)
{
std::cout << *iter;
if (++iter != palindromeDataset.end())
{
std::cout << ", ";
}
}
std::cout << "}"<<std::endl;
}
template <>
void Palindrome<std::string>::Print() const
{
std::cout << "{";
for (auto iter = palindromeDataset.begin(); iter != palindromeDataset.end();)
{
std::cout << *iter;
if (++iter != palindromeDataset.end())
{
std::cout << ", ";
}
}
std::cout << "}"<<std::endl;
}
template <>
void Palindrome<std::vector<int>>::Print() const
{
std::cout << "{";
for (auto iter1 = palindromeDataset.begin(); iter1 != palindromeDataset.end();)
{
std::cout << "{";
for (auto iter2 = iter1->begin(); iter2 != iter1->end();)
{
std::cout << *iter2;
if (++iter2 != iter1->end())
{
std::cout << ", ";
}
}
std::cout << "}";
if (++iter1 != palindromeDataset.end())
{
std::cout << ", ";
}
}
std::cout << "}"<<std::endl;
}
template <>
bool Palindrome<int>::IsPalindrome(const int& s) const
{
int x = s;
long int rev = 0;
if (x<0)
{
return false;
}
while (x!=0)
{
rev= rev*10+(x%10);
x=x/10;
}
return s == rev;
}
template <>
bool Palindrome<std::string>::IsPalindrome(const std::string& s) const
{
const size_t len = s.size();
if (!len)
{
return true;
}
size_t l = 0;
size_t r = len - 1;
while (l < r)
{
if (s[l] != s[r])
{
return false;
}
++l;
--r;
}
return true;
}
template <>
bool Palindrome<std::vector<int>>::IsPalindrome(const std::vector<int>& s) const
{
const size_t len = s.size();
if (!len)
{
return true;
}
size_t l = 0;
size_t r = len - 1;
while (l < r)
{
if(s[l] != s[r])
{
return false;
}
++l;
--r;
}
return true;
}
Odpowiedzi
Po pierwsze: wygląda na to, że jest to aplikacja „The OO Antipattern” . Nie rozumiem, dlaczego class Palindromew ogóle potrzebujesz ; a jeśli musisz go zachować, z pewnością nie powinieneś przechowywać całego zbioru danych - po prostu przetwórz go raz w konstruktorze i zachowaj palindromy!
Podobnie Palindrome<T>::Print()wydaje się, że powinno być uogólnione na „wydrukować coś , cokolwiek to jest”; ta operacja nie ma nic wspólnego z palindromami i może zostać podzielona na własną funkcję użyteczności.
Więc zostajemy z tym:
template<class T>
std::vector<T> keep_only_palindromes(std::vector<T> dataset) {
std::erase_if(dataset, [](auto&& elt) {
return !is_palindromic(elt);
});
return dataset;
}
template<class T>
class PrintableVector {
const std::vector<T> *v_;
public:
explicit PrintableVector(const std::vector<T>& v) : v_(&v) {}
friend std::ostream& operator<<(std::ostream& os, const PrintableVector& me) {
os << "{ ";
for (auto&& elt : *me.v_) os << elt << ", ";
os << "}";
return os;
}
};
Następnie moglibyśmy przepisać twoje przypadki testowe jako:
int main() {
auto pal = keep_only_palindromes(
std::vector<int>{125125, 4947, 74347, 11}
);
std::cout << PrintableVector(pal) << "\n";
auto pal1 = keep_only_palindromes(
std::vector<std::string>{"yay", "world", "level", "hello"}
);
std::cout << PrintableVector(pal1) << "\n";
std::vector<std::vector<int>> pal2_data = {
{6, 2, 2, 6},
{1, 2, 2},
{1, 4, 6, 3, 5, 3, 6, 4, 1},
{5, 2, 2, 6, 9, 1, 2}
};
auto pal2 = keep_only_palindromes(pal2_data);
std::cout << PrintableVector(pal2) << "\n";
}
Nawiasem mówiąc, bardzo miło, że napisałeś przypadki testowe! Bardzo niewielu ludzi to robi. Twoje przypadki testowe są przydatne, ponieważ pokazują, w jaki sposób zamierzasz używać tej klasy - i pozwalają mi pokazać, jak zamierzam użyć mojego przepisanego tekstu!
Robię zawiadomienie, że nie przetestować przypadki narożne, takie jak 1, 0, -1, "", {42}, lub {}. To nie jest takie wspaniałe.
Twoja IsPalindromeiterowalna rzecz będzie dokładnie taka sama. Więc wolę napisać coś takiego
template<class T>
auto is_palindromic(const T& seq)
-> decltype(std::begin(seq), std::rbegin(seq), true)
{
return std::equal(
std::begin(seq), std::end(seq),
std::rbegin(seq), std::rend(seq)
);
}
Tam używam zwracanego typu SFINAE, aby powiedzieć, że ten szablon powinien być brany pod uwagę przy tworzeniu instancji tylko wtedy, gdy wyrażenie std::begin(seq), std::rbegin(seq), truejest poprawnie sformułowane. W C ++ 20 możesz lepiej przekazać intencję za pomocą czegoś takiego:
template<class T>
concept sequence = requires (const T& seq) {
seq.begin(); seq.rbegin();
};
template<class T> requires sequence<T> // !!
bool is_palindromic(const T& seq) {
return std::equal(
std::begin(seq), std::end(seq),
std::rbegin(seq), std::rend(seq)
);
}
W obu przypadkach nadal musiałbyś napisać inne przeciążenie
bool is_palindromic(int x)
ręcznie.
Wersja tego kodu z nieco mniejszą handwavingiem i bardziej tajemną składnią znajduje się pod adresem https://godbolt.org/z/aqPfGx - może być ciekawym do przyjrzenia się, nawet jeśli część tajemnej składni jest onieśmielająca (i, szczerze mówiąc, niepotrzebna - gdybym miał wydrukować wektor wektorów w C ++, „Nie zaczynałbym od tego”).
I. Budowa jest podzielona na kilka etapów. Innymi słowy, świeżo skonstruowany obiekt nie jest w stanie sfinalizowanym, gotowym do użycia i wymaga jeszcze jednego wyraźnego wywołania inicjującego. Jest to bardzo silny anty-wzór, który oczywiście może prowadzić do błędów.
Bardziej przyzwoitym rozwiązaniem byłoby przefiltrowanie zestawu danych bezpośrednio w konstruktorze i nie trzymanie dwóch wektorów naraz, podwajając w ten sposób potrzebną przestrzeń (zwłaszcza gdy jeden z wektorów jest potrzebny tylko jako argument do utworzenia drugiego i jest niemożliwy i niedostępne inaczej). (Jedną z wad tego projektu jest oczywiście to, że konstrukcja byłaby bardzo rygorystyczna, ale jest to w porządku, o ile zaniedbamy możliwość, że skonstruowany filtr palindromowy nigdy nie będzie faktycznie używany.)
II. Kod dla Printjest absolutnie identyczny między intami i łańcuchami, a dla wektorów różni się tylko drukowaniem części elementu.
III. Sam filtr palindromowy mógłby być być może bardziej użyteczny, gdyby został zaimplementowany po prostu jako funkcja operująca na zakresach, podobnych do tych zdefiniowanych w <algorithm>; lub przynajmniej jeśli zaimplementował idiomatyczny interfejs iterator/ begin/ end. std::remove_ifz IsPalindromepredykatem jako byłby dobry początek.
IV. A sam konstruktor (tak jak jest napisany) może być szablonem, przyjmując dowolny pakiet argumentów i przekazując go do datasetctora.