Errore di compilazione per creazione file di testo

di il
11 risposte

Errore di compilazione per creazione file di testo

Buongiorno, sto cercando di imparare ad usare la funzione fopen per la creazione di file di testo, l'IDE che sto utilizzando è Visual Studio 2019 C++. Questo è il codice di prova che ho copiato su un sito:
/*
  Scrive un intero su file
*/

#include<stdlib.h>
#include<stdio.h>

int main() {
  FILE *fd;
  int x=-32;

		/* apre il file in scrittura */
  fd=fopen("scrivi.txt", "w");
  if( fd==NULL ) {
    perror("Errore in apertura del file");
    exit(1);
  }


		/* scrive il numero */
  fprintf(fd, "%d\n", x);


		/* chiude il file */
  fclose(fd);

  return 0;
}
Se tento di fare il debug mi dà il seguente messaggio di errore:
"Errori durante la compilazione. Continuare ad eseguire l'ultima compilazione completata?"

Non riesco a capire dove sia il problema, anche perchè è un codice copiato su un sito per provare la funzione...

Grazie

11 Risposte

  • Re: Errore di compilazione per creazione file di testo

    Basta leggere il warning
    
    	/* apre il file in scrittura */
    	 fopen_s(&fd, "scrivi.txt", "w");
    
    Non riesco a capire dove sia il problema, anche perchè è un codice copiato su un sito per provare la funzione...
    Perché il codice è C e il compilatore che stai usando è C++, inoltre è di Microsoft che fa un po' quello che vuole con il C
  • Re: Errore di compilazione per creazione file di testo

    La fopen è deprecata perché non è sicura e, giustamente, il compilatore ti avvisa invitandoti ad usare la versione sicura.

    Puoi aggirare questo avviso, dato che non è importante in questo momento, aggiungendo dopo le include la linea

    #pragma warning(disable:4996)

    Ovviamente dopo ricompila.
  • Re: Errore di compilazione per creazione file di testo

    Grazie ragazzi, ho provato ad inserire solo la riga suggerita da Oregon, e il programma di test che ho pubblicato qui va bene. Poi ho provato ad usarlo nel programma che mi interessa, scritto in C++, ma continua a dare lo stesso avviso di prima... Nel programma che mi interessa ho messo anche la modifica del codice suggerita da Weierstrass, ma niente
  • Re: Errore di compilazione per creazione file di testo

    Devi scrivere il codice e il messaggio di errore completo...
  • Re: Errore di compilazione per creazione file di testo

    Il codice a cui vorrei usare la funzione è questo:
    // Torx.cpp : Questo file contiene la funzione 'main', in cui inizia e termina l'esecuzione del programma.
    //
    
    #include <cstdlib>
    #include <cstdio>
    #include <iostream>
    #define _USE_MATH_DEFINES
    #include <cmath>
    #include <math.h>
    #include <C:\Users\User\Desktop\Roberto\R-CAM\analisiMatematica.h>
    #pragma warning(disable:4996)
    
    using namespace std;
    
    void polarizzaPunto(bool pianoVista, double* coordinate, double angolo, short int numeroPunti, double* coordinatePolarizzate);
    void creaGeometriaDaPunti(bool pianoVista, bool sensoPolare, bool esistenzaRaccordo, double* coordinatePuntiIniziali, short int numeroCopiePunti, double gradiIncrementali, double* geometria);
    
    int main() {
        //Dichiarazione delle variabili di input
        short int numeroLobi = 6;//Numero dei lati del poligono
        double lobo[3] = { 1.025,0,0.34 };//Dati geometrici del lobo
        double circonferenzaConcava[3] = { 2.350497,0,1.21 };//Dati geometrici della circonferenza concava
        double dGrezzo = 2.75;//Diametro del grezzo
        double coordSup = 0;//Coordinata di superficie in Z o inizio in Z della geometria
        double zEnd = 1.5;//Indica la lunghezza in Z dalla coordinata di superficie (o più semplicemente è l'estrusione della geometria partendo dalla coordinata di superficie)
        short int tool = 37;//Scelta del numero utensile
        double rT = 1.0;//Raggio utensile
        double asseC = 0;//Posizionamento dell'asse C
        double passoZ = 0.06;//Indica il passo in Z che deve avere l'utensile
        double gapSicurezza = 0.7;//Gap di sicurezza (ATTENZIONE: mettere un valore > al diametro utensile di 0.1mm)
        double f = 250;//Avanzamento in lavorazione
        int riduciFile = 100;//Riduce la dimensione del file d'uscita agendo sul feed (mettere 50 se si vuole dimezzare l'avanzamento in lavorazione)
        bool salvataggio = true;//Consente di scegliere se salvare i dati su un file di testo o meno
    
        //Dichiarazione delle variabili di lavoro
        double gradiDalNumeroLobi = 0, zIncr = 0;
        double supportoPunti[24] = {};
        double eq_circonferenza1[5] = {}, eq_circonferenza2[5] = {};
        double eq_retta[3] = {};
        double punti[4] = {};
        double puntiDiContattoUtensile[98] = {};//Vettore di output che può contenere le coordinate di 12 punti
        short int limite = 0, a = 0, b = 0;
        bool verificaRaggioCirconferenzaConcava = false;
        FILE* torxMaschio;//Creazione del puntatore tipo FILE per salvataggio su file di testo
    
        //Input
    /*	cout<<"\tPercorso utensile per torx femmina STRAUMANN";
        cout<<endl<<"Numero lobi: ";
        cin>>numeroLobi;
        cout<<"Le ordinate delle circonferenze lobo e convessa sono sempre 0!";
        cout<<endl<<"Distanza dall'origine del centro della circonferenza lobo: ";
        cin>>lobo[0];
        cout<<"Raggio della circonferenza lobo: ";
        cin>>lobo[2];
        cout<<"Distanza dall'origine del centro della circonferenza concava: ";
        cin>>circonferenzaConcava[0];
        cout<<"Raggio della circonferenza concava: ";
        cin>>circonferenzaConcava[2];
        cout<<"Diametro del grezzo: ";
        cin>>dGrezzo;
        cout<<"Coordinata di superficie: ";
        cin>>coordSup;
        cout<<"Profondita' della geometria torx: ";
        cin>>zEnd;
        cout<<"Numero utensile: ";
        cin>>tool;
        cout<<"Il diametro utensile non va messo qui, ma nei parametri\nutensile del PGM del DECO!"<<endl;
        cout<<"Orientamento della geometria sull'asse C: ";
        cin>>asseC;
        cout<<"Passo in Z: ";
        cin>>passoZ;
        cout<<"Gap di sicurezza (ATTENZIONE: mettere un valore > al diametro utensile utilizzato di 0.1mm): ";
        cin>>gapSicurezza;
        cout<<"Ridurre la dimensione del file agendo sul feed della macchina\n(solo numeri interi)[%]: ";
        cin>>riduciFile;
        cout<<"Avanzamento in lavorazione (tenere conto della voce precedente)[mm/min]: ";
        cin>>f;
        cout<<"Salvare sul desktop in un file di testo? [NO=0; SI=1]: ";
        cin>>salvataggio;*/
    
    
        /*Elaborazione*/
    //ATTENZIONE: impostare nel PGM della STAR #860 = #629
        dGrezzo /= 2;//Raggio del preforo
        dGrezzo += (rT + gapSicurezza);//Primo punto di attacco utensile in zona di sicurezza
        //Primo punto di partenza dell'utensile
        puntiDiContattoUtensile[0] = lobo[0] + lobo[2] + rT;//Ascissa
        puntiDiContattoUtensile[1] = lobo[1];//Ordinata
        //Calcolo del numero di punti che formano il percorso utensile
        limite = numeroLobi * 2;
        //Gradi e bisettrice dal numero lobi
        gradiDalNumeroLobi = 360.0 / numeroLobi;//Gradi
        gradiDalNumeroLobi /= 2.0;//Bisettrice
        //Calcolo del punto di tangenza tra le circonferenze
            //Compensazioni dei raggi utensile
        circonferenzaConcava[2] -= rT;//Compensazione del raggio circonferenzaConcava in base al raggio utensile
        lobo[2] += rT;//Compensazione del raggio lobo in base al raggio utensile
        if (circonferenzaConcava[2] <= 0.0001 && circonferenzaConcava[2] >= -0.0001)
            circonferenzaConcava[2] = 0;
        if (circonferenzaConcava[2] <= 0)
            //Polarizzazione delle coordinate del centro circonferenzaConcava
            polarizzaPunto(false, circonferenzaConcava, gradiDalNumeroLobi, 1, punti);
        else {
            limite *= 2;//Doppio prodotto del numero dei punti che formano il percorso utensile
            limite += 2;//Aggiunta delle coordinate dell'ultimo punto della geometria
            verificaRaggioCirconferenzaConcava = true;//Cambio di stato; indica che l'utensile è più piccolo del raggio circonferenzaConcava
                //Polarizzazione delle coordinate del centro circonferenzaConcava
            polarizzaPunto(false, circonferenzaConcava, gradiDalNumeroLobi, 1, circonferenzaConcava);
            //Calcolo delle equazione delle circonferenze: lobo e convessa
            circonferenza(circonferenzaConcava, eq_circonferenza1);//Equazione circonferenza convessa
            circonferenza(lobo, eq_circonferenza2);//Equazione circonferenza lobo
                //Calcolo asse radicale
            asseRadicaleTraCirconferenze(eq_circonferenza2, eq_circonferenza1, eq_retta);
            //Sistema circonferenza convessa con asse radicale
            sistemaCirconferenzaRetta(eq_circonferenza1, eq_retta, punti);
        }
        puntiDiContattoUtensile[2] = punti[0];//Il vettore della geometria acquisisce l'ascissa del punto P2
        puntiDiContattoUtensile[3] = punti[1];//Il vettore della geometria acquisisce l'ordinata del punto P2
        //Queste 2 celle con coordinate a zero, daranno il limite alla funzione che sarà chiamata dopo
        puntiDiContattoUtensile[4] = 0;//Serve per dare il limite alla funzione successiva
        puntiDiContattoUtensile[5] = 0;//Serve per dare il limite alla funzione successiva
        //Settaggio dei parametri in base al raggio utensile
        gradiDalNumeroLobi *= 2.0;//Ripristino dei gradi in base al numero dei lobi
        creaGeometriaDaPunti(false, false, verificaRaggioCirconferenzaConcava, puntiDiContattoUtensile, numeroLobi - 1, gradiDalNumeroLobi, puntiDiContattoUtensile);
        //Calcolo dei movimenti in Z e profondità d'estrusione della geometria torx
        zIncr = coordSup;//Assegno come valore iniziale della Z incrementale la coordinata di superficie
        zEnd += coordSup;//Calcolo della coordinata Z di arrivo dell'utensile
    
                                //Output
        //Salvataggio dati sul desktop in un file di testo
        if (salvataggio == true) {
            //torxMaschio = fopen("C:\\Users\\ASUS\\Desktop\\Torx maschio.txt", "w");//Apertura del file .doc sul desktop
            fopen_s(&torxMaschio, "C:\\Users\\User\\Desktop\\Torx maschio.txt", "w");//Apertura del file .doc sul desktop
            if (torxMaschio == NULL) {
                perror("Errore in apertura del file");
                exit(1);
            }
        }
    
        cout << endl;
        cout << endl << "M105";//Disattiva la rotazione del mandrino principale
        if (salvataggio == true)
            fprintf(torxMaschio, "M105");//Salvataggio sul file
        cout << endl << "M811";//Attiva rotazione del pneumatico
        if (salvataggio == true)
            fprintf(torxMaschio, "\nM811");//Salvataggio sul file
        cout << endl << "G4 X2";//Sosta di 2 secondi
        if (salvataggio == true)
            fprintf(torxMaschio, "\nG4 X2");//Salvataggio sul file
        cout << endl << "G1 X2=29 Y2=0 G100 T37";//Chiamata del numero utensile con relativo posizionamento rapido in zona XY di sicurezza
        if (salvataggio == true)
            fprintf(torxMaschio, "\nG1 X2=29 Y2=0 G100 T37");//Salvataggio sul file
        cout << endl << "G1 Z2=90 G100";//Posizionamento rapido in zona di sicurezza in Z
        if (salvataggio == true)
            fprintf(torxMaschio, "\nG1 Z2=90 G100");//Salvataggio sul file
        cout << endl << "M119 Q" << asseC;//Orientamento della geometria
        if (salvataggio == true)
            fprintf(torxMaschio, "\nM119 Q%.4lf", asseC);//Salvataggio sul file
        cout << endl << "G902 P1=" << riduciFile;//Comando che riduce la dimensione del file d'uscita
        if (salvataggio == true)
            fprintf(torxMaschio, "\nG902 P1=%d", riduciFile);//Salvataggio sul file
        cout << endl << "G1 Z2=" << coordSup + gapSicurezza << " G100";//Primo posizionamento dell'utensile in Z in zona di sicurezza
        if (salvataggio == true)
            fprintf(torxMaschio, "\nG1 Z2=%.4lf G100", coordSup + gapSicurezza);//Salvataggio sul file
        cout << endl << "G1 X2=" << (dGrezzo * 2.0) << " G100";//Posizionamento rapido in zona di sicurezza in X
        if (salvataggio == true)
            fprintf(torxMaschio, "\nG1 X2=%.4lf G100", (dGrezzo * 2.0));//Salvataggio sul file
        while (zIncr <= zEnd) {
            zIncr += passoZ;//Incremento della Z in base al passo impostato dall'utente
            //Condizione che limita la Z incrementale alla massima profondità
            if (zIncr >= zEnd)
                zIncr = zEnd;
            cout << endl << endl << endl << "G1 Z2=-" << zIncr << " F5000 G94";//Posizionamento dell'utensile in Z
            if (salvataggio == true)
                fprintf(torxMaschio, "\nG1 Z2=-%.4lf F5000 G94", zIncr);//Salvataggio sul file
            for (a = 0; a <= limite; a += 2)
                if (a == 0) {
                    cout << endl << "G1 X2=" << (puntiDiContattoUtensile[a] * 2.0) << " F" << f << " G94 G42";
                    if (salvataggio == true)
                        fprintf(torxMaschio, "\nG1 X2=%.4lf F%.0f G94 G42", puntiDiContattoUtensile[a] * 2.0, f);//Salvataggio sul file
                }
                else
                    if ((a % 4 == 0) && (verificaRaggioCirconferenzaConcava == true)) {
                        b = 2;//Interpolazione circolare concava
                        cout << endl << "G" << b << " X2=" << (puntiDiContattoUtensile[a] * 2.0) << " Y2=" << puntiDiContattoUtensile[a + 1] << " R" << circonferenzaConcava[2];
                        if (salvataggio == true)
                            fprintf(torxMaschio, "\nG%d X2=%.4lf Y2=%.4lf R%.4lf", b, puntiDiContattoUtensile[a] * 2.0, puntiDiContattoUtensile[a + 1], circonferenzaConcava[2]);//Salvataggio sul file
                    }
                    else {
                        b = 3;//Interpolazione circolare convessa
                        if (a == limite) {
                            puntiDiContattoUtensile[a] = puntiDiContattoUtensile[0];//puntiDiContattoUtensile[2]
                            puntiDiContattoUtensile[a + 1] = puntiDiContattoUtensile[1];//puntiDiContattoUtensile[3]
                        }
                        cout << endl << "G" << b << " X2=" << (puntiDiContattoUtensile[a] * 2) << " Y2=" << puntiDiContattoUtensile[a + 1] << " R" << lobo[2];
                        if (salvataggio == true)
                            fprintf(torxMaschio, "\nG%d X2=%.4lf Y2=%.4lf R%.4lf", b, puntiDiContattoUtensile[a] * 2.0, puntiDiContattoUtensile[a + 1], lobo[2]);//Salvataggio sul file
                    }
            cout << endl << "G1 Y2=" << puntiDiContattoUtensile[3];//Posizionamento rapido in Y0 dell'utensile in zona di sicurezza
            if (salvataggio == true)
                fprintf(torxMaschio, "\nG1 Y2=%.4lf", puntiDiContattoUtensile[3]);//Salvataggio sul file
            cout << endl << "G1 X2=" << dGrezzo * 2.0 << " F5000 G94";//Posizionamento rapido in X dell'utensile in zona di sicurezza
            if (salvataggio == true)
                fprintf(torxMaschio, "\nG1 X2=%.4lf F5000 G94", (dGrezzo * 2.0));//Salvataggio sul file
            cout << endl << "G40";//Annullamento compensazione automatica
            if (salvataggio == true)
                fprintf(torxMaschio, "\nG40");//Salvataggio sul file
            cout << endl << "G1 Y2=0 G100";//Posizionamento rapido in Y0 dell'utensile in zona di sicurezza
            if (salvataggio == true)
                fprintf(torxMaschio, "\nG1 Y2=0 G100");//Salvataggio sul file
                //Condizione che interrompe il ciclo ed esce
            if (zIncr == zEnd)
                break;
        }
        cout << endl << "G902";//Disattiva il codice G902 iniziale
        if (salvataggio == true)
            fprintf(torxMaschio, "\nG902");//Salvataggio sul file
    /*    cout<<endl<<"G1 Y2=0 G100";//Posizionamento rapido in Y0 dell'utensile in zona di sicurezza
        if(salvataggio == true)
            fprintf(torxMaschio,"\nG1 Y2=0 G100");//Salvataggio sul file
        cout<<endl<<"G1 X2=29 G100";//Svincolo dell'utensile in Z
        if(salvataggio == true)
            fprintf(torxMaschio,"\nG1 X2=29 G100");//Salvataggio sul file*/
        cout << endl << "G1 Z2=90 G100";//Svincolo dell'utensile in Z
        if (salvataggio == true)
            fprintf(torxMaschio, "\nG1 Z2=90 G100");//Salvataggio sul file
        cout << endl << "M812";//Disattiva la rotazione del pneumatico
        if (salvataggio == true)
            fprintf(torxMaschio, "\nM812");//Salvataggio sul file
    
        if (salvataggio == true) {
            fclose(torxMaschio);//Chiusura del file di testo di salvataggio
            cout << endl << endl << endl << "File di testo salvato sul desktop...";
        }
    
        fflush(stdin);
        getchar();
        return 0;
    }
    
    /*Funzione che crea un pattern in un vettore di punti formando una geometria.
    Parametri:
        -pianoVista-> seleziona il piano di lavoro su cui giace la geometria:
            false = XY, YZ;
            true = XZ;
        -sensoPolare:
            false = le coordinate dei punti sono sistemati nel vettore in senso antiorario;
            true = le coordinate dei punti sono sistemati nel vettore in senso orario;
        -esistenzaRaccordo-> in realtà indica alla funzione se la figura è formata dal doppio dei punti nel caso in cui per esempio
                            il raggio utensile è >= ad un raccordo o ad una circonferenza concava:
            false = indica che il raccordo non c'è (il raggio utensile è >= al raccordo o a circonferenza concava);
            true = indica che il raccordo c'è;
        -coordinatePuntiIniziali-> indica i punti da cui partire per formare il pattern geometrico;
                                IMPORTANTE: dopo l'ultimo punto, dare al punto successivo le coordinate (0;0), questo per dare un limite alla funzione;
        -numeroCopiePunti-> indica quante copie dei punti messi devono essere fatti, ricordarsi di mettere il numero esatto meno 1, che compone la geometria:
                            per esempio per un esagono: 6 - 1;
        -gradiIncrementali-> gradi incrementali usati per polarizzare i punti iniziali (Valori in gradi sempre maggiori di zero):
                            per esempio per un esagono: 60°;
        -geometria-> vettore di output che contiene le coordinate dei punti di costruzione della geometria.*/
    void creaGeometriaDaPunti(bool pianoVista, bool sensoPolare, bool esistenzaRaccordo, double* coordinatePuntiIniziali, short int numeroCopiePunti, double gradiIncrementali, double* geometria) {
        //Dichiarazione delle variabili locali
        double datiDiInput[10] = {};//datiDiInput == coordinatePuntiIniziali
        short int contatoreCelle = 2;//Contatore di posizionamento celle
        short int numeroPuntiIniziali = 0;//Contatore dei numero di punti iniziali che formano la geometria
        short int selezionaPunto = 0;//Posizione della cella da passare alla funzione polarizzaPunto per il calcolo dei punti
        double punto[2] = {};
        //Elaborazione
        while (coordinatePuntiIniziali[contatoreCelle] != 0 && coordinatePuntiIniziali[contatoreCelle + 1] != 0) {
            datiDiInput[contatoreCelle] = coordinatePuntiIniziali[contatoreCelle];
            datiDiInput[contatoreCelle + 1] = coordinatePuntiIniziali[contatoreCelle + 1];
            numeroPuntiIniziali++;
            contatoreCelle += 2;
        }
        if (sensoPolare == true)
            gradiIncrementali = -gradiIncrementali;
        selezionaPunto = numeroPuntiIniziali * 2;//Calcolo delle posizioni
        numeroCopiePunti++;//Incremento unario del numero delle copie dei punti iniziali inseriti
        numeroCopiePunti *= 2;//Doppio prodotto del numero di celle perchè ogni punto è definito da 2 valori
        if (esistenzaRaccordo == true)
            numeroCopiePunti *= selezionaPunto;//Nel caso in cui esiste un raccordo tra 2 punti
        selezionaPunto = -selezionaPunto;//Calcolo delle posizioni
        for (contatoreCelle = 2; contatoreCelle <= numeroCopiePunti; contatoreCelle += 2)
            if (contatoreCelle <= (numeroPuntiIniziali * 2)) {
                geometria[contatoreCelle] = datiDiInput[contatoreCelle];//Assegnazione ascissa dei primi punti della geometria
                if (sensoPolare == false)
                    geometria[contatoreCelle + 1] = datiDiInput[contatoreCelle + 1];//Assegnazione ordinata dei primi punti della geometria
                else
                    geometria[contatoreCelle + 1] = -datiDiInput[contatoreCelle + 1];//Assegnazione ordinata dei primi punti della geometria
            }
            else {
                if (esistenzaRaccordo == true)
                    if (selezionaPunto < 0) {
                        selezionaPunto = -selezionaPunto;//Cambio di segno
                        punto[0] = datiDiInput[selezionaPunto];
                        if (sensoPolare == false)
                            punto[1] = -datiDiInput[selezionaPunto + 1];
                        else
                            punto[1] = datiDiInput[selezionaPunto + 1];
                        selezionaPunto = -selezionaPunto;//Ripristino del segno originario
                    }
                    else {
                        punto[0] = geometria[selezionaPunto];
                        punto[1] = geometria[selezionaPunto + 1];
                    }
                else {
                    punto[0] = geometria[contatoreCelle - 2];
                    punto[1] = geometria[contatoreCelle - 1];
                }
                polarizzaPunto(pianoVista, punto, gradiIncrementali, 1, punto);
                geometria[contatoreCelle] = punto[0];//Assegnazione nel vettore geometrico del valore ascissa calcolato
                geometria[contatoreCelle + 1] = punto[1];//Assegnazione nel vettore geometrico del valore ordinata calcolato
                if (esistenzaRaccordo == true) {
                    selezionaPunto += 2;//Doppio incremento del selezionatore punto
                    if (selezionaPunto == 0)
                        selezionaPunto = 2;//Nuova inizializzazione
                }
            }
    }
    
    /*Funzione--> che restituisce le coordinate dei punti polari di un punto.*/
    void polarizzaPunto(bool pianoVista, double* coordinate, double angolo, short int numeroPunti, double* coordinatePolarizzate) {
        short int contatorePosizionePunto = 1;
        double ascissa = 0, ordinata = 0;
        double distanzaOrigine = 0;
        double teta = 0;
        //Elaborazione
        ascissa = coordinate[0];
        ordinata = coordinate[1];
        angolo = radianti(angolo);
        distanzaOrigine = teoremaPitagora(true, ascissa, ordinata);//Calcolo della distanza del punto dall'origine
        if (ascissa == 0) {
            if (pianoVista == false) {
                if (ordinata > 0)
                    teta = M_PI * 0.5;//90°
                else
                    teta = M_PI * 1.5;//270°
            }
            else {
                if (ordinata > 0)
                    teta = 0;//0°
                else
                    teta = M_PI;//180°
            }
        }
        else {
            teta = ordinata / ascissa;//Calcolo dell'angolo che forma la retta OriginePunto rispetto all'ascissa
            teta = atan(teta);
            if (pianoVista == false) {
                if (ascissa < 0)
                    teta = M_PI + teta;//180°+teta
            }
            else {
                if (ascissa > 0)
                    teta = (M_PI * 0.5) - teta;//90°-teta
                else
                    teta = (M_PI * 1.5) - teta;//270°-teta
            }
        }
        for (short int i = 0; i < (numeroPunti * 2); i++) {
            if (i % 2 == 0) {//Calcolo del valore dell'ascissa
                if (i >= 2) {
                    contatorePosizionePunto++;
                    angolo *= contatorePosizionePunto;
                }
                angolo += teta;//Incremento dell'angolo teta dell'angolo inserito
                if (pianoVista == false)
                    coordinatePolarizzate[i] = distanzaOrigine * cos(angolo);
                else
                    coordinatePolarizzate[i] = distanzaOrigine * sin(angolo);
            }
            else {//Calcolo del valore dell'ordinata
                if (pianoVista == false)
                    coordinatePolarizzate[i] = distanzaOrigine * sin(angolo);
                else
                    coordinatePolarizzate[i] = distanzaOrigine * cos(angolo);
                angolo -= teta;//Decremento dell'angolo teta dell'angolo inserito
                if (i >= 3)
                    angolo /= contatorePosizionePunto;
            }
            if (coordinatePolarizzate[i] <= 0.0001 && coordinatePolarizzate[i] >= -0.0001)
                coordinatePolarizzate[i] = 0;
        }
    }
    
    Ed il messaggio d'errore è sempre lo stesso:
    "Errori durante la compilazione. Continuare ad eseguire l'ultima compilazione completata?"
  • Re: Errore di compilazione per creazione file di testo

    Quella è la MessageBox. Clicca "No" e vai a vedere gli errori nella finestra "Elenco Errori"

    Manca il main(). Poi non mettere gli header guard dentro i sorgenti. Studia un pochino le basi prima, non fare mischioni
  • Re: Errore di compilazione per creazione file di testo

    Ho pubblicato la libreria che utilizzo, ho sbagliato, il codice è questo:
    // Torx.cpp : Questo file contiene la funzione 'main', in cui inizia e termina l'esecuzione del programma.
    //
    
    #include <cstdlib>
    #include <cstdio>
    #include <iostream>
    #define _USE_MATH_DEFINES
    #include <cmath>
    #include <math.h>
    #include <C:\Users\User\Desktop\Roberto\R-CAM\analisiMatematica.h>
    #pragma warning(disable:4996)
    
    using namespace std;
    
    void polarizzaPunto(bool pianoVista, double* coordinate, double angolo, short int numeroPunti, double* coordinatePolarizzate);
    void creaGeometriaDaPunti(bool pianoVista, bool sensoPolare, bool esistenzaRaccordo, double* coordinatePuntiIniziali, short int numeroCopiePunti, double gradiIncrementali, double* geometria);
    
    int main() {
        //Dichiarazione delle variabili di input
        short int numeroLobi = 6;//Numero dei lati del poligono
        double lobo[3] = { 1.025,0,0.34 };//Dati geometrici del lobo
        double circonferenzaConcava[3] = { 2.350497,0,1.21 };//Dati geometrici della circonferenza concava
        double dGrezzo = 2.75;//Diametro del grezzo
        double coordSup = 0;//Coordinata di superficie in Z o inizio in Z della geometria
        double zEnd = 1.5;//Indica la lunghezza in Z dalla coordinata di superficie (o più semplicemente è l'estrusione della geometria partendo dalla coordinata di superficie)
        short int tool = 37;//Scelta del numero utensile
        double rT = 1.0;//Raggio utensile
        double asseC = 0;//Posizionamento dell'asse C
        double passoZ = 0.06;//Indica il passo in Z che deve avere l'utensile
        double gapSicurezza = 0.7;//Gap di sicurezza (ATTENZIONE: mettere un valore > al diametro utensile di 0.1mm)
        double f = 250;//Avanzamento in lavorazione
        int riduciFile = 100;//Riduce la dimensione del file d'uscita agendo sul feed (mettere 50 se si vuole dimezzare l'avanzamento in lavorazione)
        bool salvataggio = true;//Consente di scegliere se salvare i dati su un file di testo o meno
    
        //Dichiarazione delle variabili di lavoro
        double gradiDalNumeroLobi = 0, zIncr = 0;
        double supportoPunti[24] = {};
        double eq_circonferenza1[5] = {}, eq_circonferenza2[5] = {};
        double eq_retta[3] = {};
        double punti[4] = {};
        double puntiDiContattoUtensile[98] = {};//Vettore di output che può contenere le coordinate di 12 punti
        short int limite = 0, a = 0, b = 0;
        bool verificaRaggioCirconferenzaConcava = false;
        FILE* torxMaschio;//Creazione del puntatore tipo FILE per salvataggio su file di testo
    
        //Input
    /*	cout<<"\tPercorso utensile per torx femmina STRAUMANN";
        cout<<endl<<"Numero lobi: ";
        cin>>numeroLobi;
        cout<<"Le ordinate delle circonferenze lobo e convessa sono sempre 0!";
        cout<<endl<<"Distanza dall'origine del centro della circonferenza lobo: ";
        cin>>lobo[0];
        cout<<"Raggio della circonferenza lobo: ";
        cin>>lobo[2];
        cout<<"Distanza dall'origine del centro della circonferenza concava: ";
        cin>>circonferenzaConcava[0];
        cout<<"Raggio della circonferenza concava: ";
        cin>>circonferenzaConcava[2];
        cout<<"Diametro del grezzo: ";
        cin>>dGrezzo;
        cout<<"Coordinata di superficie: ";
        cin>>coordSup;
        cout<<"Profondita' della geometria torx: ";
        cin>>zEnd;
        cout<<"Numero utensile: ";
        cin>>tool;
        cout<<"Il diametro utensile non va messo qui, ma nei parametri\nutensile del PGM del DECO!"<<endl;
        cout<<"Orientamento della geometria sull'asse C: ";
        cin>>asseC;
        cout<<"Passo in Z: ";
        cin>>passoZ;
        cout<<"Gap di sicurezza (ATTENZIONE: mettere un valore > al diametro utensile utilizzato di 0.1mm): ";
        cin>>gapSicurezza;
        cout<<"Ridurre la dimensione del file agendo sul feed della macchina\n(solo numeri interi)[%]: ";
        cin>>riduciFile;
        cout<<"Avanzamento in lavorazione (tenere conto della voce precedente)[mm/min]: ";
        cin>>f;
        cout<<"Salvare sul desktop in un file di testo? [NO=0; SI=1]: ";
        cin>>salvataggio;*/
    
    
        /*Elaborazione*/
    //ATTENZIONE: impostare nel PGM della STAR #860 = #629
        dGrezzo /= 2;//Raggio del preforo
        dGrezzo += (rT + gapSicurezza);//Primo punto di attacco utensile in zona di sicurezza
        //Primo punto di partenza dell'utensile
        puntiDiContattoUtensile[0] = lobo[0] + lobo[2] + rT;//Ascissa
        puntiDiContattoUtensile[1] = lobo[1];//Ordinata
        //Calcolo del numero di punti che formano il percorso utensile
        limite = numeroLobi * 2;
        //Gradi e bisettrice dal numero lobi
        gradiDalNumeroLobi = 360.0 / numeroLobi;//Gradi
        gradiDalNumeroLobi /= 2.0;//Bisettrice
        //Calcolo del punto di tangenza tra le circonferenze
            //Compensazioni dei raggi utensile
        circonferenzaConcava[2] -= rT;//Compensazione del raggio circonferenzaConcava in base al raggio utensile
        lobo[2] += rT;//Compensazione del raggio lobo in base al raggio utensile
        if (circonferenzaConcava[2] <= 0.0001 && circonferenzaConcava[2] >= -0.0001)
            circonferenzaConcava[2] = 0;
        if (circonferenzaConcava[2] <= 0)
            //Polarizzazione delle coordinate del centro circonferenzaConcava
            polarizzaPunto(false, circonferenzaConcava, gradiDalNumeroLobi, 1, punti);
        else {
            limite *= 2;//Doppio prodotto del numero dei punti che formano il percorso utensile
            limite += 2;//Aggiunta delle coordinate dell'ultimo punto della geometria
            verificaRaggioCirconferenzaConcava = true;//Cambio di stato; indica che l'utensile è più piccolo del raggio circonferenzaConcava
                //Polarizzazione delle coordinate del centro circonferenzaConcava
            polarizzaPunto(false, circonferenzaConcava, gradiDalNumeroLobi, 1, circonferenzaConcava);
            //Calcolo delle equazione delle circonferenze: lobo e convessa
            circonferenza(circonferenzaConcava, eq_circonferenza1);//Equazione circonferenza convessa
            circonferenza(lobo, eq_circonferenza2);//Equazione circonferenza lobo
                //Calcolo asse radicale
            asseRadicaleTraCirconferenze(eq_circonferenza2, eq_circonferenza1, eq_retta);
            //Sistema circonferenza convessa con asse radicale
            sistemaCirconferenzaRetta(eq_circonferenza1, eq_retta, punti);
        }
        puntiDiContattoUtensile[2] = punti[0];//Il vettore della geometria acquisisce l'ascissa del punto P2
        puntiDiContattoUtensile[3] = punti[1];//Il vettore della geometria acquisisce l'ordinata del punto P2
        //Queste 2 celle con coordinate a zero, daranno il limite alla funzione che sarà chiamata dopo
        puntiDiContattoUtensile[4] = 0;//Serve per dare il limite alla funzione successiva
        puntiDiContattoUtensile[5] = 0;//Serve per dare il limite alla funzione successiva
        //Settaggio dei parametri in base al raggio utensile
        gradiDalNumeroLobi *= 2.0;//Ripristino dei gradi in base al numero dei lobi
        creaGeometriaDaPunti(false, false, verificaRaggioCirconferenzaConcava, puntiDiContattoUtensile, numeroLobi - 1, gradiDalNumeroLobi, puntiDiContattoUtensile);
        //Calcolo dei movimenti in Z e profondità d'estrusione della geometria torx
        zIncr = coordSup;//Assegno come valore iniziale della Z incrementale la coordinata di superficie
        zEnd += coordSup;//Calcolo della coordinata Z di arrivo dell'utensile
    
                                //Output
        //Salvataggio dati sul desktop in un file di testo
        if (salvataggio == true) {
            //torxMaschio = fopen("C:\\Users\\ASUS\\Desktop\\Torx maschio.txt", "w");//Apertura del file .doc sul desktop
            fopen_s(&torxMaschio, "C:\\Users\\User\\Desktop\\Torx maschio.txt", "w");//Apertura del file .doc sul desktop
            if (torxMaschio == NULL) {
                perror("Errore in apertura del file");
                exit(1);
            }
        }
    
        cout << endl;
        cout << endl << "M105";//Disattiva la rotazione del mandrino principale
        if (salvataggio == true)
            fprintf(torxMaschio, "M105");//Salvataggio sul file
        cout << endl << "M811";//Attiva rotazione del pneumatico
        if (salvataggio == true)
            fprintf(torxMaschio, "\nM811");//Salvataggio sul file
        cout << endl << "G4 X2";//Sosta di 2 secondi
        if (salvataggio == true)
            fprintf(torxMaschio, "\nG4 X2");//Salvataggio sul file
        cout << endl << "G1 X2=29 Y2=0 G100 T37";//Chiamata del numero utensile con relativo posizionamento rapido in zona XY di sicurezza
        if (salvataggio == true)
            fprintf(torxMaschio, "\nG1 X2=29 Y2=0 G100 T37");//Salvataggio sul file
        cout << endl << "G1 Z2=90 G100";//Posizionamento rapido in zona di sicurezza in Z
        if (salvataggio == true)
            fprintf(torxMaschio, "\nG1 Z2=90 G100");//Salvataggio sul file
        cout << endl << "M119 Q" << asseC;//Orientamento della geometria
        if (salvataggio == true)
            fprintf(torxMaschio, "\nM119 Q%.4lf", asseC);//Salvataggio sul file
        cout << endl << "G902 P1=" << riduciFile;//Comando che riduce la dimensione del file d'uscita
        if (salvataggio == true)
            fprintf(torxMaschio, "\nG902 P1=%d", riduciFile);//Salvataggio sul file
        cout << endl << "G1 Z2=" << coordSup + gapSicurezza << " G100";//Primo posizionamento dell'utensile in Z in zona di sicurezza
        if (salvataggio == true)
            fprintf(torxMaschio, "\nG1 Z2=%.4lf G100", coordSup + gapSicurezza);//Salvataggio sul file
        cout << endl << "G1 X2=" << (dGrezzo * 2.0) << " G100";//Posizionamento rapido in zona di sicurezza in X
        if (salvataggio == true)
            fprintf(torxMaschio, "\nG1 X2=%.4lf G100", (dGrezzo * 2.0));//Salvataggio sul file
        while (zIncr <= zEnd) {
            zIncr += passoZ;//Incremento della Z in base al passo impostato dall'utente
            //Condizione che limita la Z incrementale alla massima profondità
            if (zIncr >= zEnd)
                zIncr = zEnd;
            cout << endl << endl << endl << "G1 Z2=-" << zIncr << " F5000 G94";//Posizionamento dell'utensile in Z
            if (salvataggio == true)
                fprintf(torxMaschio, "\nG1 Z2=-%.4lf F5000 G94", zIncr);//Salvataggio sul file
            for (a = 0; a <= limite; a += 2)
                if (a == 0) {
                    cout << endl << "G1 X2=" << (puntiDiContattoUtensile[a] * 2.0) << " F" << f << " G94 G42";
                    if (salvataggio == true)
                        fprintf(torxMaschio, "\nG1 X2=%.4lf F%.0f G94 G42", puntiDiContattoUtensile[a] * 2.0, f);//Salvataggio sul file
                }
                else
                    if ((a % 4 == 0) && (verificaRaggioCirconferenzaConcava == true)) {
                        b = 2;//Interpolazione circolare concava
                        cout << endl << "G" << b << " X2=" << (puntiDiContattoUtensile[a] * 2.0) << " Y2=" << puntiDiContattoUtensile[a + 1] << " R" << circonferenzaConcava[2];
                        if (salvataggio == true)
                            fprintf(torxMaschio, "\nG%d X2=%.4lf Y2=%.4lf R%.4lf", b, puntiDiContattoUtensile[a] * 2.0, puntiDiContattoUtensile[a + 1], circonferenzaConcava[2]);//Salvataggio sul file
                    }
                    else {
                        b = 3;//Interpolazione circolare convessa
                        if (a == limite) {
                            puntiDiContattoUtensile[a] = puntiDiContattoUtensile[0];//puntiDiContattoUtensile[2]
                            puntiDiContattoUtensile[a + 1] = puntiDiContattoUtensile[1];//puntiDiContattoUtensile[3]
                        }
                        cout << endl << "G" << b << " X2=" << (puntiDiContattoUtensile[a] * 2) << " Y2=" << puntiDiContattoUtensile[a + 1] << " R" << lobo[2];
                        if (salvataggio == true)
                            fprintf(torxMaschio, "\nG%d X2=%.4lf Y2=%.4lf R%.4lf", b, puntiDiContattoUtensile[a] * 2.0, puntiDiContattoUtensile[a + 1], lobo[2]);//Salvataggio sul file
                    }
            cout << endl << "G1 Y2=" << puntiDiContattoUtensile[3];//Posizionamento rapido in Y0 dell'utensile in zona di sicurezza
            if (salvataggio == true)
                fprintf(torxMaschio, "\nG1 Y2=%.4lf", puntiDiContattoUtensile[3]);//Salvataggio sul file
            cout << endl << "G1 X2=" << dGrezzo * 2.0 << " F5000 G94";//Posizionamento rapido in X dell'utensile in zona di sicurezza
            if (salvataggio == true)
                fprintf(torxMaschio, "\nG1 X2=%.4lf F5000 G94", (dGrezzo * 2.0));//Salvataggio sul file
            cout << endl << "G40";//Annullamento compensazione automatica
            if (salvataggio == true)
                fprintf(torxMaschio, "\nG40");//Salvataggio sul file
            cout << endl << "G1 Y2=0 G100";//Posizionamento rapido in Y0 dell'utensile in zona di sicurezza
            if (salvataggio == true)
                fprintf(torxMaschio, "\nG1 Y2=0 G100");//Salvataggio sul file
                //Condizione che interrompe il ciclo ed esce
            if (zIncr == zEnd)
                break;
        }
        cout << endl << "G902";//Disattiva il codice G902 iniziale
        if (salvataggio == true)
            fprintf(torxMaschio, "\nG902");//Salvataggio sul file
    /*    cout<<endl<<"G1 Y2=0 G100";//Posizionamento rapido in Y0 dell'utensile in zona di sicurezza
        if(salvataggio == true)
            fprintf(torxMaschio,"\nG1 Y2=0 G100");//Salvataggio sul file
        cout<<endl<<"G1 X2=29 G100";//Svincolo dell'utensile in Z
        if(salvataggio == true)
            fprintf(torxMaschio,"\nG1 X2=29 G100");//Salvataggio sul file*/
        cout << endl << "G1 Z2=90 G100";//Svincolo dell'utensile in Z
        if (salvataggio == true)
            fprintf(torxMaschio, "\nG1 Z2=90 G100");//Salvataggio sul file
        cout << endl << "M812";//Disattiva la rotazione del pneumatico
        if (salvataggio == true)
            fprintf(torxMaschio, "\nM812");//Salvataggio sul file
    
        if (salvataggio == true) {
            fclose(torxMaschio);//Chiusura del file di testo di salvataggio
            cout << endl << endl << endl << "File di testo salvato sul desktop...";
        }
    
        fflush(stdin);
        getchar();
        return 0;
    }
    
    /*Funzione che crea un pattern in un vettore di punti formando una geometria.
    Parametri:
        -pianoVista-> seleziona il piano di lavoro su cui giace la geometria:
            false = XY, YZ;
            true = XZ;
        -sensoPolare:
            false = le coordinate dei punti sono sistemati nel vettore in senso antiorario;
            true = le coordinate dei punti sono sistemati nel vettore in senso orario;
        -esistenzaRaccordo-> in realtà indica alla funzione se la figura è formata dal doppio dei punti nel caso in cui per esempio
                            il raggio utensile è >= ad un raccordo o ad una circonferenza concava:
            false = indica che il raccordo non c'è (il raggio utensile è >= al raccordo o a circonferenza concava);
            true = indica che il raccordo c'è;
        -coordinatePuntiIniziali-> indica i punti da cui partire per formare il pattern geometrico;
                                IMPORTANTE: dopo l'ultimo punto, dare al punto successivo le coordinate (0;0), questo per dare un limite alla funzione;
        -numeroCopiePunti-> indica quante copie dei punti messi devono essere fatti, ricordarsi di mettere il numero esatto meno 1, che compone la geometria:
                            per esempio per un esagono: 6 - 1;
        -gradiIncrementali-> gradi incrementali usati per polarizzare i punti iniziali (Valori in gradi sempre maggiori di zero):
                            per esempio per un esagono: 60°;
        -geometria-> vettore di output che contiene le coordinate dei punti di costruzione della geometria.*/
    void creaGeometriaDaPunti(bool pianoVista, bool sensoPolare, bool esistenzaRaccordo, double* coordinatePuntiIniziali, short int numeroCopiePunti, double gradiIncrementali, double* geometria) {
        //Dichiarazione delle variabili locali
        double datiDiInput[10] = {};//datiDiInput == coordinatePuntiIniziali
        short int contatoreCelle = 2;//Contatore di posizionamento celle
        short int numeroPuntiIniziali = 0;//Contatore dei numero di punti iniziali che formano la geometria
        short int selezionaPunto = 0;//Posizione della cella da passare alla funzione polarizzaPunto per il calcolo dei punti
        double punto[2] = {};
        //Elaborazione
        while (coordinatePuntiIniziali[contatoreCelle] != 0 && coordinatePuntiIniziali[contatoreCelle + 1] != 0) {
            datiDiInput[contatoreCelle] = coordinatePuntiIniziali[contatoreCelle];
            datiDiInput[contatoreCelle + 1] = coordinatePuntiIniziali[contatoreCelle + 1];
            numeroPuntiIniziali++;
            contatoreCelle += 2;
        }
        if (sensoPolare == true)
            gradiIncrementali = -gradiIncrementali;
        selezionaPunto = numeroPuntiIniziali * 2;//Calcolo delle posizioni
        numeroCopiePunti++;//Incremento unario del numero delle copie dei punti iniziali inseriti
        numeroCopiePunti *= 2;//Doppio prodotto del numero di celle perchè ogni punto è definito da 2 valori
        if (esistenzaRaccordo == true)
            numeroCopiePunti *= selezionaPunto;//Nel caso in cui esiste un raccordo tra 2 punti
        selezionaPunto = -selezionaPunto;//Calcolo delle posizioni
        for (contatoreCelle = 2; contatoreCelle <= numeroCopiePunti; contatoreCelle += 2)
            if (contatoreCelle <= (numeroPuntiIniziali * 2)) {
                geometria[contatoreCelle] = datiDiInput[contatoreCelle];//Assegnazione ascissa dei primi punti della geometria
                if (sensoPolare == false)
                    geometria[contatoreCelle + 1] = datiDiInput[contatoreCelle + 1];//Assegnazione ordinata dei primi punti della geometria
                else
                    geometria[contatoreCelle + 1] = -datiDiInput[contatoreCelle + 1];//Assegnazione ordinata dei primi punti della geometria
            }
            else {
                if (esistenzaRaccordo == true)
                    if (selezionaPunto < 0) {
                        selezionaPunto = -selezionaPunto;//Cambio di segno
                        punto[0] = datiDiInput[selezionaPunto];
                        if (sensoPolare == false)
                            punto[1] = -datiDiInput[selezionaPunto + 1];
                        else
                            punto[1] = datiDiInput[selezionaPunto + 1];
                        selezionaPunto = -selezionaPunto;//Ripristino del segno originario
                    }
                    else {
                        punto[0] = geometria[selezionaPunto];
                        punto[1] = geometria[selezionaPunto + 1];
                    }
                else {
                    punto[0] = geometria[contatoreCelle - 2];
                    punto[1] = geometria[contatoreCelle - 1];
                }
                polarizzaPunto(pianoVista, punto, gradiIncrementali, 1, punto);
                geometria[contatoreCelle] = punto[0];//Assegnazione nel vettore geometrico del valore ascissa calcolato
                geometria[contatoreCelle + 1] = punto[1];//Assegnazione nel vettore geometrico del valore ordinata calcolato
                if (esistenzaRaccordo == true) {
                    selezionaPunto += 2;//Doppio incremento del selezionatore punto
                    if (selezionaPunto == 0)
                        selezionaPunto = 2;//Nuova inizializzazione
                }
            }
    }
    
    /*Funzione--> che restituisce le coordinate dei punti polari di un punto.*/
    void polarizzaPunto(bool pianoVista, double* coordinate, double angolo, short int numeroPunti, double* coordinatePolarizzate) {
        short int contatorePosizionePunto = 1;
        double ascissa = 0, ordinata = 0;
        double distanzaOrigine = 0;
        double teta = 0;
        //Elaborazione
        ascissa = coordinate[0];
        ordinata = coordinate[1];
        angolo = radianti(angolo);
        distanzaOrigine = teoremaPitagora(true, ascissa, ordinata);//Calcolo della distanza del punto dall'origine
        if (ascissa == 0) {
            if (pianoVista == false) {
                if (ordinata > 0)
                    teta = M_PI * 0.5;//90°
                else
                    teta = M_PI * 1.5;//270°
            }
            else {
                if (ordinata > 0)
                    teta = 0;//0°
                else
                    teta = M_PI;//180°
            }
        }
        else {
            teta = ordinata / ascissa;//Calcolo dell'angolo che forma la retta OriginePunto rispetto all'ascissa
            teta = atan(teta);
            if (pianoVista == false) {
                if (ascissa < 0)
                    teta = M_PI + teta;//180°+teta
            }
            else {
                if (ascissa > 0)
                    teta = (M_PI * 0.5) - teta;//90°-teta
                else
                    teta = (M_PI * 1.5) - teta;//270°-teta
            }
        }
        for (short int i = 0; i < (numeroPunti * 2); i++) {
            if (i % 2 == 0) {//Calcolo del valore dell'ascissa
                if (i >= 2) {
                    contatorePosizionePunto++;
                    angolo *= contatorePosizionePunto;
                }
                angolo += teta;//Incremento dell'angolo teta dell'angolo inserito
                if (pianoVista == false)
                    coordinatePolarizzate[i] = distanzaOrigine * cos(angolo);
                else
                    coordinatePolarizzate[i] = distanzaOrigine * sin(angolo);
            }
            else {//Calcolo del valore dell'ordinata
                if (pianoVista == false)
                    coordinatePolarizzate[i] = distanzaOrigine * sin(angolo);
                else
                    coordinatePolarizzate[i] = distanzaOrigine * cos(angolo);
                angolo -= teta;//Decremento dell'angolo teta dell'angolo inserito
                if (i >= 3)
                    angolo /= contatorePosizionePunto;
            }
            if (coordinatePolarizzate[i] <= 0.0001 && coordinatePolarizzate[i] >= -0.0001)
                coordinatePolarizzate[i] = 0;
        }
    }
    
    Il messaggio di errore è:
    "C4703 Utilizzata variabile puntatore locale non inizializzata 'torxMaschio' "
  • Re: Errore di compilazione per creazione file di testo

    Non sovrascrivere i vecchi post, che non si capisce nulla


    Così compila - te lo divido in due parti perché c'è il limite di caratteri

    Parte 1
    
    //Librerie
    #include <cstdlib>
    #include <cstdio>
    #include <iostream>
    #define _USE_MATH_DEFINES
    #include <cmath>
    #include <cstring>
    
    //Costanti
    #define M_PI 3.1415926535897932384626433832795028841971694
    
    //Dichiarazione degli spazi di lavoro
    using namespace std;
    
    //Dichiarazione dei records:
    typedef struct punto {
        double asc;//Ascissa del punto
        double ord;//Ordinata del punto
    } Tpunto;
    
    typedef struct pianoCartesiano {
        bool vista;//False: XY o YZ; True: XZ
        Tpunto O;//Coordinate dell'origine del piano attivo, rispetto all'origine assoluto
    } TpianoCartesiano;
    
    typedef struct circonferenza {
        Tpunto centro;//Coordinate del centro
        double raggio;//Raggio
        double eq[5];//Equazione implicita della circonferenza: eq[4]=x^2 + eq[3]=y^2 + eq[2]=ax + eq[1]=by + eq[0]=c = 0;
    } Tcirconferenza;
    
    //Dichiarazione dei prototipi di funzione:
    void azzeraVettore(short int lengthVettore, double* array);//Equivalente al pgm della Star O6020
    double radianti(double gradi);
    double gradi(double radianti);
    double teoremaPitagora(bool ipotenusa_cateto, double a, double b);//Equivalente al pgm della Star O6000
    double gradiTraDueLatiPoligono(short int numeroLatiPoligono);//Equivalente al pgm della Star O6001
    double lunghezzaIpotenusaDaGradi_catetOrizzontale(double gradi, double misuraCatetOrizzontale);//Equivalente al pgm della Star O6002
    double lunghezzaCatetoVerticaleDaGradiEipotenusa(double gradi, double misuraIpotenusa);//Equivalente al pgm della Star O6003
    double lunghezzaCatetOrizzontaleDaGradiEipotenusa(double gradi, double misuraIpotenusa);//Equivalente al pgm della Star O6004
    double gradiDaCoordinatePunto(bool pianoVista, double* coordinatePunto);//Equivalente al pgm della Star O6005
    void duplicPolarPoint(bool pianoVista, Tpunto piano, Tpunto p, bool tieniPuntoRiferimento, double gradi, short int numPunti, Tpunto* punti);//Equivalente al pgm della Star O6006
    void fascioRetta(bool pianoVista, double* datiRetta, double* eq_FascioDiRette);//Equivalente al pgm della Star O6007
    void rettaDuePunti(double* coordinatePunti, double* eq_Retta);//Equivalente al pgm della Star O6008
    void intersezioneRette(double* eq_primaRetta, double* eq_secondaRetta, Tpunto& p);//Equivalente al pgm della Star O6009
    void circonferenza(double* datiCirconferenza, double* equazioneCirconferenza);//Equivalente al pgm della Star O6010
    void conica(double* datiConica, double* equazione);//Equivalente al pgm della Star O6011
    void formulaEq_2(double* equazioneSecondoGrado, double* soluzioni);//Equivalente al pgm della Star O6012
    void asseRadicaleTraCirconferenze(double* equazioneC1, double* equazioneC2, double* equazioneRetta);//Equivalente al pgm della Star O6013
    void sistemaCirconferenzaRetta(double* equazioneCirconferenza, double* equazioneRetta, double* coordinate);//Equivalente al pgm della Star O6014
    double estrazioneCoordinataEquazioneRetta(double* eqRetta, bool selezionaIncognitaDesiderata, double valoreIncognitaNota);//Equivalente al pgm della Star O6015
    double stabilizzaAngolo(double gradiAngolo);//Equivalente al pgm della Star O6016
    
    void eqPuntoSuCirconf(Tpunto p, double* eq);//Equivalente al pgm della Star O60
    void eqRaggioCirconf(double raggio, double* eq);//Equivalente al pgm della Star O60
    void fattorizzaEquazione(short int lengthEquaz, short int numIndFat, double* eq);//Equivalente al pgm della Star O60
    void prod_Coeff_Polinomio(double coefficiente, short int lengthPol, double* pol, double* prodotto);//Equivalente al pgm della Star O60
    void sqrBinomio(double binomio[2], double* quadratoBinomio);//Equivalente al pgm della Star O60
    void sommaTraArrayOmogenei(short int lengthArray, double* array1, double* array2);//Equivalente al pgm della Star O60
    void compattaArray(short int indicePartenza, short int numFinale, double* array);//Equivalente al pgm della Star O60
    void ordinaArrayPerStep(short int step, short int lengthArrayOutput, double* arrayInput, double* arrayOutput);//Equivalente al pgm della Star O60
    void centriCirPerDuePunti_Raggio(Tpunto* p, Tcirconferenza* circonf1, Tcirconferenza* circonf2);//Equivalente al pgm della Star O60
    
    
    void polarizzaPunto(bool pianoVista, double* coordinate, double angolo, short int numeroPunti, double* coordinatePolarizzate);
    void creaGeometriaDaPunti(bool pianoVista, bool sensoPolare, bool esistenzaRaccordo, double* coordinatePuntiIniziali, short int numeroCopiePunti, double gradiIncrementali, double* geometria);
    
                    //FUNZIONI GENERICHE
    /*Funzione che azzera gli elementi del vettore inserito.
            short int lengthVettore = lunghezza del vettore (numero intero nominale);
            double* array = vettore da azzerare.*/
    void azzeraVettore(short int lengthVettore, double* array) {
        for (short int i = 0; i < lengthVettore; i++)
            array[i] = 0.0;
    }
    
    //TRIGONOMETRIA
    //Funzione--> che trasforma i gradi in radianti
    double radianti(double gradi) {
        return gradi * (M_PI / 180.0);
    }
    
    //Funzione--> che trasforma i radianti in gradi
    double gradi(double radianti) {
        return radianti * (180.0 / M_PI);
    }
    
    //Geometria Piana
    /*Funzione che calcola la lunghezza dell'ipotenusa o di un cateto di un triangolo rettangolo in base opzione scelta.*/
    double teoremaPitagora(bool ipotenusa_cateto, double a, double b) {
        if (ipotenusa_cateto == true)
            return sqrt(pow(a, 2) + pow(b, 2));
        else
            return sqrt(pow(a, 2) - pow(b, 2));
    }
    
    /*Funzione che restituisce la misura in gradi dell'angolo formato allo spigolo tra due lati di un poligono regolare.*/
    double gradiTraDueLatiPoligono(short int numeroLatiPoligono) {
        return 180.0 - (360.0 / numeroLatiPoligono);
    }
    
    
    /*Funzione--> che restituisce la lunghezza dell'ipotenusa di un triangolo rettangolo conoscendo angolo (in gradi)
    e misura di un cateto (orizzontale o coseno dell'angolo inserito).*/
    double lunghezzaIpotenusaDaGradi_catetOrizzontale(double gradi, double misuraCatetOrizzontale) {
        return misuraCatetOrizzontale / cos(radianti(gradi));
    }
    
    /*Funzione--> che restituisce la lunghezza del cateto verticale di un triangolo rettangolo conoscendo l'angolo (in gradi)
    e la misura dell'ipotenusa.*/
    double lunghezzaCatetoVerticaleDaGradiEipotenusa(double gradi, double misuraIpotenusa) {
        return misuraIpotenusa * sin(radianti(gradi));
    }
    
    /*Funzione--> che restituisce la lunghezza del cateto verticale di un triangolo rettangolo conoscendo l'angolo (in gradi)
    e la misura dell'ipotenusa.*/
    double lunghezzaCatetOrizzontaleDaGradiEipotenusa(double gradi, double misuraIpotenusa) {
        return misuraIpotenusa * cos(radianti(gradi));
    }
    
    /*Funzione che restituisce i gradi rispetto all'asse delle ascisse della retta passante per l'origine ed un punto dato.*/
    double gradiDaCoordinatePunto(bool pianoVista, double* coordinatePunto) {
        //Dichiarazione delle variabili locali
        double gradiAngolo = 0;
        /*Elaborazione*/
        if (coordinatePunto[0] != 0) {
            gradiAngolo = gradi(atan(coordinatePunto[1] / coordinatePunto[0]));//Calcolo dell'angolo formato dalla retta origine/punto con l'ascissa
            if (pianoVista == false)
                if (coordinatePunto[0] > 0)
                    if (coordinatePunto[1] >= 0)
                        return gradiAngolo;
                    else
                        return 360.0 + gradiAngolo;
                else
                    return 180.0 + gradiAngolo;
            else
                if (coordinatePunto[0] > 0)
                    return 90.0 - gradiAngolo;
                else
                    return 270.0 - gradiAngolo;
        }
        else
            if (pianoVista == false)
                if (coordinatePunto[1] > 0)
                    return 90.0;
                else
                    return 270.0;
            else
                if (coordinatePunto[1] > 0)
                    return 0;
                else
                    return 180.0;
    }
    
    /*Funzione che duplica polarmente un punto iniziale, restituendo in un array le coordinate di tali punti.
    - pianoVista = indica il piano su cui si vuole duplicare il punto:
        pianoVista = 0-->XY e YZ;
        pianoVista = 1-->XZ.
    - piano = coordinate del piano cartesiano attivo:
        -piano.asc: ascissa;
        -piano.ord: ordinata.
    - p = coordinate del punto di riferimento da duplicare:
        -p.asc: ascissa;
        -p.ord: ordinata.
    - tieniPuntoRiferimento = true tiene all'indice zero le coordinate del punto di riferimento.
    - gradi = angolo di duplicazione attorno all'origine [in gradi].
    - numPunti = numero di copie dei punti desiderati.
    - punti = vettore di output che contiene le coordinate polari dei punti duplicati:
        punti[].asc = ascissa;
        punti[].ord = ordinata.*/
    void duplicPolarPoint(bool pianoVista, Tpunto piano, Tpunto p, bool tieniPuntoRiferimento, double gradi, short int numPunti, Tpunto* punti) {
        short int contPosPunto = 1;
        double distOrig = 0.0;//Assume la distanza dall'origine del punto di input
        double teta = 0.0;
        //Elaborazione
        gradi = radianti(gradi);
        distOrig = teoremaPitagora(true, p.asc, p.ord);//Calcolo della distanza del punto dall'origine
        //Calcolo dell'angolo, della retta passante per l'origine ed il punto iniziale con l'asse delle ascisse
        if (p.asc == 0.0)
            if (pianoVista == false)
                if (p.ord > 0.0)
                    teta = M_PI * 0.5;//90°
                else
                    teta = M_PI * 1.5;//270°
            else
                if (p.ord > 0.0)
                    teta = 0.0;//0°
                else
                    teta = M_PI;//180°
        else {
            teta = p.ord / p.asc;//Calcolo dell'angolo che forma la retta Origine/Punto rispetto all'ascissa
            teta = atan(teta);
            if (pianoVista == false) {
                if (p.asc < 0.0)
                    teta = M_PI + teta;//180°+teta
            }
            else
                if (p.asc > 0.0)
                    teta = (M_PI * 0.5) - teta;//90°-teta
                else
                    teta = (M_PI * 1.5) - teta;//270°-teta
        }
        //Calcolo delle coordinate dei punti duplicati polarmente
        for (short int i = 0; i < numPunti; i++)
            if (tieniPuntoRiferimento == true && i == 0) {
                //Le coordinate del primo punto del vettore sono quelle del punto inserito
                punti[i].asc = p.asc;
                punti[i].ord = p.ord;
                numPunti++;
            }
            else {
                gradi *= double(contPosPunto);
                gradi += teta;//Incremento dell'angolo teta dell'angolo inserito
                //Calcolo delle coordinate dei punti duplicati polarmente
                if (pianoVista == false) {
                    punti[i].asc = distOrig * cos(gradi);
                    punti[i].ord = distOrig * sin(gradi);
                }
                else {
                    punti[i].asc = distOrig * sin(gradi);
                    punti[i].ord = distOrig * cos(gradi);
                }
                if (fabs(punti[i].asc) <= 0.0001)
                    punti[i].asc = 0.0;
                if (fabs(punti[i].ord) <= 0.0001)
                    punti[i].ord = 0.0;
                gradi -= teta;//Decremento dell'angolo teta dell'angolo inserito
                gradi /= double(contPosPunto);//Ripristino dell'angolo iniziale
                contPosPunto++;//Incremento della posizione punto
            }
        //Traslazione dei punti rispetto al piano cartesiano attivo
        for (short int i = 0; i <= numPunti; i++) {
            punti[i].asc += piano.asc;
            punti[i].ord += piano.ord;
        }
    }
    
    //ANALISI MATEMATICA
    /*Funzione che restituisce i 3 coefficienti dell'equazione di una retta passante per un punto usando l'equazione del fascio di rette per un punto: y - y0 = m (x - x0).*/
    void fascioRetta(bool pianoVista, double* datiRetta, double* eq_FascioDiRette) {
        double supportoDatiRetta[3] = {};
        for (short int i = 0; i < 3; i++)
            supportoDatiRetta[i] = datiRetta[i];//Assegno a supportoRetta i dati della retta
        //Condizione in cui viene verificato il piano su cui giace la retta
        if (pianoVista == true)
            supportoDatiRetta[2] = 90.0 - supportoDatiRetta[2];
        //Calcolo dei coefficienti della retta rispetto alle varie condizioni possibili
        if (supportoDatiRetta[2] == 0 ||
            supportoDatiRetta[2] == 180.0 ||
            supportoDatiRetta[2] == 360.0 ||
            supportoDatiRetta[2] == -180.0 ||
            supportoDatiRetta[2] == -360.0) {
            eq_FascioDiRette[1] = supportoDatiRetta[1];
            eq_FascioDiRette[2] = 0;
            eq_FascioDiRette[0] = 0;
        }
        else if (supportoDatiRetta[2] == 90.0 ||
            supportoDatiRetta[2] == 270.0 ||
            supportoDatiRetta[2] == -90.0 ||
            supportoDatiRetta[2] == -270.0) {
            eq_FascioDiRette[1] = 0;
            eq_FascioDiRette[2] = supportoDatiRetta[0];
            eq_FascioDiRette[0] = 0;
        }
        else {
            eq_FascioDiRette[1] = 1;
            eq_FascioDiRette[2] = tan(radianti(supportoDatiRetta[2]));
            eq_FascioDiRette[0] = supportoDatiRetta[1] - (eq_FascioDiRette[2] * supportoDatiRetta[0]);
            if (eq_FascioDiRette[0] <= 0.0001 && eq_FascioDiRette[0] >= -0.0001)
                eq_FascioDiRette[0] = 0;
        }
    }
    
    /*Funzione che restituisce i 3 coefficienti dell'equazione di una retta passante per due punti usando la relativa equazione : [(y - y1) / (y2 - y1)] = [(x - x1) / (x2 - x1)].*/
    void rettaDuePunti(double* coordinatePunti, double* eq_Retta) {
        //Dichiarazione delle variabili locali
        double denominatoreOrdinata = 0;
        double denominatoreAscissa = 0;
    
        if (coordinatePunti[1] == coordinatePunti[3]) {
            denominatoreOrdinata = 0;
            denominatoreAscissa = 1;
        }
        else if (coordinatePunti[0] == coordinatePunti[2]) {
            denominatoreOrdinata = 1;
            denominatoreAscissa = 0;
        }
        else {
            denominatoreOrdinata = coordinatePunti[3] - coordinatePunti[1];
            denominatoreAscissa = coordinatePunti[2] - coordinatePunti[0];
        }
    
        if (denominatoreOrdinata == 0) {
            eq_Retta[1] = coordinatePunti[1];
            eq_Retta[2] = 0;
            eq_Retta[0] = 0;
        }
        else if (denominatoreAscissa == 0) {
            eq_Retta[1] = 0;
            eq_Retta[2] = coordinatePunti[0];
            eq_Retta[0] = 0;
        }
        else {
            eq_Retta[1] = 1;
            eq_Retta[2] = denominatoreOrdinata / denominatoreAscissa;
            eq_Retta[0] = ((denominatoreAscissa * coordinatePunti[1]) - (denominatoreOrdinata * coordinatePunti[0])) / denominatoreAscissa;
        }
    }
    
    /*Funzione--> che restituisce le coordinate del punto d'incidenza tra due rette, usando il sistema tra rette ed utilizzando il metodo di sostituzione.*/
    void intersezioneRette(double* eq_primaRetta, double* eq_secondaRetta, Tpunto& p) {
        //Dichiarazione delle variabili locali
        double m = 0, q = 0;
        //Elaborazione
        if ((eq_primaRetta[2] == 0 && eq_primaRetta[0] == 0) || (eq_secondaRetta[2] == 0 && eq_secondaRetta[0] == 0)) {//Caso in cui la retta è orizzontale quindi la m=0°
            if (eq_primaRetta[2] == 0) {
                p.ord = eq_primaRetta[1];
                m = eq_secondaRetta[2];
                q = eq_secondaRetta[0];
            }
            else {
                p.ord = eq_secondaRetta[1];
                m = eq_primaRetta[2];
                q = eq_primaRetta[0];
            }
            p.asc = (p.ord - q) / m;
        }
        else {
            if ((eq_primaRetta[1] == 0 && eq_primaRetta[0] == 0) || (eq_secondaRetta[1] == 0 && eq_secondaRetta[0] == 0))//Caso in cui la retta è verticale quindi la m=90°
                if (eq_primaRetta[1] == 0) {
                    m = eq_secondaRetta[2];
                    p.asc = eq_primaRetta[2];
                    q = eq_secondaRetta[0];
                }
                else {
                    m = eq_primaRetta[2];
                    p.asc = eq_secondaRetta[2];
                    q = eq_primaRetta[0];
                }
            else {//Caso in cui la retta ha un angolo diverso da 0° e 90°
                m = eq_primaRetta[2];
                q = eq_primaRetta[0];
                p.asc = (eq_primaRetta[0] - eq_secondaRetta[0]) / (eq_secondaRetta[2] - eq_primaRetta[2]);
            }
            p.ord = (m * p.asc) + q;
        }
        if (fabs(p.asc) <= 0.0001)
            p.asc = 0.0;
        if (abs(p.ord) <= 0.0001)
            p.ord = 0.0;
    }
    
    /*Funzione--> che restituisce in un vettore i coefficienti dell'equazione di una circonferenza.*/
    void circonferenza(double* datiCirconferenza, double* equazioneCirconferenza) {
        equazioneCirconferenza[0] = pow(datiCirconferenza[0], 2) + pow(datiCirconferenza[1], 2) - pow(datiCirconferenza[2], 2);//Valore noto senza incognita
        equazioneCirconferenza[1] = (-2.0) * datiCirconferenza[1];//Coefficiente di y
        equazioneCirconferenza[2] = (-2.0) * datiCirconferenza[0];//Coefficiente di x
        equazioneCirconferenza[3] = 1.0;//Coefficiente di y^2
        equazioneCirconferenza[4] = 1.0;//Coefficiente di x^2
    }
    
    /*Funzione che restituisce i termini dell'equazione di 2° grado di una figura conica.*/
    void conica(double* datiConica, double* equazione) {
        //Dichiarazione delle variabili locali
        double fattorizzatore = 0;
        //Elaborazione
        equazione[4] = pow(datiConica[3], 2);//x^2
        equazione[3] = pow(datiConica[2], 2);//y^2
        equazione[2] = (-2.0) * datiConica[0] * equazione[4];//x
        equazione[1] = (-2.0) * datiConica[1] * equazione[3];//y
        equazione[0] = (pow(datiConica[0], 2) * equazione[4]) + (pow(datiConica[1], 2) * equazione[3]) - (equazione[4] * equazione[3]);//termine noto
        fattorizzatore = equazione[3];//Assegno a questa variabile il coefficiente di y^2 per poter fattorizzare l'equazione successivamente
        for (short int i = 4; i >= 0; i--)
            equazione[i] /= fattorizzatore;//Fattorizzazione dell'equazione della conica
    }
    
    /*Funzione che restituisce in un vettore le eventuali soluzioni di un'eqauzione di secondo grado passata alla funzione.*/
    void formulaEq_2(double* equazioneSecondoGrado, double* soluzioni) {
        double supportoEquazioneSecondoGrado[3] = {};//Conterrà i valori dell'equazione di secondo grado passata
        double delta = 0;
        for (short int i = 2; i >= 0; i--)
            supportoEquazioneSecondoGrado[i] = equazioneSecondoGrado[i];
        delta = pow(supportoEquazioneSecondoGrado[1], 2) - (4.0 * supportoEquazioneSecondoGrado[2] * supportoEquazioneSecondoGrado[0]);
        if (fabs(delta) <= 0.0001) {
            soluzioni[0] = (-supportoEquazioneSecondoGrado[1]) / (2.0 * supportoEquazioneSecondoGrado[2]);
            soluzioni[1] = soluzioni[0];
        }
        else {
            soluzioni[0] = ((-supportoEquazioneSecondoGrado[1]) + sqrt(delta)) / (2.0 * supportoEquazioneSecondoGrado[2]);
            soluzioni[1] = ((-supportoEquazioneSecondoGrado[1]) - sqrt(delta)) / (2.0 * supportoEquazioneSecondoGrado[2]);
        }
        if (fabs(soluzioni[0]) <= 0.0001)
            soluzioni[0] = 0.0;
        if (fabs(soluzioni[1]) <= 0.0001)
            soluzioni[1] = 0.0;
    }
    
    /*Restituisce in un vettore l'equazione dell'asse radicale formato da due circonferenze incidenti.*/
    void asseRadicaleTraCirconferenze(double* equazioneC1, double* equazioneC2, double* equazioneRetta) {
        //Dichiarazione delle variabili locali
        double supportoEqCirc[5] = {};
        short int i = 0;
        //Assegnazione dei coefficienti dell'equazione C1 al vettore locale
        for (i = 0; i <= 4; i++)
            supportoEqCirc[i] = equazioneC1[i];
        //Sottrazione tra i coefficienti delle equazioni di C1 e C2
        for (i = 0; i <= 4; i++)
            supportoEqCirc[i] -= equazioneC2[i];
        //Calcolo dell'equazione della retta asse radicale
        if (supportoEqCirc[1] == 0.0) {
            equazioneRetta[2] = (-supportoEqCirc[0]) / supportoEqCirc[2];//Calcolo dell'incognita x
            equazioneRetta[0] = 0.0;//Assegnazione del valore 0 al termine noto dell'equazione retta	 	
            equazioneRetta[1] = 0.0;//Assegnazione del valore 0 all'incognita y dell'equazione retta
        }
        else {
            for (i = 0; i <= 2; i += 2) {
                equazioneRetta[i] = -supportoEqCirc[i];//Cambio di segno del coefficiente di x e del termine noto
                equazioneRetta[i] /= supportoEqCirc[1];//Fattorizzazione del coefficiente di x e del termine noto col coefficiente di y
            }
            equazioneRetta[1] = 1.0;//Assegnazione del valore 1 all'incognita y dell'equazione retta
        }
    
    }
    
    /*Funzione--> che restituisce in un vettore le coordinate dei punti d'intersezione tra una circonferenza ed una retta.*/
    void sistemaCirconferenzaRetta(double* equazioneCirconferenza, double* equazioneRetta, double* coordinate) {
        //Dichiarazione delle variabili locali
        double supportoCirconferenza[5] = {};//Si assegneranno a questo vettore i valori contenuti nell'array equazioneCirconferenza
        double supportoRetta[3] = {};//Si assegneranno a questo vettore i valori contenuti nell'array equazioneRetta
        double sistemaCirc_Retta[3] = {};//Verranno assegnati a questo vettore i coefficienti dell'equazione di secondo grado risultante dal sistema Circonferenza/Retta
        double supportoCoordinate[2]{};//Verranno assegnati i valori di passaggio delle coordinate calcolate
        short int i = 0;//Contatore
                        /*Elaborazione*/
        //Acquisizione dei dati di input dell'equazione della circonferenza in un vettore interno alla funzione
        for (i = 0; i < 5; i++)
            supportoCirconferenza[i] = equazioneCirconferenza[i];
        //Acquisizione dei dati di input dell'equazione della retta in un vettore interno alla funzione
        for (i = 0; i < 3; i++)
            supportoRetta[i] = equazioneRetta[i];
        //Condizione che valuta l'inclinazione della retta e in base a questa decide come applicare il metodo di sostituzione tra le 2 equazioni
        if (supportoRetta[1] != 0) {
            sistemaCirc_Retta[2] = supportoCirconferenza[4] + pow(supportoRetta[2], 2);//incognita^2
            sistemaCirc_Retta[1] = (2.0 * supportoRetta[2] * supportoRetta[0]) + supportoCirconferenza[2] + (supportoCirconferenza[1] * supportoRetta[2]);//Incognita
            if ((supportoRetta[0] != 0) && (supportoRetta[2] != 0))
                i = 0;
            else
                if (supportoRetta[0] == 0)
                    i = 0;
                else
                    i = 1;
            sistemaCirc_Retta[0] = pow(supportoRetta[i], 2) + (supportoCirconferenza[1] * supportoRetta[i]) + supportoCirconferenza[0];//Termine noto
        }
        else {
            sistemaCirc_Retta[2] = supportoCirconferenza[3];//incognita^2
            sistemaCirc_Retta[1] = supportoCirconferenza[1];//Incognita
            sistemaCirc_Retta[0] = pow(supportoRetta[2], 2) + (supportoCirconferenza[2] * supportoRetta[2]) + supportoCirconferenza[0];//Termine noto
        }
        //Risoluzione dell'equazione di secondo grado ad una incognita
        formulaEq_2(sistemaCirc_Retta, supportoCoordinate);
        //Applico il metodo di sostituzione all'equazione della retta le coordinate appena calcolate
        if (supportoRetta[1] != 0) {
            coordinate[0] = supportoCoordinate[0];//Coordinata X1
            coordinate[2] = supportoCoordinate[1];//Coordinata X2
            if ((supportoRetta[0] != 0) && (supportoRetta[2] != 0)) {
                coordinate[1] = (coordinate[0] * supportoRetta[2]) + supportoRetta[0];//Coordinata Y1
                coordinate[3] = (coordinate[2] * supportoRetta[2]) + supportoRetta[0];//Coordinata Y2
            }
            else
                if (supportoRetta[0] == 0) {
                    coordinate[1] = supportoRetta[2] * coordinate[0];//Coordinata Y1
                    coordinate[3] = supportoRetta[2] * coordinate[2];//Coordinata Y2
                }
                else {
                    coordinate[1] = supportoRetta[1];//Coordinata Y1
                    coordinate[3] = supportoRetta[1];//Coordinata Y2
                }
        }
        else {
            coordinate[0] = supportoRetta[2];//Coordinata X1
            coordinate[1] = supportoCoordinate[0];//Coordinata Y1
            coordinate[2] = supportoRetta[2];//Coordinata X2
            coordinate[3] = supportoCoordinate[1];//Coordinata Y2
        }
    }
    
    /*Calcola dall'equazione esplicita della retta (y=mx+q), il valore di coordinata richiesta, quindi ascissa o ordinata.*/
    double estrazioneCoordinataEquazioneRetta(double* eqRetta, bool selezionaIncognitaDesiderata, double valoreIncognitaNota) {
        if (eqRetta[2] == 0 && eqRetta[0] == 0)//Se angolo è a 0°
            return eqRetta[1];//y
        else if (eqRetta[1] == 0 && eqRetta[0] == 0)//Se angolo è 90°
            return eqRetta[2];//x
        else {
            if (selezionaIncognitaDesiderata == false)
                return (valoreIncognitaNota - eqRetta[0]) / eqRetta[2];//x=(y-q)/m
            else
                return (eqRetta[2] * valoreIncognitaNota) + eqRetta[0];//y=(m*x)+q
        }
    }
    
    /*Funzione che restituisce in gradi compresi tra 0° e +/-360°, i valori superiori a 360° o inferiori a -360°.*/
    double stabilizzaAngolo(double gradiAngolo) {
        //Variabili locali
        double segno = 1.0;
        if (gradiAngolo < 0)
            segno = -segno;
        gradiAngolo = radianti(fabs(gradiAngolo));//Trasforma i gradi in radianti
        gradiAngolo = cos(gradiAngolo);//Coseno dell'angolo
        gradiAngolo = acos(gradiAngolo);//Arcocoseno dell'angolo
        return (gradi(gradiAngolo) * segno);//Restituisce i gradi compresi tra 0° e 360°
    }
    
    
    
    
    
    //Analisi matematica
    
    
    /*Funzione che restituisce in un vettore di 4 elementi l'equazione di un punto noto su circonferenza:
        -Tpunto p = coordinate del punto noto della circonferenza;
        -double* eq = equazione del punto su circonferenza del tipo xa + yb + c + tn = 0.
            eq[0] = termine noto;
            eq[1] = coefficiente di c;
            eq[2] = coefficiente di b;
            eq[3] = coefficiente di a;
            eq[4] = coefficiente di b^2;
            eq[5] = coefficiente di a^2.*/
    void eqPuntoSuCirconf(Tpunto p, double* eq) {
        eq[0] = pow(p.asc, 2) + pow(p.ord, 2);//tn
        eq[1] = 1.0;//c
        eq[2] = p.ord;//b
        eq[3] = p.asc;//a
        eq[4] = 0.0;//c^2
        eq[5] = 0.0;//b^2
        eq[6] = 0.0;//a^2
    }
    
    /*Funzione che restituisce l'equazione del raggio di una circonferenza.
        double raggio = raggio della circonferenza;
        double *eq = equazione del raggio su circonferenza del tipo: a^2 + b^2 -4c - (r^2 * 4) = 0.
            eq[0] = termine noto;
            eq[1] = coefficiente di c;
            eq[2] = coefficiente di b;
            eq[3] = coefficiente di a;
            eq[4] = coefficiente di b^2;
            eq[5] = coefficiente di a^2.*/
    void eqRaggioCirconf(double raggio, double* eq) {
        eq[1] = -4.0;//c
        eq[0] = pow(raggio, 2) * eq[1];//tn
        eq[2] = 0.0;//b
        eq[3] = 0.0;//a
        eq[4] = 0.0;//c^2
        eq[5] = 1.0;//b^2
        eq[6] = 1.0;//a^2
    }
    
    /*Funzione che restituisce i coefficienti fattorizzati dell'equazione di input. Questa cambia i valori dell'equazione inserita,
    ma non modifica l'ordine degli elementi. A fine funzione la cella del fattore varrà zero.
            short int lengthEquaz = lunghezza dell'array dell'equazione da fattorizzare (numero intero nominale);
            short int numIndFat = numero effettivo dell'indirizzo array del fattore;
            double* eq = equazione fattorizzata.*/
    void fattorizzaEquazione(short int lengthEquaz, short int numIndFat, double* eq) {
        //Variabili di lavoro locali
        double fat = -eq[numIndFat];//Assegnazione del coefficiente fattorizzatore col segno invertito
            //Elaborazione
        for (short int i = 0; i < lengthEquaz; i++) {
            eq[i] /= fat;//Fattorizzazione dell'equazione
            if (fabs(eq[i]) <= 0.0001)
                eq[i] = 0.0;
        }
        eq[numIndFat] = 0.0;//L'indirizzo dell'array che ha fatto da fattorizzatore dell'equazione assume il valore di uno
    }
    
    /*Funzione che restituisce il prodotto tra un numero (o coefficiente) ed un polinomio.
            double coefficiente = numero che verrà moltiplicato per ogni singolo elemento del polinomio;
            short int lengthPol = lunghezza del polinomio (numero intero nominale);
            double* polinomio = vettore coi coefficienti del polinomio esaminato;
            double* prodotto = vettore coi risultati del prodotto.*/
    void prod_Coeff_Polinomio(double coefficiente, short int lengthPol, double* pol, double* prodotto) {
        for (short int i = 0; i < lengthPol; i++) {
            prodotto[i] = coefficiente * pol[i];
            if (fabs(prodotto[i]) <= 0.0001)
                prodotto[i] = 0.0;
        }
    }
    
    /*Funzione che restituisce in un vettore di 3 elementi, il quadrato di un binomio del tipo: (x+1)^2.
            double binomio[2] = vettore di input del binomio;
                   binomio[0] = termine noto;
                   binomio[1] = incognita;
            double* quadratoBinomio = vettore di output, risultato del quadrato del binomio.
                    quadratoBinomio[0] = termine noto;
                    quadratoBinomio[1] = x;
                    quadratoBinomio[2] = x^2.*/
    void sqrBinomio(double binomio[2], double* quadratoBinomio) {
        quadratoBinomio[0] = pow(binomio[0], 2);//Termine noto 
        quadratoBinomio[1] = 2.0 * binomio[1] * binomio[0];//x
        quadratoBinomio[2] = pow(binomio[1], 2);//x^2
    }
    
    /*Funzione che restituisce nell'array2 la somma degli elementi tra due vettori di ugual misura.
    Il vettore array2 è quello che verrà cambiato dopo la funzione.
            short int lengthArray = lunghezza effettiva di entrambi gli array;
            double* array1 = vettore che contiene gli elementi del primo array;
            double* array2 = vettore che contiene gli elementi del secondo array.*/
    void sommaTraArrayOmogenei(short int lengthArray, double* array1, double* array2) {
        for (short int i = 0; i < lengthArray; i++) {
            array2[i] += array1[i];
            if (fabs(array2[i]) <= 0.0001)
                array2[i] = 0.0;
        }
    }
    
    /*Funzione che compatta gli elementi di un array che sono diversi da zero, partendo dall'indirizzo indicato dall'utente fino a quello finale indicato,
    gli elementi spostati sono sostituiti con zero. La lunghezza dll'array non viene modificata, ma gli elementi diversi da zero sono portati verso alle
    prime celle dell'array.
        -short int indicePartenza = numero che indica la cella iniziale dell'array da cui partire;
        -short int numFinale = numero che indica la cella finale dell'array;
        -double* array = array da esaminare.*/
    void compattaArray(short int indicePartenza, short int numFinale, double* array) {
        //Dichiarazione variabili locali
        short int c = 0;//Contatore del ciclo annidato
        short int j = indicePartenza;//Inizializzatore
        double temp = 0.0;//Variabile di supporto temporanea
        //Elaborazione
        for (indicePartenza; indicePartenza < numFinale; indicePartenza++) {
            for (c = j; c < numFinale; c++)
                if (array[c] != 0.0) {
                    temp = array[c];
                    array[c] = 0.0;
                    c = numFinale - 1;
                }
                else
                    temp = 0.0;
            if (temp != 0.0)
                array[indicePartenza] = temp;
            j++;
        }
    }
    
    /*Funzione che ordina nell'array di output i valori di un array di input in base ad un passo indicato.
            short int step = passo;
            short int lengthArrayOutput = lunghezza nominale dell'array di output;
            double* arrayInput = valori di input iniziali;
            double* arrayOutput = valori ordinati dallo step.*/
    void ordinaArrayPerStep(short int step, short int lengthArrayOutput, double* arrayInput, double* arrayOutput) {
        //Dichiarazione variabili locali
        short int c = 0;//Secondo contatore
        //Elaborazione
        for (short int i = 0; i < lengthArrayOutput; i++)
            if ((i % step) == 0) {
                arrayOutput[i] = arrayInput[c];//Assegnazione del valore
                c++;//Incremento unario di c
            }
            else
                arrayOutput[i] = 0.0;
    }
    
    /*Funzione che restituisce i centri circonferenze e le relative equazioni, aventi noti 2 punti ed il loro raggio.
        -Tpunto* p: struttura avente le coordinate dei 2 punti noti delle circonferenze;
            p[0].asc = ascissa di P1;
            p[0].ord = ordinata di P1;
            p[1].asc = ascissa di P2;
            p[1].ord = ordinata di P2.
        -Tcirconferenza* circonf1: struttura che contiene tutti i dati della circonferenza C1;
            circonf1.centro.asc = ascissa centro di C1;
            circonf1.centro.ord = ordinata centro di C1;
            circonf1.raggio = raggio di C1 (e C2);
            circonf1.eq[] = equazione di 5 elementi di secondo grado di C1.
        -Tcirconferenza* circonf2: struttura che contiene tutti i dati della circonferenza C2;
            circonf2.centro.asc = ascissa centro di C2;
            circonf2.centro.ord = ordinata centro di C2;
            circonf2.raggio = raggio di C2 (e C1);
            circonf2.eq[] = equazione di 5 elementi di secondo grado di C2.*/
    void centriCirPerDuePunti_Raggio(Tpunto* p, Tcirconferenza* circonf1, Tcirconferenza* circonf2) {
        //Dichiarazione delle variabili locali
        double A[7] = {};//Vettore equazione del punto A
        double B[7] = {};//Vettore equazione del punto B
        double R[7] = {};//Vettore equazione del raggio circonferenza
        double supporto[7] = {};//Vettore di supporto per calcoli
        bool actB = false;//Attiva la variabile B.b come fattorizzatore
        double binomio[3] = {};//Binomio
        short int j = 0;//Variabile di supporto
    
                        //Elaborazione
        if (fabs(p[0].asc - p[1].asc) == (circonf1->raggio * 2.0) || fabs(p[0].ord - p[1].ord) == (circonf1->raggio * 2.0))
            if (p[0].asc == p[1].asc) {
                circonf1->centro.asc = p[0].asc;
                circonf2->centro.asc = p[0].asc;
                if (p[0].ord < p[1].ord) {
                    circonf1->centro.ord = p[0].ord + circonf1->raggio;
                    circonf2->centro.ord = circonf1->centro.ord;
                }
                else {
                    circonf1->centro.ord = p[0].ord - circonf1->raggio;
                    circonf2->centro.ord = circonf1->centro.ord;
                }
            }
            else {
                circonf1->centro.ord = p[0].ord;
                circonf2->centro.ord = p[0].ord;
                if (p[0].asc < p[1].asc) {
                    circonf1->centro.asc = p[0].asc + circonf1->raggio;
                    circonf2->centro.asc = circonf1->centro.asc;
                }
                else {
                    circonf1->centro.asc = p[0].asc - circonf1->raggio;
                    circonf2->centro.asc = circonf1->centro.asc;
                }
            }
        else {
            //Calcolo equazione del punto A e acquisizione nel vettore con cambio di segno
            eqPuntoSuCirconf(p[0], A);
            //Calcolo equazione del punto B
            eqPuntoSuCirconf(p[1], B);
            //Calcolo equazione del raggio circonferenza
            eqRaggioCirconf(circonf1->raggio, R);
            //Fattorizzazione dell'equazione punto A
            fattorizzaEquazione(4, 1, A);//c = a + b + tn
            //Sostituzione della variabile c nell'eq. di B  
            sommaTraArrayOmogenei(4, A, B);
            B[1] = 0.0;//Azzeramento dell'incognita B.c
            //Sostituzione della variabile c nell'eq. di R
            prod_Coeff_Polinomio(R[1], 4, A, supporto);//Prodotto tra il coefficiente di c dell'eq. R e A
            R[1] = 0.0;//Azzeramento dell'incognita R.c 
            sommaTraArrayOmogenei(7, supporto, R);//Somma tra i coefficienti simili di R
            //Fattorizzazione dei termini dell'eq. B con B.a o B.b
            if (B[3] == 0.0) {
                actB = true;//Attiva la variabile B.b
                j = 2;//Assume la posizione del fattorizzatore nell'equazione
            }
            else
                j = 3;//Assume la posizione del fattorizzatore nell'equazione
            fattorizzaEquazione(4, j, B);
            if (actB == false) {
                if (B[2] == 0.0)
                    B[3] = B[0];//L'incognita a è uguale al tn
                j = 3;//Acquisizione numero cella coefficiente
                R[6] = 0.0;//Azzeramento di a^2
            }
            else {
                if (B[3] == 0.0)
                    B[2] = B[0];//L'incognita b è uguale al tn
                j = 2;//Acquisizione numero cella coefficiente
                R[5] = 0.0;//Azzeramento di b^2
            }
            B[0] = 0.0;//Azzeramento del tn di B
            //Sostituzione dei termini dell'eq. B con quelli di A
            azzeraVettore(7, supporto);//Azzeramento dell'array di supporto
            prod_Coeff_Polinomio(A[j], 4, B, supporto);//Prodotto tra il coefficiente A.a o A.b con il polinomio di B
            A[j] = 0.0;//Azzeramento della cella corrispondente al coefficiente del prodotto
            sommaTraArrayOmogenei(7, supporto, A);//Somma tra i coefficienti simili di A
            compattaArray(1, 4, A);//Compatta l'eq. A, il valore nella posizione A[1] non corrisponderà più all'incognita c, ma a b o a
            //Sostituzione dei termini dell'eq. B con quelli di R
            azzeraVettore(7, supporto);//Azzeramento dell'array di supporto
            prod_Coeff_Polinomio(R[j], 4, B, supporto);//Prodotto tra il coefficiente A.a o A.b con il polinomio di B
            R[j] = 0.0;//Azzeramento della cella corrispondente al coefficiente del prodotto
            sommaTraArrayOmogenei(7, supporto, R);//Somma tra i coefficienti simili di R
            compattaArray(1, 4, B);//Compatta l'eq. B, il valore nella posizione B[1] non corrisponderà più all'incognita c, ma a b o a
            sqrBinomio(B, binomio);//Quadrato del binomio di B da passare a R
            compattaArray(1, 7, R);//Compatta l'eq. di R
            R[3] = 0.0;//Azzeramento ultima cella
            sommaTraArrayOmogenei(3, binomio, R);//Somma tra i coefficienti simili di R con il quadrato del binomio
            azzeraVettore(3, binomio);//Azzeramento del vettore
            //Calcolo delle 2 soluzioni corrispondenti a b1 e b2 se actB è false, o a1 e a2 se actB true
            formulaEq_2(R, binomio);
            //Calcolo dei valori di a1 e a2 se actB è false, b1 e b2 se actB è true
            B[2] = (B[1] * binomio[0]) + B[0];//B[2] assume il valore di a1\b1
            B[3] = (B[1] * binomio[1]) + B[0];//B[3] assume il valore di a2\b2
            //Il calcolo dei valori di c1 e c2 non fatti perchè le equazioni saranno calcolati poi con i due centri circonferenze più il raggio comune
            //A[2] = (A[1] * binomio[0]) + A[0];//A[2] assume il valore di c1
            //A[3] = (A[1] * binomio[1]) + A[0];//A[3] assume il valore di c2
            //Calcolo delle coordinate dei centri delle circonferenze1 e circonferenza2
            if (actB == false) {
                circonf1->centro.asc = B[2] / (-2.0);//Ascissa di C1
                circonf1->centro.ord = binomio[0] / (-2.0);//Ordinata di C1
                circonf2->centro.asc = B[3] / (-2.0);//Ascissa di C2
                circonf2->centro.ord = binomio[1] / (-2.0);//Ordinata di C2
            }
            else {
                circonf1->centro.asc = binomio[0] / (-2.0);//Ascissa di C1
                circonf1->centro.ord = B[2] / (-2.0);//Ordinata di C1
                circonf2->centro.asc = binomio[1] / (-2.0);//Ascissa di C2
                circonf2->centro.ord = B[3] / (-2.0);//Ordinata di C2
            }
        }
        //Fine del calcolo del sistema
    //Il vettore binomio assume i valori delle coordinate del centro circonferenza1 ed il raggio per essere passato alla funzione che calcola l'equazione
        binomio[0] = circonf1->centro.asc;
        binomio[1] = circonf1->centro.ord;
        binomio[2] = circonf1->raggio;
        //Il vettore supporto assume i valori delle coordinate del centro circonferenza2 ed il raggio per essere passato alla funzione che calcola l'equazione
        supporto[0] = circonf2->centro.asc;
        supporto[1] = circonf2->centro.ord;
        supporto[2] = binomio[2];
        //Calcolo dell'equazione della circonferenza1
        circonferenza(binomio, circonf1->eq);
        //Calcolo dell'equazione della circonferenza2
        circonferenza(supporto, circonf2->eq);
    }
    
    
    int main() {
        //Dichiarazione delle variabili di input
        short int numeroLobi = 6;//Numero dei lati del poligono
        double lobo[3] = { 1.025,0,0.34 };//Dati geometrici del lobo
        double circonferenzaConcava[3] = { 2.350497,0,1.21 };//Dati geometrici della circonferenza concava
        double dGrezzo = 2.75;//Diametro del grezzo
        double coordSup = 0;//Coordinata di superficie in Z o inizio in Z della geometria
        double zEnd = 1.5;//Indica la lunghezza in Z dalla coordinata di superficie (o più semplicemente è l'estrusione della geometria partendo dalla coordinata di superficie)
        short int tool = 37;//Scelta del numero utensile
        double rT = 1.0;//Raggio utensile
        double asseC = 0;//Posizionamento dell'asse C
        double passoZ = 0.06;//Indica il passo in Z che deve avere l'utensile
        double gapSicurezza = 0.7;//Gap di sicurezza (ATTENZIONE: mettere un valore > al diametro utensile di 0.1mm)
        double f = 250;//Avanzamento in lavorazione
        int riduciFile = 100;//Riduce la dimensione del file d'uscita agendo sul feed (mettere 50 se si vuole dimezzare l'avanzamento in lavorazione)
        bool salvataggio = true;//Consente di scegliere se salvare i dati su un file di testo o meno
    
        //Dichiarazione delle variabili di lavoro
        double gradiDalNumeroLobi = 0, zIncr = 0;
        double supportoPunti[24] = {};
        double eq_circonferenza1[5] = {}, eq_circonferenza2[5] = {};
        double eq_retta[3] = {};
        double punti[4] = {};
        double puntiDiContattoUtensile[98] = {};//Vettore di output che può contenere le coordinate di 12 punti
        short int limite = 0, a = 0, b = 0;
        bool verificaRaggioCirconferenzaConcava = false;
        FILE* torxMaschio = NULL;//Creazione del puntatore tipo FILE per salvataggio su file di testo
    
        //Input
    /*	cout<<"\tPercorso utensile per torx femmina STRAUMANN";
        cout<<endl<<"Numero lobi: ";
        cin>>numeroLobi;
        cout<<"Le ordinate delle circonferenze lobo e convessa sono sempre 0!";
        cout<<endl<<"Distanza dall'origine del centro della circonferenza lobo: ";
        cin>>lobo[0];
        cout<<"Raggio della circonferenza lobo: ";
        cin>>lobo[2];
        cout<<"Distanza dall'origine del centro della circonferenza concava: ";
        cin>>circonferenzaConcava[0];
        cout<<"Raggio della circonferenza concava: ";
        cin>>circonferenzaConcava[2];
        cout<<"Diametro del grezzo: ";
        cin>>dGrezzo;
        cout<<"Coordinata di superficie: ";
        cin>>coordSup;
        cout<<"Profondita' della geometria torx: ";
        cin>>zEnd;
        cout<<"Numero utensile: ";
        cin>>tool;
        cout<<"Il diametro utensile non va messo qui, ma nei parametri\nutensile del PGM del DECO!"<<endl;
        cout<<"Orientamento della geometria sull'asse C: ";
        cin>>asseC;
        cout<<"Passo in Z: ";
        cin>>passoZ;
        cout<<"Gap di sicurezza (ATTENZIONE: mettere un valore > al diametro utensile utilizzato di 0.1mm): ";
        cin>>gapSicurezza;
        cout<<"Ridurre la dimensione del file agendo sul feed della macchina\n(solo numeri interi)[%]: ";
        cin>>riduciFile;
        cout<<"Avanzamento in lavorazione (tenere conto della voce precedente)[mm/min]: ";
        cin>>f;
        cout<<"Salvare sul desktop in un file di testo? [NO=0; SI=1]: ";
        cin>>salvataggio;*/
    
    
        /*Elaborazione*/
    //ATTENZIONE: impostare nel PGM della STAR #860 = #629
        dGrezzo /= 2;//Raggio del preforo
        dGrezzo += (rT + gapSicurezza);//Primo punto di attacco utensile in zona di sicurezza
        //Primo punto di partenza dell'utensile
        puntiDiContattoUtensile[0] = lobo[0] + lobo[2] + rT;//Ascissa
        puntiDiContattoUtensile[1] = lobo[1];//Ordinata
        //Calcolo del numero di punti che formano il percorso utensile
        limite = numeroLobi * 2;
        //Gradi e bisettrice dal numero lobi
        gradiDalNumeroLobi = 360.0 / numeroLobi;//Gradi
        gradiDalNumeroLobi /= 2.0;//Bisettrice
        //Calcolo del punto di tangenza tra le circonferenze
            //Compensazioni dei raggi utensile
        circonferenzaConcava[2] -= rT;//Compensazione del raggio circonferenzaConcava in base al raggio utensile
        lobo[2] += rT;//Compensazione del raggio lobo in base al raggio utensile
        if (circonferenzaConcava[2] <= 0.0001 && circonferenzaConcava[2] >= -0.0001)
            circonferenzaConcava[2] = 0;
        if (circonferenzaConcava[2] <= 0)
            //Polarizzazione delle coordinate del centro circonferenzaConcava
            polarizzaPunto(false, circonferenzaConcava, gradiDalNumeroLobi, 1, punti);
        else {
            limite *= 2;//Doppio prodotto del numero dei punti che formano il percorso utensile
            limite += 2;//Aggiunta delle coordinate dell'ultimo punto della geometria
            verificaRaggioCirconferenzaConcava = true;//Cambio di stato; indica che l'utensile è più piccolo del raggio circonferenzaConcava
                //Polarizzazione delle coordinate del centro circonferenzaConcava
            polarizzaPunto(false, circonferenzaConcava, gradiDalNumeroLobi, 1, circonferenzaConcava);
            //Calcolo delle equazione delle circonferenze: lobo e convessa
            circonferenza(circonferenzaConcava, eq_circonferenza1);//Equazione circonferenza convessa
            circonferenza(lobo, eq_circonferenza2);//Equazione circonferenza lobo
                //Calcolo asse radicale
            asseRadicaleTraCirconferenze(eq_circonferenza2, eq_circonferenza1, eq_retta);
            //Sistema circonferenza convessa con asse radicale
            sistemaCirconferenzaRetta(eq_circonferenza1, eq_retta, punti);
        }
        puntiDiContattoUtensile[2] = punti[0];//Il vettore della geometria acquisisce l'ascissa del punto P2
        puntiDiContattoUtensile[3] = punti[1];//Il vettore della geometria acquisisce l'ordinata del punto P2
        //Queste 2 celle con coordinate a zero, daranno il limite alla funzione che sarà chiamata dopo
        puntiDiContattoUtensile[4] = 0;//Serve per dare il limite alla funzione successiva
        puntiDiContattoUtensile[5] = 0;//Serve per dare il limite alla funzione successiva
        //Settaggio dei parametri in base al raggio utensile
        gradiDalNumeroLobi *= 2.0;//Ripristino dei gradi in base al numero dei lobi
        creaGeometriaDaPunti(false, false, verificaRaggioCirconferenzaConcava, puntiDiContattoUtensile, numeroLobi - 1, gradiDalNumeroLobi, puntiDiContattoUtensile);
        //Calcolo dei movimenti in Z e profondità d'estrusione della geometria torx
        zIncr = coordSup;//Assegno come valore iniziale della Z incrementale la coordinata di superficie
        zEnd += coordSup;//Calcolo della coordinata Z di arrivo dell'utensile
    
                                //Output
        //Salvataggio dati sul desktop in un file di testo
        if (salvataggio == true) {
            //torxMaschio = fopen("C:\\Users\\ASUS\\Desktop\\Torx maschio.txt", "w");//Apertura del file .doc sul desktop
            fopen_s(&torxMaschio, "C:\\Users\\User\\Desktop\\Torx maschio.txt", "w");//Apertura del file .doc sul desktop
            if (torxMaschio == NULL) {
                perror("Errore in apertura del file");
                exit(1);
            }
        }
    
        cout << endl;
        cout << endl << "M105";//Disattiva la rotazione del mandrino principale
        if (salvataggio == true)
            fprintf(torxMaschio, "M105");//Salvataggio sul file
        cout << endl << "M811";//Attiva rotazione del pneumatico
        if (salvataggio == true)
            fprintf(torxMaschio, "\nM811");//Salvataggio sul file
        cout << endl << "G4 X2";//Sosta di 2 secondi
        if (salvataggio == true)
            fprintf(torxMaschio, "\nG4 X2");//Salvataggio sul file
        cout << endl << "G1 X2=29 Y2=0 G100 T37";//Chiamata del numero utensile con relativo posizionamento rapido in zona XY di sicurezza
        if (salvataggio == true)
            fprintf(torxMaschio, "\nG1 X2=29 Y2=0 G100 T37");//Salvataggio sul file
        cout << endl << "G1 Z2=90 G100";//Posizionamento rapido in zona di sicurezza in Z
        if (salvataggio == true)
            fprintf(torxMaschio, "\nG1 Z2=90 G100");//Salvataggio sul file
        cout << endl << "M119 Q" << asseC;//Orientamento della geometria
        if (salvataggio == true)
            fprintf(torxMaschio, "\nM119 Q%.4lf", asseC);//Salvataggio sul file
        cout << endl << "G902 P1=" << riduciFile;//Comando che riduce la dimensione del file d'uscita
        if (salvataggio == true)
            fprintf(torxMaschio, "\nG902 P1=%d", riduciFile);//Salvataggio sul file
        cout << endl << "G1 Z2=" << coordSup + gapSicurezza << " G100";//Primo posizionamento dell'utensile in Z in zona di sicurezza
        if (salvataggio == true)
            fprintf(torxMaschio, "\nG1 Z2=%.4lf G100", coordSup + gapSicurezza);//Salvataggio sul file
        cout << endl << "G1 X2=" << (dGrezzo * 2.0) << " G100";//Posizionamento rapido in zona di sicurezza in X
        if (salvataggio == true)
            fprintf(torxMaschio, "\nG1 X2=%.4lf G100", (dGrezzo * 2.0));//Salvataggio sul file
        while (zIncr <= zEnd) {
            zIncr += passoZ;//Incremento della Z in base al passo impostato dall'utente
            //Condizione che limita la Z incrementale alla massima profondità
            if (zIncr >= zEnd)
                zIncr = zEnd;
            cout << endl << endl << endl << "G1 Z2=-" << zIncr << " F5000 G94";//Posizionamento dell'utensile in Z
            if (salvataggio == true)
                fprintf(torxMaschio, "\nG1 Z2=-%.4lf F5000 G94", zIncr);//Salvataggio sul file
            for (a = 0; a <= limite; a += 2)
                if (a == 0) {
                    cout << endl << "G1 X2=" << (puntiDiContattoUtensile[a] * 2.0) << " F" << f << " G94 G42";
                    if (salvataggio == true)
                        fprintf(torxMaschio, "\nG1 X2=%.4lf F%.0f G94 G42", puntiDiContattoUtensile[a] * 2.0, f);//Salvataggio sul file
                }
                else
                    if ((a % 4 == 0) && (verificaRaggioCirconferenzaConcava == true)) {
                        b = 2;//Interpolazione circolare concava
                        cout << endl << "G" << b << " X2=" << (puntiDiContattoUtensile[a] * 2.0) << " Y2=" << puntiDiContattoUtensile[a + 1] << " R" << circonferenzaConcava[2];
                        if (salvataggio == true)
                            fprintf(torxMaschio, "\nG%d X2=%.4lf Y2=%.4lf R%.4lf", b, puntiDiContattoUtensile[a] * 2.0, puntiDiContattoUtensile[a + 1], circonferenzaConcava[2]);//Salvataggio sul file
                    }
                    else {
                        b = 3;//Interpolazione circolare convessa
                        if (a == limite) {
                            puntiDiContattoUtensile[a] = puntiDiContattoUtensile[0];//puntiDiContattoUtensile[2]
                            puntiDiContattoUtensile[a + 1] = puntiDiContattoUtensile[1];//puntiDiContattoUtensile[3]
                        }
                        cout << endl << "G" << b << " X2=" << (puntiDiContattoUtensile[a] * 2) << " Y2=" << puntiDiContattoUtensile[a + 1] << " R" << lobo[2];
                        if (salvataggio == true)
                            fprintf(torxMaschio, "\nG%d X2=%.4lf Y2=%.4lf R%.4lf", b, puntiDiContattoUtensile[a] * 2.0, puntiDiContattoUtensile[a + 1], lobo[2]);//Salvataggio sul file
                    }
            cout << endl << "G1 Y2=" << puntiDiContattoUtensile[3];//Posizionamento rapido in Y0 dell'utensile in zona di sicurezza
            if (salvataggio == true)
                fprintf(torxMaschio, "\nG1 Y2=%.4lf", puntiDiContattoUtensile[3]);//Salvataggio sul file
            cout << endl << "G1 X2=" << dGrezzo * 2.0 << " F5000 G94";//Posizionamento rapido in X dell'utensile in zona di sicurezza
            if (salvataggio == true)
                fprintf(torxMaschio, "\nG1 X2=%.4lf F5000 G94", (dGrezzo * 2.0));//Salvataggio sul file
            cout << endl << "G40";//Annullamento compensazione automatica
            if (salvataggio == true)
                fprintf(torxMaschio, "\nG40");//Salvataggio sul file
            cout << endl << "G1 Y2=0 G100";//Posizionamento rapido in Y0 dell'utensile in zona di sicurezza
            if (salvataggio == true)
                fprintf(torxMaschio, "\nG1 Y2=0 G100");//Salvataggio sul file
                //Condizione che interrompe il ciclo ed esce
            if (zIncr == zEnd)
                break;
        }
        cout << endl << "G902";//Disattiva il codice G902 iniziale
        if (salvataggio == true)
            fprintf(torxMaschio, "\nG902");//Salvataggio sul file
    /*    cout<<endl<<"G1 Y2=0 G100";//Posizionamento rapido in Y0 dell'utensile in zona di sicurezza
        if(salvataggio == true)
            fprintf(torxMaschio,"\nG1 Y2=0 G100");//Salvataggio sul file
        cout<<endl<<"G1 X2=29 G100";//Svincolo dell'utensile in Z
        if(salvataggio == true)
            fprintf(torxMaschio,"\nG1 X2=29 G100");//Salvataggio sul file*/
        cout << endl << "G1 Z2=90 G100";//Svincolo dell'utensile in Z
        if (salvataggio == true)
            fprintf(torxMaschio, "\nG1 Z2=90 G100");//Salvataggio sul file
        cout << endl << "M812";//Disattiva la rotazione del pneumatico
        if (salvataggio == true)
            fprintf(torxMaschio, "\nM812");//Salvataggio sul file
    
        if (salvataggio == true) {
            fclose(torxMaschio);//Chiusura del file di testo di salvataggio
            cout << endl << endl << endl << "File di testo salvato sul desktop...";
        }
    
        fflush(stdin);
        getchar();
        return 0;
    }
    
  • Re: Errore di compilazione per creazione file di testo

    Parte 2 (appena sotto)
    
    /*Funzione che crea un pattern in un vettore di punti formando una geometria.
    Parametri:
        -pianoVista-> seleziona il piano di lavoro su cui giace la geometria:
            false = XY, YZ;
            true = XZ;
        -sensoPolare:
            false = le coordinate dei punti sono sistemati nel vettore in senso antiorario;
            true = le coordinate dei punti sono sistemati nel vettore in senso orario;
        -esistenzaRaccordo-> in realtà indica alla funzione se la figura è formata dal doppio dei punti nel caso in cui per esempio
                            il raggio utensile è >= ad un raccordo o ad una circonferenza concava:
            false = indica che il raccordo non c'è (il raggio utensile è >= al raccordo o a circonferenza concava);
            true = indica che il raccordo c'è;
        -coordinatePuntiIniziali-> indica i punti da cui partire per formare il pattern geometrico;
                                IMPORTANTE: dopo l'ultimo punto, dare al punto successivo le coordinate (0;0), questo per dare un limite alla funzione;
        -numeroCopiePunti-> indica quante copie dei punti messi devono essere fatti, ricordarsi di mettere il numero esatto meno 1, che compone la geometria:
                            per esempio per un esagono: 6 - 1;
        -gradiIncrementali-> gradi incrementali usati per polarizzare i punti iniziali (Valori in gradi sempre maggiori di zero):
                            per esempio per un esagono: 60°;
        -geometria-> vettore di output che contiene le coordinate dei punti di costruzione della geometria.*/
    void creaGeometriaDaPunti(bool pianoVista, bool sensoPolare, bool esistenzaRaccordo, double* coordinatePuntiIniziali, short int numeroCopiePunti, double gradiIncrementali, double* geometria) {
        //Dichiarazione delle variabili locali
        double datiDiInput[10] = {};//datiDiInput == coordinatePuntiIniziali
        short int contatoreCelle = 2;//Contatore di posizionamento celle
        short int numeroPuntiIniziali = 0;//Contatore dei numero di punti iniziali che formano la geometria
        short int selezionaPunto = 0;//Posizione della cella da passare alla funzione polarizzaPunto per il calcolo dei punti
        double punto[2] = {};
        //Elaborazione
        while (coordinatePuntiIniziali[contatoreCelle] != 0 && coordinatePuntiIniziali[contatoreCelle + 1] != 0) {
            datiDiInput[contatoreCelle] = coordinatePuntiIniziali[contatoreCelle];
            datiDiInput[contatoreCelle + 1] = coordinatePuntiIniziali[contatoreCelle + 1];
            numeroPuntiIniziali++;
            contatoreCelle += 2;
        }
        if (sensoPolare == true)
            gradiIncrementali = -gradiIncrementali;
        selezionaPunto = numeroPuntiIniziali * 2;//Calcolo delle posizioni
        numeroCopiePunti++;//Incremento unario del numero delle copie dei punti iniziali inseriti
        numeroCopiePunti *= 2;//Doppio prodotto del numero di celle perchè ogni punto è definito da 2 valori
        if (esistenzaRaccordo == true)
            numeroCopiePunti *= selezionaPunto;//Nel caso in cui esiste un raccordo tra 2 punti
        selezionaPunto = -selezionaPunto;//Calcolo delle posizioni
        for (contatoreCelle = 2; contatoreCelle <= numeroCopiePunti; contatoreCelle += 2)
            if (contatoreCelle <= (numeroPuntiIniziali * 2)) {
                geometria[contatoreCelle] = datiDiInput[contatoreCelle];//Assegnazione ascissa dei primi punti della geometria
                if (sensoPolare == false)
                    geometria[contatoreCelle + 1] = datiDiInput[contatoreCelle + 1];//Assegnazione ordinata dei primi punti della geometria
                else
                    geometria[contatoreCelle + 1] = -datiDiInput[contatoreCelle + 1];//Assegnazione ordinata dei primi punti della geometria
            }
            else {
                if (esistenzaRaccordo == true)
                    if (selezionaPunto < 0) {
                        selezionaPunto = -selezionaPunto;//Cambio di segno
                        punto[0] = datiDiInput[selezionaPunto];
                        if (sensoPolare == false)
                            punto[1] = -datiDiInput[selezionaPunto + 1];
                        else
                            punto[1] = datiDiInput[selezionaPunto + 1];
                        selezionaPunto = -selezionaPunto;//Ripristino del segno originario
                    }
                    else {
                        punto[0] = geometria[selezionaPunto];
                        punto[1] = geometria[selezionaPunto + 1];
                    }
                else {
                    punto[0] = geometria[contatoreCelle - 2];
                    punto[1] = geometria[contatoreCelle - 1];
                }
                polarizzaPunto(pianoVista, punto, gradiIncrementali, 1, punto);
                geometria[contatoreCelle] = punto[0];//Assegnazione nel vettore geometrico del valore ascissa calcolato
                geometria[contatoreCelle + 1] = punto[1];//Assegnazione nel vettore geometrico del valore ordinata calcolato
                if (esistenzaRaccordo == true) {
                    selezionaPunto += 2;//Doppio incremento del selezionatore punto
                    if (selezionaPunto == 0)
                        selezionaPunto = 2;//Nuova inizializzazione
                }
            }
    }
    
    /*Funzione--> che restituisce le coordinate dei punti polari di un punto.*/
    void polarizzaPunto(bool pianoVista, double* coordinate, double angolo, short int numeroPunti, double* coordinatePolarizzate) {
        short int contatorePosizionePunto = 1;
        double ascissa = 0, ordinata = 0;
        double distanzaOrigine = 0;
        double teta = 0;
        //Elaborazione
        ascissa = coordinate[0];
        ordinata = coordinate[1];
        angolo = radianti(angolo);
        distanzaOrigine = teoremaPitagora(true, ascissa, ordinata);//Calcolo della distanza del punto dall'origine
        if (ascissa == 0) {
            if (pianoVista == false) {
                if (ordinata > 0)
                    teta = M_PI * 0.5;//90°
                else
                    teta = M_PI * 1.5;//270°
            }
            else {
                if (ordinata > 0)
                    teta = 0;//0°
                else
                    teta = M_PI;//180°
            }
        }
        else {
            teta = ordinata / ascissa;//Calcolo dell'angolo che forma la retta OriginePunto rispetto all'ascissa
            teta = atan(teta);
            if (pianoVista == false) {
                if (ascissa < 0)
                    teta = M_PI + teta;//180°+teta
            }
            else {
                if (ascissa > 0)
                    teta = (M_PI * 0.5) - teta;//90°-teta
                else
                    teta = (M_PI * 1.5) - teta;//270°-teta
            }
        }
        for (short int i = 0; i < (numeroPunti * 2); i++) {
            if (i % 2 == 0) {//Calcolo del valore dell'ascissa
                if (i >= 2) {
                    contatorePosizionePunto++;
                    angolo *= contatorePosizionePunto;
                }
                angolo += teta;//Incremento dell'angolo teta dell'angolo inserito
                if (pianoVista == false)
                    coordinatePolarizzate[i] = distanzaOrigine * cos(angolo);
                else
                    coordinatePolarizzate[i] = distanzaOrigine * sin(angolo);
            }
            else {//Calcolo del valore dell'ordinata
                if (pianoVista == false)
                    coordinatePolarizzate[i] = distanzaOrigine * sin(angolo);
                else
                    coordinatePolarizzate[i] = distanzaOrigine * cos(angolo);
                angolo -= teta;//Decremento dell'angolo teta dell'angolo inserito
                if (i >= 3)
                    angolo /= contatorePosizionePunto;
            }
            if (coordinatePolarizzate[i] <= 0.0001 && coordinatePolarizzate[i] >= -0.0001)
                coordinatePolarizzate[i] = 0;
        }
    }
    
  • Re: Errore di compilazione per creazione file di testo

    Ok si grazie, perchè prima volevo selezionare il main, invece ho selezionato la libreria che utilizzo...
  • Re: Errore di compilazione per creazione file di testo

    Se hai errori devi sempre leggere la descrizione nella lista dato che possono essere diversi.

    Ovviamente la riga che ti ho proposto risolve la questione fopen ma non tutti gli altri.
Devi accedere o registrarti per scrivere nel forum
11 risposte