Demigodd

И снова здраствуйте.
Вы не прислушались к моему прошлому совету, да? :)

В классе Point добавьте метод
double DistanceFrom(Point oth)
{
dx = oth.x - x;
dy = oth.y - y;
return(sqrt((dx*dx)+(dy*dy)));
}

Тогда периметр a,b,c будет :
double Perimeter = a.DistanceFrom(b) + b.DistanceFrom(c) + c.DistanceFrom(a);

Ну а площадь... Вы в гугле забейте "Площадь треугольника по координатам вершин" - там все совсем просто.

Наследование подразумевает отношение "является". Является ли линия точкой? Нет. А треугольник является точкой? Нет. Так за каким же фигом ты их наследуешь так? Треугольник это три точки. Причём не любые, а три различные точки, не лежащие на одной прямой. Этим инвариантам треугольник удовлетворять обязан.
Площадь и периметр считаются из трёх точек.

Вывод - это вывод из программы в поток (cout), ввод - это ввод из потока в программу (cin), это можно понять по названиям.

Один из вариантов - считывать не чисто, а строку, а затем уже преобразовать строку в чисто другими функциями.
Или можно воспользоваться интерфейсом обработки ошибок потоков:

#include <iostream>
#include <limits>

int main() {
    int num = 0;

    while(num != -1) {
        std::cout << "Enter the number to push: ";
        std::cin >> num;
        if(std::cin.fail()){
            std::cout  << "It is not number" << std::endl;
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<int>::max(), '\n');
        } else{
            std::cout << "num = " << num << std::endl;
        }
    }
    
    return 0;
}

Тащемта размер тубуляции настраивается в вашем редакторе.

Самостоятельная замена в файле символ_таб -> 4пробела полностью снимает проблему.

Разница только в том, что calloc обнуляет выделенную память перед тем, как возвратить указатель, а malloc этого не делает. Внутри calloc, наверняка вызывает malloc для выделения памяти, а потом memset для обнуления. Так что calloc это просто надстройка над malloc для удобства. Вот схематично реализация calloc:

void * calloc (size_t num, size_t size)
{
   void * mem = malloc(num * size);
  memset(mem, 0, num * size);
  return mem;
}

Сами эти функции оперируют исключительно размером выделяемой области в байтах, им все равно что вы в дальнейшем будете делать с выделенной памятью - инты туда писать или "стринги".
Ну и как бы никто не мешает вам одну и ту же область памяти сначала использовать как массив интов, а потом как массив байт. Или так например:

int a = 0x33323130;
char * c = (char*)&a;
printf("%c %c %c %c\n", c[0], c[1], c[2], c[3]);

Пример не использует malloc/calloc для выделения памяти, память выделяется в стеке просто объявлением int a. Тут я попытался показать, что содержимое памяти можно интерпретировать как угодно, главное находится в границах выделенного диапазона.
Причем языки С/С++/asm это позволяют делать, а другие - нет.
Пример предполагает, что int имеет размер 32 бита, не для всех платформ это так, но в основном - именно так.
Кстати этот пример можно использовать для определения порядка байтов платформы: если выведется "1 2 3 4" значит у вас LITTLE ENDIAN, а если "2 1 4 3" - BIG ENDIAN.

PS: free() - это Си, а delete - C++

Если я тебя правильно понял:
создаёшь новый дин. массив, копируешь в него значения, сортируешь его, выводишь, потом освобождаешь память, и всё.

Во-первых, не нужно разделять PrintArray и SourceArray. Код у них один и тот же.

Во-вторых, массив передается в BubbleSort по указателю, то есть, если BubbleSort меняет массив, то он меняется вообще.

Вам нужно перед вызовом BubbleSort скопировать массив, и в функцию передать копию. Например:

int array_copy[size];
memcpy(array_copy, array, size);

Если вы изучаете С++, то лучше использовать классы стандартной библиотеки для массивов. В функцию передаете ссылку на класс.
В чистом Си передается просто указатель и размер в отдельном параметре (или 2 размера для двумерного массива).
Сам двумерный массив может быть представлен в двух вариантах:
1.Как массив указателей, где каждый указатель представляет собой одномерный массив. Нужно отдельно выделять память для массива указателей и для каждого одномерного подмассива и аналогично освобождать. В этом случае возможна операция индексации обоих измерений массива, при этом массив указателей и каждый подмассив могут находится в разных участках памяти.

void foo(int ** arr, int N, int M)
{
...
}
int main()
{
  int N = 10; // первое измерение массива
  int M = 20; // второе измерение массива
  int ** arr = new int * [N];
  for(int i = 0; i < M; ++i)
  {
     arr[i] = new int[M];
  }
  ...
  foo(arr, N, M);
  ...
  // Тут освобождение массива аналогично выделению в обратном порядке
}

2.Как одномерный массив размерностью N * M. В этом случае память под массив выделяется и освобождается вся оптом одним куском, но операция индексации первых размерностей не возможна. Но можно легко переходить от двумерного массива к одномерному, сразу вычислять нужный индекс или просто перемещаться по элементам массива с помощью временного указателя.

void foo(int * arr, size_t N, size_t M) 
{
  ...
}
int main()
{
  int N = 10; // первое измерение массива
  int M = 20; // второе измерение массива
  int * arr = new int * [N*M];
  int * arrcur = arr;  // временный указатель для обхода массива
  int * arrone = arr;  // вариант с переходом к одномерному массиву
  for(int i = 0; i < N; ++i)
  {
    for(int j = 0; j < M; ++j)
    {
        // Вариант с вычислением адреса текущего элемента по индексам
       *(arr + i * M + j) = rand() % 10;   // вычисление нужного индекса на месте
       // Вариант с обходом массива с помощью временного указателя
       *arrcur = rand() % 10; 
       ++arrcur;  // переход к следующему элементу
       // Вариант с переходом к одномерному массиву
      arrone[j] = rand() % 10; 
    }
    arrone += M;
  }
  ...
  foo(arr, N, M);
  ...
  delete[] arr;
}

Можно так:

#include <array>

template<std::size_t ColumnCount, std::size_t RowCount > 
int foo(int (&matrix)[ColumnCount][RowCount]){ 
   int r = 0;
   for(auto& row: matrix){
       for(auto& x: row)
          r += x;
   }
   return r;
}

int bar(){
    int matrix [][2] = {{1, 2}, {3, 4}, {4, 6}};
    return foo(matrix);
}

С-массивы в функции можно передавать только по ссылке. Или преобразовать в массив указателей.

Вообще, для передачи С-массивов придуман std::array, но двумерный C-массив нельзя напрямую привести к std::array<std::array<int, M>, N>. Но можно изначально работать с std::array:

template<std::size_t ColumnCount, std::size_t RowCount > 

int foo(std::array<std::array<int, RowCount>, ColumnCount>& matrix){ 
   int r = 0;
   for(auto& row: matrix){
       for(auto& x: row)
          r += x;
   }
   return r;
}

int bar(){
    std::array<std::array<int, 2>, 3> matrix = {{{1, 2}, {3, 4}, {4, 6}}};
    return foo(matrix);
}

const int size
Массив не передается. Передается указатель. Даже если вы пишете a[][size]

Можете еще проверить обновление винды, если так же будет завершаться с непонятной ошибкой, то вы не первый пострадавший.
Можете подождать, вдруг в этот раз проблема действительно в мелкософте.
Лично мне проблему решить не удалось, это было примерно пол года назад (я тогда то же ждал неделю или две, просто руки не доходили плотно заняться). В итоге переустанавливал винду.
И у других соратников по несчастью, которые писали аналогичные вопросы тут, на сколько я знаю, так же дело разрешилось переустановкой.

Рекурсия - это тоже цикл. Только скрытый с глаз и делающий stackoverflow круче, чем это делает Спольски.

эти значения используются только при создании коммита.
если ты сначала закоммитил, а потом пошел менять локальные параметры, это ничего не изменит.
крайний коммит можно git commit --amend --reset-author, остальные - через интерактивный ребейз.

нужно выполнить

echo -e "host=github.com\nprotocol=https" | git credential-manager erase

man basename
man dirname
man awk

Последнее - на предмет опции F и переменной NF.