jcmvbkbc

#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

Возможно ли как то совместить две эти реализации что бы получать на выходе crc32 в виде const char*?

void massiv::sum(massiv obj1, massiv obj2)
void massiv::multiply(massiv obj1, massiv obj2)

void massiv::sum(const massiv& obj1, const massiv& obj2)
void massiv::multiply(const massiv& obj1, const massiv& obj2)

long double a = 1.4142135623730950488;
double b = 1.4142135623730950488;

почему переменная типа long double хранит данные с такой же точностью, как и переменная типа double?

The type of a floating literal is double unless explicitly specified by a suffix.

Подскажите, как лучше поступить в моем случае?

как можно уместить 1.7754 в 3f 1a?

Как число с плавающей точкой преобразовать в half float в 16 формат

В чем ошибка?

if (miderate[i] > miderate[i + 1]) {
        swap (records[i].name, records[i + 1].name);
        swap (records[i].group, records[i + 1].group);
        swap(records[i].marks, records[i + 1].marks);
      }