Попытка напечатать оптимальный массив: поиск имени «k» изменен на новый ISO «для

Я работаю над планификацией для компании, которая производит автозапчасти. Мне нужно зациклиться на многих вещах, которые, возможно, немного сложно объяснить текстом. Цель состоит в том, чтобы получить окончательный оптимальный заказ деталей, чтобы получить наибольшую прибыль.

Это весь код, я не думаю, что вам нужно все понимать, так как я думаю, что это проблема pointers или &.

#include <cstdlib>
#include <stdio.h>
#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <limits.h>
#define SIZE 8
using namespace std;

int cmp(const void *a, const void *b);
void replacerow(int a[SIZE][SIZE], int row);
void replacecol(int a[SIZE][SIZE], int col);
float calculate_time(float tiempo_piezas, int piezas_almacen);
float calculate_planification(int* arrayNumeros);
int* grasp(char* piezadeseada);

typedef struct pair {
        int value, column;
} Pair;

char a[] = {0,1,2,3,4,5,6,7}, x;
int array_grande[5040][8];
int cont = 0;
int precio[8] = {5, 8, 10, 3, 1, 2, 10, 6}; 
double tiempo[8] = {1, 2, 1, 3, 1, 2, 3, 1}; //Pa hacer 100 piezas necesitan 1h, Para hacer 100 piezas necesitan 2h...
int almacen[8] = {1200, 500, 700, 850, 900, 450, 950, 900}; 
int numerodepiezas = 8;
int pedido[5] = {300, 2, 3, 4, 7};
int piezasdisponibles[3] = {0, 3, 7};

int main(int argc, char** argv) {

    float optimo = 0.0;
    int* arrayoptimo;
    char nombres_pieza[][20] = {"pieza0", "pieza1", "pieza2", "pieza3", "pieza4", "pieza5", "pieza6", "pieza7"};


    for (int i = 0; i < 100; i++) {
        int r = rand() % 8;
        int* arrayNumeros = grasp(nombres_pieza[r]);
        float precio = calculate_planification(arrayNumeros);
        if (precio > optimo) {
            memcpy (  arrayoptimo, arrayNumeros, sizeof(arrayNumeros) );
            optimo = precio;
        }
    }

    printf("Optimum sequence found\n");
    printf("total profit: %d euros", precio);
    printf("\n");
    for(int kl=0; kl< sizeof(arrayoptimo)/sizeof(int);kl++);
        printf( " %d ", arrayoptimo[kl]);
}

int* grasp(char* piezadeseada) {
    int f, c, q, myrow, r;
    int FILAS = 8;
    int array_aleatorio[8] = {0, 1, 2, 3, 4, 5, 6, 7};

    printf("El orden aleatorio es: ");
    for (int i = 0; i < 8; i++)
        printf(" %d ", array_aleatorio[i]);
    printf("\n\n");

    int piezas[8][8] = {
        -5, 2, 2, 5, 3, 2, 1, 1,
        0, -5, 5, 2, 4, 3, 0, 0,
        0, 4, -5, 2, 1, 2, 3, 2,
        0, 3, 1, -5, 1, 2, 3, 4,
        2, 5, 6, 5, -5, 1, 2, 7,
        8, 2, 0, 0, 0, -5, 1, 1,
        1, 2, 2, 1, 1, 6, -5, 4,
        0, 1, 3, 2, 0, 0, 0, -5,
    };

    char nombres_pieza[][20] = {"pieza0", "pieza1", "pieza2", "pieza3", "pieza4", "pieza5", "pieza6", "pieza7"};
    Pair data_pair[FILAS];

    // Prints matrix
    printf("\t");
    for (q = 0; q < FILAS; q++) {
        printf("%s", nombres_pieza[q]);
        printf("\t\t");
    }
    printf("\n");
    for (f = 0; f < FILAS; f++) {
        printf("%s", nombres_pieza[f]);
        printf("\t");
        for (c = 0; c < FILAS; c++) {
            printf("%d", piezas[f][c]);
            printf("\t\t");
        }
        puts("");
    }

    int iter = 0;
    int columna_a_borrar;
    int barras_perdidas = 0;
    int arrayNumeros[8];   

    for(int i=0;i<=8;++i) {
        if (!strcmp(piezadeseada, nombres_pieza[i])) {
            myrow = i;
        }
    }


    while (iter<sizeof (piezas) / sizeof (int)) {
        if (iter == 0) {
            arrayNumeros[0] = myrow;
        }
        for (int i = 0; i < FILAS; ++i) {
            if (piezas[myrow][i] != -5 && piezas[myrow][i] != -10) {
                data_pair[i].value = piezas[myrow][i];
                data_pair[i].column = i;
            } else {
                data_pair[i].value = INT_MAX;
                data_pair[i].column = i;
            }
        }
        if (iter < (numerodepiezas - 3)) {
            qsort(data_pair, FILAS, sizeof (Pair), cmp);
            for (int i = 0; i < 3; ++i)
                //printf("\nvalue = %d, column = %d", data_pair[i].value, data_pair[i].column);
                srand(time(NULL));
            int randNum = (rand() % 3);
            columna_a_borrar = data_pair[randNum].column;
            barras_perdidas = barras_perdidas + data_pair[randNum].value;


        } else if (iter < (numerodepiezas - 1)) { 
//printf("\n\nLos dos valores minimos de esta fila son:");
            qsort(data_pair, FILAS, sizeof (Pair), cmp);
            for (int i = 0; i < 2; ++i)
                //printf("\nvalue = %d, column = %d", data_pair[i].value, data_pair[i].column);

                // Generamos un número aleatorio para elegir la columna a borrar
                srand(time(NULL));
            int randNum = (rand() % (numerodepiezas - (iter + 1)));
            columna_a_borrar = data_pair[randNum].column;
            barras_perdidas = barras_perdidas + data_pair[randNum].value;

        } else if (iter == (numerodepiezas - 1)) {
            break;
        }

        replacerow(piezas, myrow);
        replacecol(piezas, myrow); 
        myrow = columna_a_borrar;
        strcpy(piezadeseada, nombres_pieza[myrow]);
        arrayNumeros[iter + 1] = myrow;
        iter = iter++;
    } // while end

    printf("\n\n\nSalgo del while y acambo. Array de numeros;\n");
    for (int p = 0; p < 8; p++)
        printf(" %d ", arrayNumeros[p]);
    printf("\n\n\n++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
    printf("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
    printf("++++++  El orden de introduccion de las piezas es:  +++++\n");
    for (int p = 0; p < 8; p++)
        printf("++++++    %d - %s \n", p + 1, nombres_pieza[arrayNumeros[p]]);
    printf("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
    printf("++++++  Barras perdidas en este proceso: %d\n", barras_perdidas);
    printf("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");

    return arrayNumeros;    
}


int cmp(const void *a, const void *b) {
        Pair *pa = (Pair *)a;
        Pair *pb = (Pair *)b;
        return pa->value - pb->value;
}
void replacerow(int a[SIZE][SIZE], int row) {
        for (int i=0;i<SIZE;++i) {
                a[row][i] = -10;
        } 
}

void replacecol(int a[SIZE][SIZE], int col) {
    int r;
        for(r=0;r<SIZE;++r) {
                a[r][col] = -10;
        }
}


float calculate_time(float tiempo_piezas, int piezas_almacen) {
        int time = (piezas_almacen * tiempo_piezas) / 100;
        return time;
}

int calcular_piezas(float tiempo_piezas, int tiempo_disponible){
    int piezas = ( tiempo_piezas / 100) * tiempo_disponible;
    return piezas;
}

float calculate_planification(int* arrayNumeros) {
    printf("start planification!\n");
    float horas_dia = 24;
    float tiempo_pieza;
    int horas_dia_restantes, tiempo_pieza_dia, num_dia = 0;
    float precio_total = 0.0;

    int p = 0;

    while (num_dia > 5 || p < sizeof (arrayNumeros) / sizeof (int)) {
        tiempo_pieza = calculate_time(tiempo[arrayNumeros[p]], almacen[arrayNumeros[p]]);

        if (tiempo_pieza > 24) {
            if ( ( ((num_dia + (int)(tiempo_pieza / 24) )*24 ) + ((int)tiempo_pieza % 24) ) < (5 * 24) ) 
            {
                num_dia += (int) (tiempo_pieza / 24);
                horas_dia_restantes = horas_dia - ((int)tiempo_pieza % 24);
                precio_total += almacen[arrayNumeros[p]] * precio[arrayNumeros[p]];
            } else {
                int piezas = calcular_piezas(almacen[arrayNumeros[p]], (5 * horas_dia) - num_dia * horas_dia - horas_dia_restantes);
                precio_total += piezas * precio[arrayNumeros[p]];
            }
        } else {
            if (horas_dia - tiempo_pieza > 0) {
                horas_dia_restantes = horas_dia - tiempo_pieza;
                precio_total += almacen[arrayNumeros[p]] * precio[arrayNumeros[p]];
            } else {
                num_dia++;
                horas_dia_restantes = horas_dia - tiempo_pieza;
                horas_dia_restantes = horas_dia + horas_dia_restantes;
                precio_total += almacen[arrayNumeros[p]] * precio[arrayNumeros[p]];
            }

        }
        p++;
    }
        printf("end planification\n");

}

И вот часть, где у меня есть ошибки. Это когда я пытаюсь напечатать оптимальный массив (если вы прокомментируете эту часть, код работает):

printf("Optimum sequence found\n");
printf("total profit: %d euros", precio);
printf("\n");
for(int k=0; k< sizeof(arrayoptimo)/sizeof(int);k++);
    printf( " %d ", arrayoptimo[k]);

И ошибка:

main.cpp:55: ошибка: поиск имени 'k' изменен для нового ISO 'для'
области видимости main.cpp:54: ошибка: использование устаревшей привязки в 'k'

Я потратил весь свой день, пытаясь исправить код, но это невозможно, и я схожу с ума. Любая помощь очень ценится.