Czy nawet na potrzeby pojedynczych, prostych projektów powinno się pisać jak najlepszy kod?

Question

Cze.

Piszę parę prostych zadań dla jednej osoby. W jednym z nich pojawiło się szukanie max wartości dla tablicy int.

Funkcja napisana, ale tylko dla int*. Pytanie brzmi, czy nawet dla takich prostych programów pisać kod najbardziej "rozciągliwy" (w tym przypadku użyć template'ów), czy jednak tutaj można sobie pozwolić na takie statyczne cuś?

 

Z góry dziękuję za odpowiedzi.

 

Pozdrawiam.

Answer 1

Rozumiem, że chodzi ci o hardkodowanie rozmiarów tablic itp vs działanie na dynamicznych strukturach.
Specjalistą nie jestem, ale imo zależy to od tego co ma dany program robić i na ile jest potrzebne bawienie się ze wskaźnikami i dynamicznymi strukturami. Osobiście, dla małych, przewidywalnych w inpucie zadań, robiłbym hardcode, jeśli input byłby dynamiczny, analogicznie zrobiłbym to dynamicznie

Comments

Czyli jako nauczyciel uznałbyś coś takiego?

---

Do nauczyciela mi daleko, ale o ile specyfika zadania nie wymaga 'dynamiki' to po co dokładać sobie pracy? (w większości przypadków używanie wskaźników jest utrudnianiem sobie pracy, ale też nie zawsze)

---

Racja, dzięki wielkie.

Answer 2

Nie jestem ekspertem, ale odpowiedzią na Twoje pytanie mogą być słowa śp. prof. Władysława Bartoszewskiego:

"Pewne rzeczy w życiu warto, a pewne rzeczy w życiu się opłaca."

Answer 3

W 1974 roku (drugie wydanie 1978), Brian Kernighan i P. J. Plauger popełnili książkę: The Elements of Programming Style.

Pierwsze zalecenie z niej to: Wyrażaj się jasno i nie bądź zbyt sprytny. Tu są wszystkie zalecenia: https://en.wikipedia.org/wiki/The_Elements_of_Programming_Style

Od tamtego czasu nic się nie zmieniło. To klasyk i warto go w wolnej chwili przeczytać choć przykłady są w językach programowania  "antycznych".

Answer 4

To zależy.

Jaki jest główny cel tego kodu? To coś pożytecznego czy tylko nauka?

Jeśli chce się podszkolić w języku to często świadomie wybieram cięższą drogę. Próbuje napisać trudniejszą wersje (zaimplementować coś od zera, bardziej generycznie)

Ale jeśli programuję dla wyniku to idę na łatwiznę. Wykorzystuje biblioteki i maksymalnie upraszczam problem.

Np dla Twojego problemu wyznaczenia maksymalnej wartości w tablicy intów:

Wersja maksymalnie użyteczna:

int m = *max_element(std::begin(tab), std::end(tab));

Wersja mocno rozwijająca (sporo copy pasty, można by pewnie jakieś makra do tego popisać :P)

template <typename T, typename V = void>
struct is_n_eq_comparable : std::false_type {};

template <typename T>
struct is_n_eq_comparable<T, void_t<
	decltype(declval<T>() != declval<T>())>> : std::true_type{};

template <typename T, typename V = void>
struct is_incrementable : std::false_type {};

template <typename T>
struct is_incrementable<T, void_t<
	decltype(++declval<T&>())>> : std::true_type {};

template <typename T, typename V = void>
struct is_dereferencable : std::false_type {};

template <typename T>
struct is_dereferencable<T, void_t<
	decltype(*declval<T>())>> : std::true_type {};

template <typename T, typename V = void>
struct is_dereference_less_comparable : std::false_type {};

template <typename T>
struct is_dereference_less_comparable<T, void_t<
	decltype(*declval<T>() < *declval<T>())>> : std::true_type {};


template <typename T, typename std::enable_if<
	is_n_eq_comparable<T>{} &&
	is_incrementable<T>{} &&
	is_dereferencable<T>{} &&
	is_dereference_less_comparable<T>{}
, int>::type = 0>
T max_val(T start, T end) {
	T current_max = start;
	for (; start != end; ++start) {
		if (*current_max < *start)
			current_max = start;
	}
	return current_max;
}

 

Comments

Co to jest? XD

Na mój poziom to jest trochę... Zbyt zaawansowane :D

---

Zwykłe rozwiązanie na template'ach ma jeden minus. Możesz wygenerować funkcje, która nie ma sensu i wywali się dopiero w trakcie działania programu:

template <typename T>
T bad_max(T start, T end) {
	T current_max = start;
	for (; start != end; ++start) {
		if (*current_max < *start)
			current_max = start;
	}
	return current_max;
}
bad_max(100,69); //skompiluje sie, ale wywali w runtime

Za to mój szablon dzięki metaprogramowaniu i SFINAE nie wygeneruje funkcji, która nie ma sensu, czyli:

max_val(100,69);

się po prostu nie skompiluje, bo typu int nie da się zdereferencjować

---

Tutaj jest fajny tutorial jak to działa:

https://www.fluentcpp.com/2017/06/02/write-template-metaprogramming-expressively/

---

Dzięki!