Mercury13

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

Кстати, посмотри интереса ради gcc -Os.

Трёхмерная графика не бывает векторной и растровой. У неё там свои разновидности, и там она используется полигональная. Текстуры, разумеется, растровые. Существуют псевдовекторные элементы вроде поля расстояний, но это именно что «псевдо-».

Двухмерная — в подавляющем большинстве случаев растровая, но и векторные элементы бывают.

Вы тут просто не знаете, что такое указатель. А это, грубо говоря, адрес другого объекта в памяти.
Операция new заводит объект в «куче», вызывает конструктор (если таковой есть) и возвращает указатель на него.
И мы можем разыменовать указатель: пройти на тот объект, куда он указывает, и сделать с ним что-то. В Си разыменование — операция ->.

Указатели не на абстрактный класс, а на вполне конкретный, a.

a(int) — не конструктор копирования, а просто конструктор, делающий объект из int’а. Конструктор копирования всегда a(const a&). Отличается от других конструкторов тем, что автоматика его по возможности строит, но не всегда верно. В вашем объекте с одним полем int вполне себе построит без всяких проблем.

Обычный указатель Си никоим образом не знает, есть объект или нет, и кто этот объект уничтожает. У вас это приводит к ошибке «утечка памяти»: теряется указатель на объект, и уже никак его не освободишь. Из-за небольшого размера и линейного характера программы неопасно, но всё-таки.

Вместо
boolean[][] visited = new boolean[ROW][COL];

надо сделать такое:

static final byte DIR_UNKNOWN = 0;
static final byte DIR_UP = 1;
...

byte[][] bestDirection = new boolean[ROW][COL];  // изначально заполнено DIR_UNKNOWN

for (int dir = DIR_UP; dir <= DIR_RIGHT; ++dir) {
  ...
  bestDirection[row][col] = dir;
}

Добравшись до финиша, делаем обратный ход. А именно: определяем, какой bestDirection у финиша, и если он, например, DIR_UP — смещаемся на 1 вниз. И так далее, пока не доберёмся до старта.

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

Не забывайте, что у startManufacturing есть скрытый параметр this.

Четыре варианта.

1. Использовать указатель на метод App:

Rest::function(char * function_name, int (App::* f)(String), App& object)
      // вместо App можно какой-то интерфейс, который App реализует
…
object.*f("string");
...
bt_rest.function("", &App::startManufacturing, *this);

2. Сделать startManufacturing static:

class App {
  static int startManufacturing(String command)
};

3. Сделать обёртку с замыканием:

Rest::function(char * function_name, int (*f)(String, void*), void*);

void doStartManufacturing(String command, void* closure) {
  reinterpret_cast<App*>(closure)->startManufacturing(command);
}
...
bt_rest.function("startManufacturing", doStartManufacturing, this);

4. «Избегай незнакомых женщин и глобальных переменных». Костыль, в общем.

App app;
int doStartManufacturing(String command) { return app.startManufacturing(command); }
...
bt_rest.function("startManufacturing", doStartManufacturing);

Ах да. Вы передаёте String’и по значению. Приспособлены они к такой передаче или всё же лучше по ссылке?

Я бы работал по такой формуле:

result = ((original / max)^{1 / gamma}) · 255

Original — это полученное алгоритмом Ву значение (float или хотя бы short!)
max — максимально возможное значение original. Для short, например, это 65535.
gamma — традиционно 2,2.

1. Для ввода строки использовать std::getline.
2. Ну, в Си++ есть хорошо инкапсулированные строки, а в Си нет. Потому в Си очень сложно получить из потока строку неизвестной длины.

Есть такое понятие, как «принцип подстановки Барбары Лисков». Если подставить на место User класс Comparator, должно сойтись по типам. Но нет: User умеет сравнивать только с самим собой, а Comparator — с любым Comparator.

Теоретически должно было бы подойти такое (так называемая контравариантность). Но не работает ни в Си++, ни в Яве.

class ComparatorBase
{
public:
    virtual ~ComparatorBase() = default;
};

class Comparator : public ComparatorBase {
    public:
        virtual int compare(Comparator  *t)=0;
};

class User : public Comparator{
public:
    int compare(ComparatorBase *u) override {
        return 1;
    }
};

А по возвращаемому значению (если возвращается ссылка/указатель) может быть ковариантность, и она работает и в Си++, и в Яве.

class Father
{
public:
    virtual Father& foo();
    virtual ~Father() = default;
};

class Son : public Father
{
public:
    Son& foo() override;
};

Как обойти. Есть два способа.
Способ 1. Пусть старой Явы.

int User::compare(Comparator *u)
{
    auto* v = dynamic_cast<User*>(u);
    if (!v)
        return false;
    return v->name > this->name;
}

Способ 2. Так называемый «странно рекуррентный шаблон».

template <class T>
class Comparator {
public:
    virtual int compare(T *t)=0;
    virtual ~Comparator() = default;
};

class User : public Comparator<User> {
private:
    std::string name;
public:
    User(std::string name){this->name=name;}
    int compare(User *u);
    void showName(){std::cout<<"Name "<<this->name<<std::endl;}

};

int User::compare(User *u)
{
    return u->name > this->name;
}

1. С использованием функций преобразования типа, встроенных в Си++ или написанных пользователем. Это может делаться неявно, через C-style cast, через вызов конструктора, через операцию static_cast.
2. С преобразованием указателя вниз по иерархии наследования, и особым поведением, если это не получилось, через операцию dynamic_cast и функцию dynamic_pointer_cast.
3. С рассмотрением участка памяти как переменной несовместимого типа. Через union, const_cast, reinterpret_cast, C-style cast указателей.

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

Без особого консольного API той или иной ОС — никак. Потому что строка передаётся в консоль, когда пользователь нажимает на ввод.

Самомодифицирующийся код.