jcmvbkbc

но почему, если мы его занулили в самом начале программы?

int i,k,w = 0;

// каким образом i учавствует в коде, если мы с ней
// ничего не делали?? если убрать это условие, код не работает

for(i=0; i<w; i++)

зачем в этом коде нужна переменная k,

Как это код работает?

AnsiString params[] = {"/c REG DELETE \"***\"};
        for (unsigned short i = 0; i < params->Length(); {
           system(params[i].c_str());
        }

ругается на "Access violation at address"

Нужно из c++ переместить этот массив в ассемблерную вставку, а там уже перенести из этого массива в другой массив все элементы, которые равны сумме соседних.
То есть регистры e*x нельзя брать. Кто может подсказать, где найти материал по этой теме, либо же предложить пример кода для решения поставленной задачи?

#include <stdint.h>

void f(void)
{
    uint32_t a[16] = {1, 2, 3, 1, 5, 4, -1, }, b[16] = {0};
    void *a1, *b1;
    uint32_t tmp, cnt = 14;

    asm (
        "lea %[a], %[a1]\n\t"
        "lea %[b], %[b1]\n"
        "1:\n\t"
        "mov (%[a1]), %[tmp]\n\t"
        "add 8(%[a1]), %[tmp]\n\t"
        "cmp 4(%[a1]), %[tmp]\n\t"
        "jne 2f\n\t"
        "mov %[tmp], (%[b1])\n\t"
        "add $4, %[b1]\n"
        "2:\n\t"
        "add $4, %[a1]\n\t"
        "dec %[cnt]\n\t"
        "jnz 1b\n\t"
        : [cnt] "=&r" (cnt), [tmp] "=&r" (tmp),
          [a1] "=&r" (a1), [b1] "=&r" (b1),
          [b] "=m" (b)
        : [a] "m" (a));
}

if (arr[i] <= arr[j]) {
            d[k] = arr[i];
            da[k] = arr2[i];
            i++;
        } 
        else {
            d[k] = arr[j];
            da[k] = arr2[i];
            j++;
        }

std::string d[end - begin];
    std::string da[end - begin];

как ускорить работу этого потока чтоб он использовал все ресурсы процессора?

постоянно 0 показывает

Ведь operator=() - не статический метод, а значит его вызывать можно только через объект.

#include <pty.h>
#include <unistd.h>
#include <thread>
#include <future>
#include <iostream>
#include <string>

ssize_t sz = 1;

int main()
{
  int mfd;

  pid_t pid_fork = forkpty(&mfd, NULL, NULL, NULL);

  if (!pid_fork) {
    // Дочерний процесс
    execl("/bin/sh", "-", NULL);
  } else {
    // Родительский процесс
    char buf[1024];

    // Async
    auto future = std::async(std::launch::async, [mfd]() {
      std::string line;
      while (sz) {
        std::getline(std::cin, line);
        line = line  + "\n";
        write(mfd, line.c_str(), line.size()); // Нужно направить в дочерний процесс как stdin
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
      }
    });

    while (sz = read(mfd, buf, sizeof(buf))) {
      write(STDOUT_FILENO, buf, sz); // Вывод из дочернего процесса stdout
      std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }

    exit(0);
  }
}

...
#include <sys/ioctl.h>
...
  struct winsize ws, *pws = NULL;

  if (ioctl(1, TIOCGWINSZ, &ws) >= 0)
    pws = &ws;
  pid_t pid_fork = forkpty(&mfd, NULL, NULL, pws);

как быть? Какой размер массива объявить?

напрашивается вопрос "Будет ли конструктор базового класса A вызываться два раза, ведь в конструкторе C тоже вызывается конструктор A?".

A mem-initializer where the mem-initializer-id denotes a virtual base class is ignored during execution of a constructor of any class that is not the most derived class.

LONG error = RegCreateKeyEx(...);
  if (hKey) {

Ошибок нет, но и результатов нет !

This flag must be combined using the OR operator with the other flags in this table that either query or access registry values.

RegSetValueA(hKey, "test", REG_SZ, (LPCSTR)path.c_str(), sizeof(path.c_str()));

struct Data {
  short id;
  double val;
};

я понимаю что 32 00 11 49 - это интовское значение

Как в данном выводе понять где выравнивание происходит?

Насчет компиляторов поверю, но вот процессора ??? как ???

В сети не нашёл ответа.

Получается, что, если явно скобками не обозначить, то ассоциативность всегда будет справа налево, или я не прав?

#include <string>
#include <iostream>

struct A
{
        std::string name;

        A(const std::string& _name): name(_name)
        {
        }

        A operator +(const A& other) const
        {
                std::cerr << name << " + " << other.name << std::endl;
                return A(std::string("{temporary from ") + name + " + " + other.name + "}");
        }
};

int main()
{
        A first("first"), second("second"), third("third");
        A r = first + second + third;
}

first + second
{temporary from first + second} + third