Questions[c++]

Since c++11 the c ++ standards committee has made it a goal to approve a new standard every 3 years. This has been the case to date and we have had the following standards:

• c++14 approved in August 2014.
• c++17 approved in March 2017.
  • What are the new features of C++17? .
  • C++17 What is it? Isn't it C++? ¹ .

Standardization is divided into four working groups:

• Nucleus (Core): Maintenance of the language and standardization of new proposals.
• Evolution : Development of new features for the language.
• Library : Maintenance of the standard library and standardization of new proposals.
• Library evolution : Development of new features for the standard library.

In July 2019, the C++20 standard was considered closed. This implies that no new features can be added (although some could be removed if problems are detected) and approved features are being reviewed for possible improvements or minor corrections.

At this last meeting, it was considered that the Contracts ² proposal (technical document P0542R4 ) would not be incorporated in C++20 and is delayed to C++23.

We are going to list some of the main features that C++20 will incorporate.

¹ Due to some strange oversight, I wrote two threads about C++17.

² According to Wikipedia the contract is:

Design - by-contract is a methodology for the design and implementation of applications and components popularized by the Eiffel programming language . It consists of considering design elements as participants in a relationship similar to a business contract. Thus, components can be designed assuming that certain input conditions (pre-conditions) will be met, while certain output conditions (post-conditions) must be guaranteed, as well as class invariance (properties that remain invariant despite of the processing performed by the component).

C++ Contracts will follow the attribute syntax (added in C++11):

[[contrato modificador: expresión-condicional]]

Contracts have been moved to C++23, the following is subject to change: The available contracts are:

• expects: A type contract expectsis a pre-condition. Indicates what a function expects from its arguments, and that contract is expected to hold throughout the function call.
• ensures: A type contract ensuresis a post-condition. Indicates the state that the objects passed to a function (or the return from it) are expected to have at the end of the call.
• asert: A type contract assertis an assertion. Indicates a condition that is expected to be satisfied where the contract appears.

When a contract is not fulfilled, a function call will be made with the following signature:

void(const std::contract_violation &);

The object std::contract_violationwill contain information about the breach of contract such as where (file, line, function) has been breached.

Modifiers can be applied to contracts, modifiers will affect how code with contracts is generated and whether or not contracts are checked at runtime. The available modifiers are:

• axiom: The verification of the conditions of this contract is expected to have no cost, it is not evaluated at execution time.
• default: Verification of the conditions of this contract is expected to be inexpensive.
• audit: Verification of the terms of this contract is expected to be expensive.

The contracts that will be verified at compile time contain code that will be compiled, you can specify the level with which you want to compile each translation unit and the resulting behavior will be:

• Default: Checks (compiles) contracts marked as default(contracts that have no modifier are considered default).
• Audit: Verifies (compiles) the contracts marked as auditand default.

At the suggestion of the PaperBirdMaster user, I have decided to ask the question indicated in the title of this post.

Basically, as I mentioned to said user, I have seen in different SO answers that in C++ it is not necessary to include the instruction return 0;in the function mainsince the compiler is capable of including said instruction on its own. How much truth is there in the above statement?

Personally, I prefer to include the return 0;because it goes along the lines of using a returnwithin a function, since by definition functions return a value. It would be different if mainhe declared it as void main(), which is not standard, but at least it is valid in Visual Studio, for example, and there he would see the need to include some kind of return.

On the other hand, related to all of the above, how valid is it to use another type of returnlike, for example, return EXIT_SUCCESS;, which can be found in one of the books on C++ by Luis Joyanes.

Thanks in advance for your responses and/or comments.

For example if I use:

printf("ó á");

The result obtained in the console is:

¾ ß

Where 3/4 represents ó and ß represents á

Today I found a piece of code where the program seems to have a bug, but works as expected:

This is a simplification of that code, which reproduces the same behavior:

int main()
{
  int arreglo[] = { 0, 1, 2, 3 };
  int indice = 0;
  std::cout << arreglo[indice] << "\n";
  indice++;
  std::cout << arreglo[indice] << "\n";
  indice++;
  std::cout << indice[arreglo] << "\n";
  indice++;
  std::cout << arreglo[indice] << "\n";
}

Departure:

$ ./prueba
0
1
2
3

The question is: Why does the expression work indice[arreglo]as if I were putting arreglo[indice], if they should be backwards?

Here is a very peculiar piece of C++ code. For some strange reason sorting the data miraculously causes the code to run 3 times faster.

#include <algorithm>
#include <ctime>
#include <iostream>

int main()
{
    // Generate data
    const unsigned arraySize = 32768;
    int data[arraySize];

    for (unsigned c = 0; c < arraySize; ++c)
        data[c] = std::rand() % 256;

    // !!! Con esto el siguiente bucle se ejecuta más rápido.
    std::sort(data, data + arraySize);

    // Test
    clock_t start = clock();
    long long sum = 0;

    for (unsigned i = 0; i < 100000; ++i)
    {
        // Primary loop
        for (unsigned c = 0; c < arraySize; ++c)
        {
            if (data[c] >= 128)
                sum += data[c];
        }
    }

    double elapsedTime = static_cast<double>(clock() - start) / CLOCKS_PER_SEC;

    std::cout << elapsedTime << std::endl;
    std::cout << "sum = " << sum << std::endl;
}

• Without std::sort(data, data + arraySize);, the code runs in 12.41 seconds.
• With the data sorted it runs in 3.82 seconds.

At first I thought it might be a language or compiler anomaly. So I tried in Java :

import java.util.Arrays;
import java.util.Random;

public class Main
{
    public static void main(String[] args)
    {
        // Generate data
        int arraySize = 32768;
        int data[] = new int[arraySize];

        Random rnd = new Random(0);
        for (int c = 0; c < arraySize; ++c)
            data[c] = rnd.nextInt() % 256;

        // !!! Con esto el siguiente bucle se ejecuta más rápido.
        Arrays.sort(data);

        // Test
        long start = System.nanoTime();
        long sum = 0;

        for (int i = 0; i < 100000; ++i)
        {
            // Primary loop
            for (int c = 0; c < arraySize; ++c)
            {
                if (data[c] >= 128)
                    sum += data[c];
            }
        }

        System.out.println((System.nanoTime() - start) / 1000000000.0);
        System.out.println("sum = " + sum);
    }
}

Which gives similar but less extreme results. 10.7 and 6.2 seconds.

At first I thought it might have to do with sorting the data getting it into the cache, and then I realized that the data had just been generated with what should already be in the cache before sorting.

• What's going on?
• Why is an ordered array faster than an unordered one?
• The code is calculating the sum of independent terms. The order should not influence, in any case, all the elements are traversed and the same ones are always added, giving the same result, whether they are ordered or not.

This is a question translated from the original in English and adapted to the results it gives on my computer: Why is processing a sorted array faster than an unsorted array? by GManNickG