Wie kann man typeid nutzen?

Hallo,

sehr interessant. Danke.

Wikipedia hat sicherlich auch erheblichen Einfluss....

struct Factorial
Stammt aus diesem interessanten Artikel.

Die rekursive Funktion stammt aus einer meiner Experimentserien.

Hallo,

sehr interessant. Danke.

Du weißt schon, dass du jetzt die Büchse der Pandora geöffnet hast, oder gerade dabei bist.....?
:smiling_imp: :smiling_imp: :smiling_imp: :smiling_imp:

combie:
Du weißt schon, dass du jetzt die Büchse der Pandora geöffnet hast, oder gerade dabei bist.....?
:smiling_imp: :smiling_imp: :smiling_imp: :smiling_imp:

Ich denke auch, weiß noch nicht wie ich aus der Nummer wieder rauskomme. Weil eigentlich bin ich noch nicht so weit. Je mehr Quellen man kennt umso mehr Informationen stürzen auf Einen ein. :slight_smile:

Hallo,

nach einer Pause und erneuter Betrachtung stellt sich mir eine Frage. Die beiden Funktionen is_same dienen ja nur dazu um zu wissen welche Variante der Compiler verwendet um dann festzustellen ob Datentypen gleich oder unterschiedlich sind. Wofür dient dann das enum und constexpr operator bool? Kann man da nicht nur return false oder true schreiben? Dann wäre es leichter lesbar. Oder muss das so sein wegen der Optimierung zusammen?

statt

template<typename T, typename U>
struct is_same
{
  enum { value = 0 };

  constexpr operator bool() {
    return false;
  }
};


template<typename T>
struct is_same <T, T>
{
  enum { value = 1 };

  constexpr operator bool() {
    return true;
  }
};

dann

template<typename T, typename U>
struct is_same
{
    return false;
};


template<typename T>
struct is_same <T, T>
{
    return true;
};

Seit wann haben Klassen Rückgabewerte? Mit operator bool überlädst du den bool Operator, wodurch man Objekte wie Methoden verwenden kann

Dann wäre es leichter lesbar.

Mittlerweile habe ich die Geschichte etwas weiter entwickelt.
Vielleicht ist diese Variante ja leichter lesbar.
Da findet sich ein is_same ohne enum, es geht also ohne.

template<bool b> 
struct bool_type
{
  constexpr operator bool()
  {
    return b;
  }
};

struct true_type   :bool_type<true> {};
struct false_type  :bool_type<false>{};

template<typename T> struct is_floating_point         :false_type{};
template<>           struct is_floating_point<float>  :true_type {};
template<>           struct is_floating_point<double> :true_type {};

template<typename T> struct is_signed             :false_type{};
template<>           struct is_signed<int8_t >    :true_type {};
template<>           struct is_signed<int16_t>    :true_type {};
template<>           struct is_signed<int32_t>    :true_type {};
template<>           struct is_signed<int64_t>    :true_type {};

template<typename T> struct is_unsigned           :false_type{};
template<>           struct is_unsigned<uint8_t > :true_type {};
template<>           struct is_unsigned<uint16_t> :true_type {};
template<>           struct is_unsigned<uint32_t> :true_type {};
template<>           struct is_unsigned<uint64_t> :true_type {};

template<typename T> struct is_integral   :bool_type<is_unsigned<T>()||is_signed<T>()>{};
template<typename T> struct is_arithmetic :bool_type<is_integral<T>()||is_floating_point<T>()> {};

template<typename T, typename U> struct is_same      :false_type{};
template<typename T>             struct is_same<T,T> :true_type {};

template<typename T> struct is_void    :bool_type<(is_same<T,void>())> {};
template<typename T> struct is_nullptr :bool_type<(is_same<nullptr_t,T>())> {};

template<typename T> struct is_const          :false_type{};
template<typename T> struct is_const<const T> :true_type {};

template< typename T> struct is_pointer     : false_type{};
template< typename T> struct is_pointer<T*> : true_type {};


template<typename T>           struct is_array       :false_type{};
template<typename T>           struct is_array<T[]>  :true_type {};
template<typename T, size_t N> struct is_array<T[N]> :true_type {};

Hallo,

nicht böse sein. Ich habe das wegen template, struct und constexpr ... nicht mehr überblickt das es ein Objekt ist und kein Datentyp als Rückgabewert voran steht. Wenn ich template Konstrukte nicht selbst schreibe habe ich immer Probleme beim lesen. Die Pause mit dem Thema tat ihr übrigens.

Ich guck mir das an, nehme auch combies Ausarbeitung gern mit und werde schauen was ich damit wie machen kann. Erstmal muss ich zwischen Integer und Float unterscheiden. Langsam wirds ernst für mein Vorhaben. Bis jetzt war es Vorgeplänkel. :slight_smile:

Danke Euch.

Hallo,

ich habs geschnallt. :grin: Das sind Bausteine mit denen man sich noch seine eigenen Funktionen bauen muss. Erste Versuche waren erfolgreich. Meine Leitung ist manchmal auch länger als sie sein dürfte. :wink: Danke nochmal.

Hallo,

ich habe das heute nochmal durchprobiert. Was ich nicht hinbekomme ist die Abfrage auf ein Array und einer Konstante. Frage ich ein Array auf Zeiger ab klappt das, zerfällt ja zu einem Zeiger. Habe char und byte Arrays probiert. Klappt nicht. Übersehe ich irgendwas? Ist ein bestimmter Syntax erforderlich?

Eingebunden wird dein Baustein Code als Header.

#include "DataTypesDetection.h"

template<typename T>
bool isArray(T)
{
  return (is_array<T>() );
}

template<typename T>
bool isConst(T)
{
  return (is_const<T>() );
}

void setup(void) {
  Serial.begin(9600);

  //char text[] = "Hallo";
  byte zahlen[4] = {0,1,2,3};
  
  if ( isArray(zahlen[4]) )
    Serial.println("Ist ein Array");
  else
    Serial.println("Ist kein Array");   

  const int k = 1;
  
  if ( isConst(k) )
    Serial.println("Ist eine Konstante");
  else
    Serial.println("Ist keine Konstante");  
      
}

void loop(void) {
  
}

T ist nicht das Gleiche wie const T

 if ( isArray(zahlen[4]) )

Da übergibst du ja auch kein Array

Hallo,

wir teilen das mal auf. Zuerst Thema Konstantenerkennung.

Wenn ich const T schreibe wird eine Konstante erkannt obwohl es keine ist, also immer.

#include "DataTypesDetection.h"

template<typename T>
bool isConst(T)
{
  return (is_const<const T>() );
}

void setup(void) {
  Serial.begin(9600);

  int k = 1;
  
  if ( isConst(k) )
    Serial.println("Ist eine Konstante");
  else
    Serial.println("Ist keine Konstante");  
      
}

void loop(void) {
  
}

und mit

template<typename T>
bool isConst(const T)
{
  return (is_const<T>() );
}

wird immer keine Konstante erkannt, mit const int k = 1
Ich weiß noch nicht was ich falsch mache.

Ich weiß noch nicht was ich falsch mache.

Aber ich.

Du übergibst deiner Funktion den Parameter per Value.
Also werden Kopien angelegt.
Und die sind eben nicht const.

Wenn du Referenzen übergibst, bleibt die const Qualifizierung erhalten.

Also so:

template<typename T>
bool isConst(T &)
{
  return (is_const<T>() );
}

Hallo,

oh man, da hätte ich lange doktern können, wäre ich jetzt nicht draufgekommen.
Das löst auch mein Problem mit der Arrayerkennung. :wink:
Vielen Dank.

Dabei ist das doch so schön dokumentiert :sunglasses: :sunglasses: :sunglasses: :sunglasses:

If P is a reference type, it is replaced by the type referred to
..
If P is cv-qualified, P is replaced with cv-unqualified version of itself

(mit cv ist const und volatile gemeint)
Siehe: cppreference.com Function template

Hallo,

das wäre zu einfach gewesen. Ich unterscheide zwischen 3 Dingen. Wissen wo es steht, lesen und verstehen. Wobei verstehen noch nicht bedeutet das man es sofort anwenden kann. Sind eigentlich 4 unterschiedliche Dinge. Lasse es uns darüber bitte nicht diskutieren - nur wundern. :wink:

Eins darf ich bestimmt noch fragen. Gehört dieses template struct schon zu der berüchtigt magischen Metaprogrammierung? Was in C++20 mit Concepts weiter verfeinert wird?

magischen Metaprogrammierung?

Lesenswert: Wikipedia C++-Metaprogrammierung

Magisch?
Ist nur solange magisch, bis man die Technik dahinter verstanden hat.
:smiling_imp: :smiling_imp:

Hallo,

noch ein Link zum lesen. Ihr wisst gar nicht wieviele Links ich in den letzten Jahren gesammelt habe. Die meisten sind schon wieder tot. Lesen werde ich das natürlich bzw. habe es schon gelesen. Danke.

Magisch bzw. erstaunlich. Ja das wird immer so sein egal welches Thema. Wenn man weiß wie ist es plötzlich ganz einfach. :slight_smile: