Как найти тип переменной

Other answers offer good help with this question, but there is an important and subtle issue that none of them addresses directly. There are two ways of considering type in C#: static type and run-time type.

Static type is the type of a variable in your source code. It is therefore a compile-time concept. This is the type that you see in a tooltip when you hover over a variable or property in your development environment.

Run-time type is the type of an object in memory. It is therefore a run-time concept. This is the type returned by the GetType() method.

An object’s run-time type is frequently different from the static type of the variable, property, or method that holds or returns it. For example, you can have code like this:

object o = "Some string";

The static type of the variable is object, but at run time, the type of the variable’s referent is string. Therefore, the next line will print «System.String» to the console:

Console.WriteLine(o.GetType()); // prints System.String

But, if you hover over the variable o in your development environment, you’ll see the type System.Object (or the equivalent object keyword).

For value-type variables, such as int, double, System.Guid, you know that the run-time type will always be the same as the static type, because value types cannot serve as the base class for another type; the value type is guaranteed to be the most-derived type in its inheritance chain. This is also true for sealed reference types: if the static type is a sealed reference type, the run-time value must either be an instance of that type or null.

Conversely, if the static type of the variable is an abstract type, then it is guaranteed that the static type and the runtime type will be different.

To illustrate that in code:

// int is a value type
int i = 0;
// Prints True for any value of i
Console.WriteLine(i.GetType() == typeof(int));

// string is a sealed reference type
string s = "Foo";
// Prints True for any value of s
Console.WriteLine(s == null || s.GetType() == typeof(string));

// object is an unsealed reference type
object o = new FileInfo("C:\f.txt");
// Prints False, but could be true for some values of o
Console.WriteLine(o == null || o.GetType() == typeof(object));

// FileSystemInfo is an abstract type
FileSystemInfo fsi = new DirectoryInfo("C:\");
// Prints False for all non-null values of fsi
Console.WriteLine(fsi == null || fsi.GetType() == typeof(FileSystemInfo));

Another user edited this answer to incorporate a function that appears below in the comments, a generic helper method to use type inference to get a reference to a variable’s static type at run time, thanks to typeof:

Type GetStaticType<T>(T x) => typeof(T);

You can use this function in the example above:

Console.WriteLine(GetStaticType(o)); // prints System.Object

But this function is of limited utility unless you want to protect yourself against refactoring. When you are writing the call to GetStaticType, you already know that o’s static type is object. You might as well write

Console.WriteLine(typeof(object)); // also prints System.Object!

This reminds me of some code I encountered when I started my current job, something like

SomeMethod("".GetType().Name);

instead of

SomeMethod("String");

I’m not sure if my answer would help.

The short answer is, you don’t really need/want to know the type of a variable to use it.

If you need to give a type to a static variable, then you may simply use auto.

In more sophisticated case where you want to use «auto» in a class or struct, I would suggest use template with decltype.

For example, say you are using someone else’s library and it has a variable called «unknown_var» and you would want to put it in a vector or struct, you can totally do this:

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

Hope this helps.

EDIT: For good measure, here is the most complex case that I can think of: having a global variable of unknown type. In this case you would need c++14 and template variable.

Something like this:

template<typename T> vector<T> global_var;

void random_func (auto unknown_var) {
    global_var<decltype(unknown_var)>.push_back(unknown_var);
}

It’s still a bit tedious but it’s as close as you can get to typeless languages. Just make sure whenever you reference template variable, always put the template specification there.

Введение

Для определения типа переменной в C++ существует функция

typeid().name()

из библиотеки

typeinfo

которую нужно предварительно подключить с помощью

#include <typeinfo>

typeid().name()

Небольшая демонстрация

#include <string>
#include <iostream>
#include <typeinfo>

int main()
{
// Создадим четыре переменные разных типов

int int_var = 1;
float float_var = 1.0;
char char_var = '0';
std::string str1 = "www.heihei.ru";

// Выведем на экран результат работы typeid
std::cout << typeid(int_var).name() << std::endl;
std::cout << typeid(float_var).name() << std::endl;
std::cout << typeid(char_var).name() << std::endl;
std::cout << typeid(str1).name() << std::endl;


return 0;
}

Результат

int
float
char
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >

C:Usersaosourcerepostypeidx64Debugtypeid.exe (process 132920) exited with code 0.
Press any key to close this window . . .

Все четыре типа определены.

В других языках

• Си

  : такой функции нет.

• C#

  :
  есть похожая функция

  GetType()

• Go

  :
  функция

  typeof

  доступна из библиотеки reflect

  Читать статью: «Как определить тип переменной Go»

• Java

  :
  оператор

  instanceof

• JavaScript

  :
  эту задачу решает

  typeof()

  Читать статью: «Как определить тип переменной JavaScript»

• PHP

  :
  эту задачу решает

  gettype()

  Читать статью: «Как определить тип переменной PHP»

• Python

  :
  аналогичная функция

  type()

  и немного другая функция

  isinstance()

  с помощью которой можно решить эту же задачу.

  Читать статью: «Как определить тип переменной Python»