Alexander Movchan

Вы имеете ввиду разбить проект на несколько файлов?
Вам понадобится создать по два файла для каждого модуля: заголовочный (с объявлениями) и собственно файл с реализацией (определением). Файлы с объявлениями имеют расширение .h .H .hpp и так далее.

main.cpp: определение функции main.

// Следующая строка при компиляции будет заменена на содержимое файла helloworld.h
#include "helloworld.h"

int main(int argc, char** argv)
{
    helloworld(); // Вызываем функцию определённую в другом файле.
    return 0;
}

helloworld.h: объявление функции helloworld

// Следующая конструкция называется include guard.
// Благодаря ней вы не сможете вставить содержимое этого файла дважды,
// что поможет вам избежать ошибок переопределения.
#ifndef HELLOWORLD_H 
#define HELLOWORLD_H

// Объявление функции.
// Если функция объявлена но не определена в данном файле,
// компилятор будет искать её реализацию в других файлах.
void helloworld();

#endif

helloworld.cpp

// Снова вставляем содержимое файла helloworld.h
#include "helloworld.h"

#include <iostream>

// Определяем функцию.
void helloworld()
{
    std::cout << "Hello, world!";
}

Потому, что gcc - компилятор языка C. Используйте g++.

Upd.
Ошибку выбивает потому, что вы не подключили библиотеку libstdc++, в которой определены string и другие объекты стандартной библиотеки:
gcc file_name.cpp -lstdc++
Просто, msvc++ и g++ делают это автоматически.

Наверняка как-то это уже реализованно/упрощено с помощью стл или буст или чего-то еще.

Так почему же не проверить, перед тем, как задавать вопрос? Вот, первая ссылка - то, что вам нужно.

Так же как в десятичной системе счисления вы не можете представить число 1/3 в виде десятичной дроби, вы не можете представить в двоичной системе счисления некоторые дроби, которые можете представить в десятичной. Если всё же попытаетесь это сделать, получите бесконечную периодическую дробь.
Так, например если перевести число 0.4 из десятичной системы в двоичную, получите такую периодическую дробь: 0,0110011001100.. и так далее до бесконечности. 100 / 1010 = 0.(0110)

Однако это не означает, что ваша задача не решаема. Просто нужно подойти к решению с другой стороны:

class DecimalFixedPoint
{
public:

    static const int denominator = 100; // Affect on precison
    friend std::ostream& operator<<(std::ostream& stdout, DecimalFixedPoint dfp);

    DecimalFixedPoint()                  : numerator(0)               {}
    DecimalFixedPoint(int i, bool)       : numerator(i)               {}
    DecimalFixedPoint(int i)             : numerator(i * denominator) {}
    explicit DecimalFixedPoint(float f)  : numerator(f * denominator) {}
    explicit DecimalFixedPoint(double d) : numerator(d * denominator) {}

    DecimalFixedPoint operator+(const DecimalFixedPoint& right)
    {
        return DecimalFixedPoint(numerator + right.numerator, true);
    }

    DecimalFixedPoint operator-(const DecimalFixedPoint& right)
    {
        return DecimalFixedPoint(numerator - right.numerator, true);
    }

    DecimalFixedPoint operator*(const DecimalFixedPoint& right)
    {
        return DecimalFixedPoint(numerator * right.numerator / denominator, true);
    }

    DecimalFixedPoint operator/(const DecimalFixedPoint& right)
    {
        return DecimalFixedPoint(numerator * denominator / right.numerator, true);
    }


private:
    int numerator;
};


std::ostream& operator<<(std::ostream& stdout, DecimalFixedPoint dfp)
{
    stdout << dfp.numerator / DecimalFixedPoint::denominator
           << '.'
           << dfp.numerator % DecimalFixedPoint::denominator;
    return stdout;
}

Upd.
В конструкторе DecimalFixedPoint(int i, bool) : numerator(i) {} второй параметр нужен для того, чтоб сигнатура отличалась от конструктора

DecimalFixedPoint(int i) : numerator(i * denominator) {}

Если вызывается конструктор с параметром bool, подразумевается, что мы не приводим целое число к нашему типу, а передаём заранее вычисленный числитель нашей дроби. Это, конечно, костыль, но так как такой подход используется в самом стандарте C++ (перегрузка префиксных и постфиксных инкремента/декремента), то совесть моя чиста.

1. Что-то вроде доказательства от обратного: сначала предполагаем, что число простое isPrime = true; А если находится число, деление на которое происходит нацело, то есть остаток от деления равен нулю if((i%j) == 0), тогда доказано обратное, данное число составное: isPrime = false;

2. Для того, чтоб не делать лишних итераций, если есть число N, то достаточно проверить только его делители от 2 до √N.

P.S. Если, поставить i < 100, то в проверку пойдёт и само число, а так как число нацело делится само на себя, остаток будет 0 и условие сработает неправильно. Внутренний цикл перебирает делители числа, а для числа N, они находятся в диапазоне [1, N], однако так как и простые числа делятся на 1 и на самих себя, проверять нужно только диапазон (1, N).
Все делители больше чем √N дают в результате деления целые числа меньше чем √N, а так как меньшие числа мы уже перебрали, в проверке бо ́льших нет смысла. Условие j<(i/j) как раз обеспечит перебор целых чисел в диапазоне [2, √N].

Можно также добавить небольшую оптимизацию:

for (j=2; j<(i/j); j++) {
        if((i%j) == 0) {
                isPrime = false;
                break;
        }
      }

Если нашли один делитель, этого достаточно. Перебирать остальные не обязательно.

То, что вы написали, называется делегирующий конструктор. И это работает начиная со стандарта C++11.

Указатели действительно не очень востребованы в языке C++, так как в большинстве случаев лучше использовать ссылки. Однако в языке С ссылок нет, и поэтому для совместимости иногда используют указатели.
Передача по значению создаёт копию передаваемого объекта. Это используется тогда, когда в функции (или методе) вам может понадобится изменить объект, однако эти изменения не должны затронуть тот объект, который вы передавали.

Например, поиск наибольшего общего делителя:

int gcd(int a, int b) {
   int c;
   while (b) {
      c = a % b;
      a = b;
      b = c;
   }
   return abs(a);
 }

В функции изменяются копии переданных объектов, а не сами объекты.

int a = 16;
int b = 4;
gcd(a, b);
cout << a << ' ' << b; // Выведет "16 4", а не "4 0"

Upd.1
Указатели используются в многих структурах данных. Например, связный список:

template<T> struct LinkedListItem
{
    T value;
    LinkedListItem* next;
};

Значение здесь использовать нельзя, так как объект не может содержать внутри объект того же типа (получается бесконечная рекурсия). Ссылку использовать также нельзя, так как ссылка должна быть сразу привязана к объекту (переменной), а в случае со списком, элементы могут быть добавлены/изменены в любое время.

Upd.2
Можно создавать указатели на функции. Функцию нельзя передать по значению или по ссылке.

#include <iostream>

float f1(float x)
{
    return 2 * x + 6;
}

float f2(float x)
{
    return -3 * x * x + 8 * x - 6;
}

void printTable(float(*f)(float), float beg=0.f, float end=10.f, float step = 1.f)
{
    for(float x = beg; x <= end; x += step)
    {
        std::cout << "x = " << x << "\ty = " << f(x) << '\n';
    }
}

int main(int argc, char** argv)
{
    printTable(f1);
    printTable(f2);
}

(x1 != x2 or y1 != y2) and    # Первая точка не совпадает со второй и...
(x1 != x3 or y1 != y3) and    # Первая точка не совпадает с третьей и...
(x2 != x3 or y2 != y3) and    # Вторая точка не совпадаят с третьей и...
((x1 == x2 and x2 == x3) or   # X-координаты всех точек равны или...
 (y1 == y2 and y2 == y3))     # Y-координаты всех точек равны