Dimensional Data

RAD Studio is the ultimate IDE with features both C++ and Delphi developers love to design, code, debug and test for cross-platform platform with native performance. Supported Platforms: Windows, iOS, macOS, Linux, and Android (some platforms Delphi only) Major Delphi Code Insight Redesign: The largest and best improvement to Delphi’s code tooling in many years, RAD Studio 10.4 provides Code Insight using a Delphi implementation of the Language Server Protocol (LSP). LSP is a technique for calculating results for code completion, navigation, or similar in a separate process. This means that the IDE will never block while completing and Code Insight will provide accurate results. You can also use code completion while debugging. 10.4 provides a much enhanced developer productivity experience when working with large projects with millions of lines of code. Accurate Error Insight results (red squiggles) and errors shown in the structure view. Delphi – Custom Managed Records: A key language addition to the Delphi language, the Delphi record type now supports custom initialization, finalization, and copy operations. Developers now have the ability to customize how records get created, copied, and destroyed, by writing the code to be executed at the various steps. This adds additional power to records in Delphi, a construct used to achieve better efficiency compared to classes. Unified Memory Management for Delphi and C++: Delphi memory management is now unified across all supported platforms – mobile, desktop, and server – using the classic implementation of object memory management. Compared to Automatic Reference Counting (ARC), this offers better compatibility with existing code and simpler coding for components, libraries, and end-user applications. The ARC model remains for string management and interface type references for all platforms. For C++, this change means that the creation and deletion of Delphi-style classes in C++ follow normal memory management just like any heap-allocated C++ class, significantly reducing complexity. New C++ Builder Features: Expanded C++ libraries support : Ported numerous popular C++ libraries to C++Builder, providing optimized support for use within C++Builder. This includes libraries such as ZeroMQ, SDL2, SOCI, libSIMDpp, and Nematode, as well as others already supported such as Eigen, available for download through the GetIt Package Manager. Win 64-Debugging and Linker for C++ : A new debugger for Windows 64-bit for C++. Based on LLDB, this debugger introduces significant stability improvements when debugging 64-bit applications, as well as a key new feature assisting evaluating and inspecting types like C++ and Delphi strings plus STL collections. Toolchain performance and quality improvements: A large number of STL improvements from Dinkumware, Several key RTL methods, Several improvements to CMake support. VCL Styles for High DPI: The VCL Styles architecture has been extended to support High DPI and 4K monitors. All UI controls on the VCL form are now automatically scaled for the proper resolution of the monitor the form is displayed on. The style API has been fully revised to support high DPI styles. Updated a large number of our built-in and premium VCL styles to provide support for the new High-DPI style mode, letting you design visually stunning applications for any monitor. VCL Per Control Styling -VCL developers can now use multiple VCL styles in different forms within a single application or even different visual controls that are on the same form. This also enables you to use third-party unstyled […]

C++ Builder supports the Variadic templates. Variadic templates are template that take a variable number of arguments. Both the classes and functions can be variadic offered by C++11. Templates have been a powerful feature in C++. Now, after the introduction of variadic templates, templates have proven themselves even more powerful. Variadic templates are a trustworthy solution to implement delegates and tuples. Here’s a variadic class template: template class VariadicTemplate {}; templatetypename… Arguments> class VariadicTemplate {}; Any of the following ways to create an instance of this class template is valid: VariadicTemplate instance; VariadicTemplate instance; VariadicTemplate, std::string, std::string, std::vector> instance; VariadicTemplatedouble, float> instance; VariadicTemplatebool, unsigned short int, long> instance; VariadicTemplatechar, std::vectorint>, std::string, std::string, std::vectorlong long>> instance; Here’s a function template: template void SampleFunction(Arguments… parameters) {}; template void SampleFunction(Arguments… parameters) {}; The contents of the variadic template arguments are called parameter packs. These packs will then be unpacked inside the function parameters. For example, if you create a function call to the above variadic function template, SampleFunction(16, 24); SampleFunctionint, int>(16, 24); an equivalent function template would be like this: template void SampleFunction(T param1, U param2){}; templatetypename T, typename U> void SampleFunction(T param1, U param2){}; Head over and find out more about C++ variadic templates in the Embarcadero DocWiki!

In this session, you can see and listen to a conversation with C++ designer, Bjarne Stroustrup.  Overview ISO/IEC 14882-2011 aka C++11, formerly “C++0x” How C++ 11 builds on C++’s strengths How C++ 11 makes C++ easier to Application portability C++’s ubiquitous presence in the markets About Bjarne Stroustrup Designer and original implementor of C++ Distinguished Professor and holder of the College of Engineering Chair in Computer Science, Texas A&M Member, the C++ standards committee When is the right time to start a language standard? What’s like to work on the C++ standard with others from the industry and academia? Bjarne Stroustrup has shown his views on C++. And how the C++ designed, what things were the influence for the creation of the C++ language. What are some of the key areas that help make C++ easier to use? Is inheritance overused? Be sure to watch the whole session to get a deep understanding of C++ language!

Embarcadero Bcc32c and bcc32x (Clang-enhanced compiler for Win32) implements all of the ISO C++11 standard. It includes the use of non-static data member to be initialized where it is declared. The basic idea for C++11 is to allow a non-static data member to be initialized where it is declared (in its class). A constructor can then use the initializer when run-time initialization is needed. #include struct B { B(int, double, double); }; class A { int a = 7; // OK std::string str1 = “member”; // OK B b = {1, 2, 3.0}; //OK std::string str2(“member”); // ill-formed }; #include   struct B {         B(int, double, double); };   class A {         int a = 7; // OK         std::string str1 = “member”; // OK         B b = {1, 2, 3.0}; //OK         std::string str2(“member”);   // ill-formed }; Why useful.-Easier to write.-You are sure that each member is properly initialized.-You cannot forget to initialize a member like when having a complicated constructor. Initialization and declaration are in one place – not separated.-Especially useful when we have several constructors.-Previously we would have to duplicate initialization code for members.-Now, you can do a default initialization and constructors will only do its specific jobs. If a member is initialized by both an in-class initializer and a constructor, only the constructor’s initialization is done (it “overrides” the default). Head over and find out more about C++ non-static data member initializers in the Embarcadero DocWiki!

function TForm1.GetProperty(pSelf, Args : PPyObject) : PPyObject; cdecl; var   key : PAnsiChar; begin   with GetPythonEngine do     if PyArg_ParseTuple( args, ‘s:GetProperty’,@key ) > 0 then       begin         if key = ‘Title’ then           Result := VariantAsPyObject(cbTitle.Text)         else if key = ‘Name’ then           Result := VariantAsPyObject(edName.Text)         else if key = ‘Informatician’ then           Result := VariantAsPyObject(cbInformatician.Checked)         else if key = ‘PythonUser’ then           Result := VariantAsPyObject(cbPythonUser.Checked)         else if key = ‘Age’ then           Result := VariantAsPyObject(edAge.Text)         else if key = ‘Sex’ then           Result := VariantAsPyObject(rgSex.ItemIndex)         else           begin             PyErr_SetString (PyExc_AttributeError^, PAnsiChar(Format(‘Unknown property “%s”‘, [key])));             Result := nil;           end;       end     else       Result := nil; end;   function TForm1.SetProperty(pSelf, Args : PPyObject) : PPyObject; cdecl; var   key : PAnsiChar;   value : PPyObject; begin   with GetPythonEngine do     if PyArg_ParseTuple( args, ‘sO:SetProperty’,@key, @value ) > 0 then       begin         if key = ‘Title’ then           begin             cbTitle.Text := PyObjectAsVariant( value );             Result := ReturnNone;           end         else if key = ‘Name’ then           begin             edName.Text := PyObjectAsVariant( value );             Result := ReturnNone;           end         else if key = ‘Informatician’ then           begin             cbInformatician.Checked := PyObjectAsVariant( value );             Result := ReturnNone;           end         else if key = ‘PythonUser’ then           begin             cbPythonUser.Checked := PyObjectAsVariant( value );             Result := ReturnNone;           end         else if key = ‘Age’ then           begin             edAge.Text := PyObjectAsVariant( value );             Result := ReturnNone;           end         else if key = ‘Sex’ then           begin             rgSex.ItemIndex := PyObjectAsVariant( value );             Result := ReturnNone;           end         else           begin             PyErr_SetString (PyExc_AttributeError^, PAnsiChar(Format(‘Unknown property “%s”‘, [key])));             Result := nil;           end;       end     else       Result := nil; end;