Hoe kom ik aan het type variabele?

Hoe vind je in C++ het type variabele?

Antwoord 1, autoriteit 100%

U kunt de typeid-operatorgebruiken:

#include <typeinfo>
...
cout << typeid(variable).name() << endl;

Antwoord 2, autoriteit 21%

Voor statische beweringen introduceerde C++11 decltypewat best handig is in bepaalde scenario’s.

Antwoord 3, autoriteit 7%

Als je een variabele hebt

int k;

Je kunt het type krijgen met

cout << typeid(k).name() << endl;

Zie de volgende thread op SO: Vergelijkbare vraag

Antwoord 4, autoriteit 6%

Het belangrijkste verschil tussen C++ en Javascript is dat C++ een statische taal is, terwijl javascript dynamisch is.

In dynamisch getypeerde talen kan een variabele elk ding bevatten, en het type wordt gegeven door de waarde die het bezit, van moment tot moment.
In statisch getypeerde talen wordt het type van een variabele gedeclareerd en kan het niet veranderen.

Er kunnen dynamische verzending en objectsamenstelling en subtypering (overerving en virtuele functies) zijn, evenals statische verzending en supertypering (via sjabloon CRTP), maar in ieder geval moet het type van de variabele bekend zijn bij de compiler.

Als je niet weet wat het is of zou kunnen zijn, komt dat omdat je iets hebt ontworpen omdat de taal een dynamisch typesysteem heeft.

Als dat het geval is, kun je je ontwerp maar beter heroverwegen, aangezien het een land ingaat dat niet natuurlijk is voor de taal die je gebruikt (het meest zoals op een snelweg gaan met een rups, of in het water met een auto )

Antwoord 5, autoriteit 4%

Meestal is het de verkeerde vraag om het type variabele in C++ te vinden. Het is meestal iets dat je meeneemt uit proceduretalen zoals bijvoorbeeld C of Pascal.

Als je verschillende gedragingen wilt coderen, afhankelijk van het type, probeer dan meer te weten te komen over b.v. overbelasting van functiesen objectovererving. Dit is niet meteen logisch op je eerste dag met C++, maar blijf doorgaan.

Antwoord 6, autoriteit 3%

Ik geloof dat ik een geldig gebruiksscenario heb voor het gebruik van typeid(), op dezelfde manier als het geldig is om sizeof() te gebruiken. Voor een sjabloonfunctie moet ik de code speciaal maken op basis van de sjabloonvariabele, zodat ik maximale functionaliteit en flexibiliteit bied.

Het is veel compacter en beter te onderhouden dan het gebruik van polymorfisme, om één instantie van de functie te maken voor elk ondersteund type. Zelfs in dat geval zou ik deze truc kunnen gebruiken om de hoofdtekst van de functie maar één keer te schrijven:

Houd er rekening mee dat, omdat de code sjablonen gebruikt, de onderstaande switch-instructie statisch in slechts één codeblok zou moeten worden opgelost, waardoor alle valse gevallen worden geoptimaliseerd, AFAIK.

Beschouw dit voorbeeld, waar we mogelijk een conversie moeten afhandelen als T het ene type is versus het andere. Ik gebruik het voor klassespecialisatie om toegang te krijgen tot hardware waarbij de hardware ofwel het myClassA- of myClassB-type zal gebruiken. Bij een mismatch moet ik tijd besteden aan het converteren van de gegevens.

switch ((typeid(T)) {
  case typeid(myClassA):
    // handle that case
    break;
  case typeid(myClassB):
    // handle that case
    break;
  case typeid(uint32_t):
    // handle that case
    break;
  default:
    // handle that case
}

Antwoord 7, autoriteit 2%

Ik weet niet zeker of mijn antwoord zou helpen.

Het korte antwoord is dat je niet echt het type variabele nodig hebt/wil weten om het te gebruiken.

Als u een type aan een statische variabele moet geven, kunt u gewoon auto gebruiken.

In meer gesofisticeerde gevallen waarin je “auto” in een klasse of struct wilt gebruiken, raad ik aan om een sjabloon met decltype te gebruiken.

Stel bijvoorbeeld dat u de bibliotheek van iemand anders gebruikt en deze een variabele heeft met de naam “unknown_var” en dat u deze in een vector of struct wilt plaatsen, dan kunt u dit volledig doen:

template <typename T>
struct my_struct {
    int some_field;
    T my_data;
};
vector<decltype(unknown_var)> complex_vector;
vector<my_struct<decltype(unknown_var)> > simple_vector

Hopelijk helpt dit.

EDIT: Voor de goede orde, hier is het meest complexe geval dat ik kan bedenken: een globale variabele van een onbekend type. In dit geval heb je c++14 en template variabele nodig.

Zoiets:

template<typename T> vector<T> global_var;
void random_func (auto unknown_var) {
    global_var<decltype(unknown_var)>.push_back(unknown_var);
}

Het is nog steeds een beetje vervelend, maar het komt zo dicht mogelijk bij typeloze talen. Zorg ervoor dat wanneer u naar een sjabloonvariabele verwijst, altijd de sjabloonspecificatie daar plaatst.

Antwoord 8

#include <typeinfo>
...
string s = typeid(YourClass).name()

Antwoord 9

Als u een vergelijking moet maken tussen een klasse en een bekend type, bijvoorbeeld:

class Example{};
...
Example eg = Example();

U kunt deze vergelijkingsregel gebruiken:

bool isType = string( typeid(eg).name() ).find("Example") != string::npos;

die controleert of de typeid-naam het stringtype bevat (de typeid-naam heeft andere verminkte gegevens, dus het is het beste om een s1.find(s2)te doen in plaats van ==).

Antwoord 10

Je kunt zeker gaan voor typeid(x).name()waarbij x de naam van de variabele is. Het retourneert eigenlijk een const char-aanwijzer naar het gegevenstype. Bekijk nu de volgende code.

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n = 36;
    char c = 'A';
    double d = 1.2;
    if(*(typeid(n).name()) == 'i'){
        cout << "I am an Integer variable" << endl;
    }
    if(*((char *) typeid(d).name()) == 'd'){
        cout << "I am a Double variable" << endl;
    }
    if(*((char *) typeid(c).name()) == 'c'){
        cout << "I am a Char variable" << endl;
    }
    return 0;
}

Let op hoe de eerste en de tweede beide werken.