Data Analysis and Visualization in High Energy Physics

ROOT 6 is written in standard C++ 11. To successfully use this version of ROOT you should familiarize yourself with the differences C+ 11 from previous versions of C++. Here is a list of the most significant of them:

Changes affecting the basis of the language:

• New reserved keywords defined: alignas, alignof, array, char16_t, char32_t, constexpr, decltype, index, noexcept, nullptr, static_assert, thread_local. Below each of these words is considered separately.
• Added new data types: long long int, char16_t, char32_t.
• Introduced the concept of rvalue links (defined with & amp; & amp;) to distinguish a link to lvalue (an object that has a name) and a link to rvalue (an object that does not have a name). References to temporary values ​​( The rvalues ​​ values ​​on the right side of the assignment) allow you to change such values ​​after they are initialized. The class /structure used to have some implicit member functions: the default constructor (if another constructor is not defined), copy constructor and destructor. The copy constructor performs bitwise copying of variables. This means that if there is a class with pointers to some objects, then the copy constructor copies the pointers, not the objects they point to. If it is necessary to get the objects in the copy, and not just the pointers to them, then it is necessary describe in the copy constructor. In C ++ 11 the transfer constructor (move) and the operator are added assignment move. These two special functions take the T & & , which is rvalue . In fact, they can modify the object.
• Added generic constant expressions based on the use of the keyword constexpr . With this qualifier, you can create variables, functions, and even objects that will be calculated at compile time. Previously, for such purposes it was necessary to use templates. The constexpr keyword before the function indicates that the function always returns a constant value, and allows you to use such a function in the same context as a constant.
• The definition of the type of simple data (plain old data or POD) has changed. Simple data structure It has a rigidly defined arrangement of fields in memory that does not require access restriction and automatic control. Variables of this type can be copied with simple procedures. copy plots of memory. In C ++ 11, it is split into two: a trivial type (allowing static initialization and use of memcpy) and the type of standard placement (the order of its members is compatible with order C). This allows you to more accurately set the boundaries of compatibility type C.
• Introduced the concept of an external template - a way to prevent the compiler from instantiating (create an instance class) pattern.
• Expanded options for using initialization lists. Concept of initialization lists came in C ++ from C. A structure or array can be created by passing the list of arguments in order, corresponding to the order of definition of members of the structure. Initialization lists are recursive, which allows use them for arrays of structures and structures containing nested structures.

  struct Object
  {
      float first;
      int second;
  };
  
  Object scalar = {0.43f, 10}; // один объект, с first=0.43f и second=10
  Object anArray[] = {{13.4f, 3}, {43.28f, 29}, {5.934f, 17}}; // массив из трёх объектов
  

  Initialization lists are very useful for static lists and when required. initialize the structure with a specific value. C ++ also contains constructors that can contain a general part of the work on the initialization of objects. C ++ Standard allows lists to be used initialization for structures and classes, provided that they meet the definition of a simple type Data (Plain Old Data POD). Classes that are not PODs cannot be used for initialization. initialization lists, including the standard C ++ containers, such as vectors. C ++ 11 linked the concept of initialization lists to a template class named std :: initializer_list. This allowed constructors and other functions to get initialization lists as parameters. For example:

  class SequenceClass
  {
  public:
    SequenceClass (std::initializer_list  list);
  };
  

  This description allows you to create a SequenceClass from a sequence of integers as follows:

  SequenceClass someVar = {1, 4, 5, 6};
  

  The std :: initializer_list <> class is defined in the standard C ++ 11 library. However, the objects of this classes can be created by the C ++ 11 compiler only statically using syntax with brackets {}. The list can be copied after creation, however, it will be copying by reference. The initialization list is constant: neither its members nor their data can be changed after creation. .
• C++11 provides a syntax that allows you to use a single form of initialization for all types objects using the initialization list syntax extension:

  struct BasicStruct {
      int x;
      double y;
  };
  
  struct AltStruct {
      AltStruct(int x, double y) : x_(x), y_(y) {}
  
  private:
      int x_;
      double y_;
  };
  
  BasicStruct var1{5, 3.2};
  AltStruct var2{2, 4.3};
  

  Universal initialization does not completely replace the initialization syntax using the constructor. If the class has a constructor that takes an initialization list as an argument (TypeName (initializer_list );), it will have a higher priority than other features to create objects. For example, in C ++ 11, std :: vector contains a constructor, taking an initialization list as an argument:

  std :: vector  theVec {4};
  

  This code will cause the constructor to be called, taking as an argument the initialization list, rather than a constructor with a single parameter, creating a container of a given size. To call this constructor, you must use the standard syntax for calling a constructor.
• Added type inference: variables that are initialized when declaring can be declared as auto, and the decltype keyword allows you to determine the type of a variable at compile time. Prior to C ++ 11, the auto keyword was used as a variable storage specifier (such as register, static, extern). In C ++ 11, auto allows you not to specify the type of a variable explicitly, telling the compiler, so that he himself determines the actual type of the variable, based on the type of value being initialized. It may used when declaring variables in different scopes, such as namespaces, blocks, initialization in a loop, etc. auto i = 42; // i - int auto l = 42LL; // l - long long auto p = new foo(); // p - foo*
• The foreach loop syntax has been added to iterate over the elements of a collection. In the new form, it is possible to perform iterations if the iteration object is overloaded begin () and end () methods. This is useful when you just need to get items. array / container or do something with them without worrying about indexes, iterators, or quantity of elements.
• Added support for anonymous lambda functions.
• Added new syntax for declaring function templates, indicating the type of return value after listing the function arguments.
• Introduced "smart pointers" with reference counting and automatic freeing of memory: unique_ptr: should be used when the memory resource should not have been shared (it does not have copy constructor), but it can be passed to another unique_ptr shared_ptr: should be used when the memory resource is to be shared weak_ptr: contains a link to an object that is managed by shared_ptr, but does not implement reference counting; allows you to get rid of the cyclical dependence
• Class constructors can call other constructors of the same class as in Java, C #, and D. The object is considered to be created as soon as at least one constructor has completed.
• Two new identifiers have been added: override , to indicate that the method is redefining the virtual method in the base class and final , indicating that the derived class should not override the virtual method.
• A new nullptr keyword has been entered that defines a null pointer. Previously, a null macro was used to reset pointers; it is a zero integer type, which, of course, caused problems (for example, when overloading functions). Keyword nullptr has its own type std :: nullptr_t, which eliminates these problems. There are implicit conversions. nullptr to a null pointer of any type and to bool (as false), but conversion there is no integer type.
• The “traditional” enums in C ++ have some flaws: they export their values ​​to surrounding scope (which can lead to name conflicts), they are implicitly converted to integer type and cannot have a user-defined type. These problems are fixed in C ++ 11 with the introduction of a new category of enumerations called strongly typed enums. They are defined by the enum class keyword. They no longer export their enumerated values ​​in the surrounding scope are no longer implicitly converted to the whole type and may have a user-defined type (this option is also added for “traditional” enumerations).

  enum class Options {None, One, All};
  Options o = Options :: All;
  

• Changing the specification of a parser so that >> is interpreted as a pair of closing brackets, and not as right shift operator.
• The explicit keyword also applies to type conversion operators (to avoid implicit transformations).
• synonyms for templates.
• removed some restrictions on what types of objects can belong to a union.
• templates with a variable number of parameters are allowed.
• Support for three new types of string constants: UTF-8 (u8 "..."), UTF-16 (u "...") and UTF-32 (U "..."). custom constants (the ability to treat a record as a constant of some type depending on its suffix).
• multi-threaded memory model.
• storing data local to the stream.
• Added static_assert, which checks the assertion at compile time. If the statement is true, then nothing happens. If false, the compiler outputs the specified error message.
• sizeof can work with class members without objects of this class.
• Added ability to control the placement of variables.
• removed some scripts that made the implementation of automatic garbage collection impossible.
• D The begin () and end () functions are entered. This is a new addition to the standard library. They work with all STL containers and can be extended to work with any type.

Changes to the STL library:

• multithreading support (classes of threads, mutexes, condition variables, locks, etc.).
• Added tuple (std :: tuple) - non-uniform list of elements. The tuple is "similar" to a couple (std :: pair), however, it may contain an arbitrary (albeit finite) number of elements. You can create a tuple like this:

  #include 
  std :: tuple  tuple _ ("hello", 42, 3.14);
  

  A tuple can be called a collection of heterogeneous (disparate) values. Therefore, the element type (value_type), which is defined in any standard container, does not make sense in a tuple, and is simply missing, exactly like any of the iterator types. The tuple is not a regular container class, and does not respond container concepts in C ++. Therefore, there is no simple way to bypass the elements of a tuple. No cycles are applicable to it:

  for (auto& x : tuple_);  // Compilation error!
  
  error: no viable 'begin' function available
  

  "Walk" through the elements of a tuple can only know the exact number of arguments at the compilation stage. To do this, use the get function:

  std :: get <0> (tuple_); // element index as a template argument
  std :: get <1> (tuple_);
  std :: get <2> (tuple_);
  

  In this case, the transfer of the index during the execution of the program is impossible:

  int i = 0;
  std :: get < i > (tuple_); // Error compiling!
  

  However, by using template metaprogramming, you can create a more convenient way to bypass the tuple at compile time.
• collections of heterogeneous objects of given dimensions.
• hash tables (unordered associative containers) unordered_set, unordered_multiset, unordered_map and unordered_multimap.
• regular expression library &< regex &>.
• general purpose smart pointers: added unique_ptr and improved shared_ptr and weak_ptr, auto_ptr excluded as obsolete.
• extended random number generation