:OK) :OK) :OK) :OK) :OK) :OK) :OK) :OK) :OK) :OK) :OK) :OK) :OK) :OK) :OK)InterNik":18b3y1wy ha detto:
quesito per qualcuno che sa programmare in c++
- Autore discussione mezzostordito
- Data d'inizio
Un' altra domanda
Ho visto che quelli di ing informatica nel main mettono una casino di cose
nel senso
main(bla bla bla)
come funziona mettere le cose al posto di dove io ho messo bla bla bla???
Ho visto che quelli di ing informatica nel main mettono una casino di cose
nel senso
main(bla bla bla)
come funziona mettere le cose al posto di dove io ho messo bla bla bla???
mezzostordito":vkcnabh0 ha detto:
Al posto del bla bla bla nelle funzioni che li richiedono ci vanno i parametri.
:OK)
mezzostordito":257g39nd ha detto:FlorianoL":257g39nd ha detto:mezzostordito":257g39nd ha detto:ma sto goto è bellissimo ne ho usati una ventina nel programma alla fine al posto dei contatori uno spettacolo si risolve tutto in un attimo
il goto è come tirarsi la zappa sui piedi... forse nei programmi semplici vale la pena usarlo, ma come ti hanno già detto un programma con i goto è poco leggibile e spesso provoca qualche problemino quando la complesità aumenta...
abbasso i goto!! :asd)
l'ho usato al posto di un contatore nel senso che dopo che aveva fatto un un' operazione andava alla fine del programma senza piu dover calcolare il resto
ho capito la semplicità del tuo caso, ma cmq se vuoi un consiglio, per imparare a programmae BENE evitalo come la peste... :asd)
Meglio non abituarsi all'utilizzo di una porcheria simile.... :cesso)
Era la cosa che ti avevo fatto notare fin dall'inizio.mezzostordito":1h5nrkbo ha detto:
Un programma C "vecchio-stile" ha una funzione "speciale" main che ha questo formato
int main(int argc, char *argv[]);
Ovvero e' una funzione (ritorna un valore intero), e due parametri, argc che sono quanti parametri a riga di comando ci sono, argv che sono i parametri stessi (il secondo e' in pratica un char **, ovvero un puntatore a puntatori di caratteri. Se non sei molto "abituato" e' una sorta di vettore di stringhe-C, ovvero terminate con uno zero)
Tanto per capirci prova
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
while(argc--)
printf("%s\n", *argv++);
exit(0);
}
Usualmente argc e' sempre > di zero, in argv da zero ad argc-1 ci sono i puntatori ai parametri; argv[0] usualmente e' il nome del programma stesso (con tanto di path, sotto Windows)
altro esempietto (codificato per essere chiaro, non per essere "ben scritto": alloca un int per il for inutile, ritorna sempre zero etc.etc, giusto
per darti un'idea)
int main(int argc, char *argv[])
{
int i;
/* Se non ci sono parametri */
if (argc<=1)
{
printf("\nSuperprogramma-147\r\n\r\n");
printf("Parametri : [che-ne-so]\n");
printf("Esempio : \n");
}
else /* Ci sono parametri */
for (i=1;i<argc;i++)
fai_qualcosa(argv);
return 0;
}
---
Se vuoi dichiarare che NON ritorni valori (sono numeri che possono essere letti da file batch) tipicamente si mette un
void main(...) con cui dichiari che main NON ritorna nulla.
Spero di esserti stato d'aiuto...
mezzostordito":11wsrfdy ha detto:
Un po' di chiarezza, và.
1) Il goto è visto come "il male" assoluto da praticamente tutti i docenti di informatica. Questo è basato, a mio parere, dal fatto che una buona parte ha studiato su "algoritmi e strutture dati" di Niklaus Wirth, secondo il quale il goto è una creazione di Satana.
2) E' verissimo che non serve mai, con un linguaggio strutturato, utilizzaro (nel senso "indispensabile")
3) E' verissimo che puo' rappresentare un elemento difficile da decifrare, all'interno del codice
4) Visto che sei alle primissime armi, non usarlo mai.
Questo è lo stato per, diciamo così, il "programmatore junior".
Poi c'è il programmatore "senior" (se preferisci smaliziato), per il quale
1) Ci sono linguaggi di programmazione (es. assembler) in cui il goto e' praticamente obbligatorio (in verita' solo nella versione "lunga", cmq non approfondiamo)
2) Lo si usa praticamente sempre, sia come "trucco" (exit anticipato di una procedura, tipico per il test dei parametri), sia come vero e prorio jmp assembler. Perchè il programma, scritto nel linguaggio che vuoi senza goto, alla fine diventa... codice macchina, nel quale i goto abbondano.
3) Se un programma e' scritto bene e' ben leggibile sia che usi i goto sia che non li usi (non e' il goto che determina la qualita' del software)
4) E' un po'... tanto per capirci... come il freno a mano. A scuola guida ti dicono, giustamente, che serve come freno di stazionamento. Se vedi un pilota rally ti rendi conto che puo' essere usato come un vero e proprio "trucchetto" per... fare le curve anche su asciutto!
Certo, se all'esame per la patente quando ti chiedono "a cosa serve il freno a mano" tu rispondi "per curvare" rischi concretamente di essere bocciato.
Spero di essermi spiegato (??): tu fatti furbo e non usarlo mai. Tra una decina di anni, magari, ti renderai conto che cio' che insegnano non necessariamente e' il modo "migliore" per fare le cose.
Posta il frammento di codice che dici che ti mostro come va scritto per fare "bella figura", che e' la cosa che poi ti interessa! :OK)
Ok io lo posto ma è diventato un vero e propro casino incredibile non ci capisco piu nulla nemmeno io
Non vi spaventatehmamma) hmamma) hmamma) hmamma)
Dovevo dare 2 punti su una retta nel piano 2 su un'altra retta poi lui doveva scrivere le rette in forma cartesiana dire se sono parallele incidenti e perpendicolari e dove si incontrano
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
int main()
{
signed int x1,x2,y1,y2,x3,y3,x4,y4,h,q,k,i;
float m1,m2,a,b,c,d,xp,yp,q1a,q1b,q2a,q2b,q1,q2;
printf("PUNTI SULLA PRIMA RETTA\n\n\n");
printf("Inserire la x del primo punto: ");
scanf("%d",&x1);
printf("Inserire la y del primo punto: ");
scanf("%d",&y1);
printf("Inserire la x del secondo punto: ");
scanf("%d",&x2);
printf("Inserire la y del secondo punto: ");
scanf("%d",&y2);
system("cls");
printf("PUNTI SULLA SECONDA RETTA\n\n\n");
printf("Inserire la x del primo punto: ");
scanf("%d",&x3);
printf("Inserire la y del primo punto: ");
scanf("%d",&y3);
printf("Inserire la x del secondo punto: ");
scanf("%d",&x4);
printf("Inserire la y del secondo punto: ");
scanf("%d",&y4);
system("cls");
a=(x1-(x2));
b=(x3-(x4));
c=(y1-(y2));
d=(y3-(y4));
m1=c/a;
m2=d/b;
//equazione della prima retta
q1a=y1-m1*x1;
q1b=y2-m1*x2;
if(q1a==q1b)
{
q1=q1a=q1b;
printf("EQUAZIONE DELLA PRIMA RETTA: \n\n");
q=0;
k=0;
i=0;
//a=0 la prima retta è verticale
if(a==0)
{
printf("x = %d",x1);
q=1;
i=1;
goto eq2;
}
printf("y = ");
if(m1==0)
{
printf("");
goto q;
}
if(m1==1)
{
printf("x ");
i=1;
goto q;
}
if(m1==-1)
{
printf("- x ");
i=1;
goto q;
}
if(m1>0,m1!=1)
{
printf("+ %fx ",m1);
i=1;
goto q;
}
if(m1<0,m1!=-1)
{
m1=-m1;
printf("- %fx ",m1);
i=1;
}
//calcolo del q della prima retta
q:
if((q1==0)&&(i==1))
{
printf("");
goto eq2;
}
else if ((q1==0)&&(i==0))
{
printf("0");
goto eq2;
}
if(q1<0)
{
q1=-q1;
printf("- %f",q1);
goto eq2;
}
if(q1>0)
{
printf("+ %f",q1);
goto eq2;
}
}
else
printf("Errore 01\n");
//equazione della seconda retta
eq2:
q2a=y3-m2*x3;
q2b=y4-m2*x4;
if(q2a==q2b)
{
q2=q2a=q2b;
printf("\n\nEQUAZIONE DELLA SECONDA RETTA: \n\n");
// b=0 la seconda è verticale
int j;
j=0;
if(b==0)
{
printf("x = %d\n\n",x3);
j=1;
k=2;
goto controlli;
}
// inizia a scrivere la seconda se non è verticale
printf("y = ");
if(m2==1)
{
printf("x");
goto q1;
}
if(m2==-1)
{
printf("- x");
goto q1;
}
if(m2!=1,m2>0)
{
printf("+ %fx");
j=1;
goto q1;
}
if(m2!=-1,m2<0)
{
m2=-m2;
printf("- %fx",m2);
j=1;
goto q1;
}
if(m2==0)
{
printf("");
h=1;
goto q1;
}
if(m2==1)
{
printf("x ");
goto q1;
}
if(m2==-1)
{
printf("- x ");
goto q1;
}
if(m2>0,m2!=1)
{
printf("+ %fx ",m2);
j=1;
goto q1;
}
if(m2<0,m2!=-1)
{
m2=-m2;
printf("- %fx ",m2);
j=1;
goto q1;
}
//calcolo del q della seconda retta
q1:
if((q2==0)&&(j==1))
{
printf("");
goto controlli;
}
else if ((q2==0)&&(j==0))
{
printf("0");
goto controlli;
}
if(h==1,q2==0)
{
printf("");
goto controlli;
}
if(h==1,q2>0)
{
printf(" + %f",q2);
goto controlli;
}
if(h==1,q2<0)
{
q2=-q2;
printf(" - %f",q2);
goto controlli;
}
if(q2<0,q2!=-1)
{
q2=-q2;
printf(" - %f",q2);
goto controlli;
}
if(q2>0,q2!=1)
{
printf(" + %f",q2);
goto controlli;
}
if(q2==0)
{
printf("");
}
}
else
printf("Errore 01\n");
controlli:
//verifica se sono coincidenti
if((m1==m2)&&(q1==q2))
{
printf("\n\nLe rette sono coincidenti infatti hanno equazioni uguali\n\n");
goto vaffanculo;
}
//q==1 e k==2 tutte e 2 le rette sono verticali e quindi parallele
if((q==1)&&(k==2))
{
printf("\n\nle rette sono parallele\n\n");
goto vaffanculo;
}
//verifica se sono parallele
if((a==0)&&(b==0))
{
printf("\n\nle rette sono parallele\n\n");
goto vaffanculo;
}
m1=c/a;
m2=d/b;
h=0;
if(m1==m2)
{
printf("\n\nLe rette sono parallele\n\n");
h=1;
}
else
//rette perpendicolari e incidenti
if(m1==(-1/m2)||m2==(-1/m1))
{
xp=((-q2+q1)/(m2-m1));
yp=(m2*xp)+q2;
if((m1==0)&&(i==0))
{
xp=x1;
yp=q1;
}
else
{
xp=x2;
yp=q2;
}
printf("\n\nLe rette sono perpendicolari e si incontrano nel punto P di coordinate:\n\n");
printf("P(%f,%f)\n\n",xp,yp);
h=1;
goto vaffanculo;
}
else
{
if(h==0)
xp=((-q2+q1)/(m2-m1));
yp=(m2*xp)+q2;
printf("\n\nLe rette sono incidenti e si incontrano nel punto P di coordinate:\n\n");
printf("P(%f,%f)\n\n",xp,yp);
goto vaffanculo;
}
//una verticale e una qualsiasi
if((q==1)&&(k!=2))
{
xp=x1;
yp=m2*x1+q2;
printf("\n\nLe rette sono incidenti e si incontrano nel punto P di coordinate:\n\n");
printf("P(%f,%f)\n\n",xp,yp);
goto vaffanculo;
}
if((q==1)&&(k!=2))
{
xp=x3;
yp=m1*x3+q1;
printf("\n\nLe rette sono incidenti e si incontrano nel punto P di coordinate:\n\n");
printf("P(%f,%f)\n\n",xp,yp);
}
vaffanculo:
system("pause");
}
Non vi spaventate
hmamma) hmamma) hmamma) hmamma) Dovevo dare 2 punti su una retta nel piano 2 su un'altra retta poi lui doveva scrivere le rette in forma cartesiana dire se sono parallele incidenti e perpendicolari e dove si incontrano
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
int main()
{
signed int x1,x2,y1,y2,x3,y3,x4,y4,h,q,k,i;
float m1,m2,a,b,c,d,xp,yp,q1a,q1b,q2a,q2b,q1,q2;
printf("PUNTI SULLA PRIMA RETTA\n\n\n");
printf("Inserire la x del primo punto: ");
scanf("%d",&x1);
printf("Inserire la y del primo punto: ");
scanf("%d",&y1);
printf("Inserire la x del secondo punto: ");
scanf("%d",&x2);
printf("Inserire la y del secondo punto: ");
scanf("%d",&y2);
system("cls");
printf("PUNTI SULLA SECONDA RETTA\n\n\n");
printf("Inserire la x del primo punto: ");
scanf("%d",&x3);
printf("Inserire la y del primo punto: ");
scanf("%d",&y3);
printf("Inserire la x del secondo punto: ");
scanf("%d",&x4);
printf("Inserire la y del secondo punto: ");
scanf("%d",&y4);
system("cls");
a=(x1-(x2));
b=(x3-(x4));
c=(y1-(y2));
d=(y3-(y4));
m1=c/a;
m2=d/b;
//equazione della prima retta
q1a=y1-m1*x1;
q1b=y2-m1*x2;
if(q1a==q1b)
{
q1=q1a=q1b;
printf("EQUAZIONE DELLA PRIMA RETTA: \n\n");
q=0;
k=0;
i=0;
//a=0 la prima retta è verticale
if(a==0)
{
printf("x = %d",x1);
q=1;
i=1;
goto eq2;
}
printf("y = ");
if(m1==0)
{
printf("");
goto q;
}
if(m1==1)
{
printf("x ");
i=1;
goto q;
}
if(m1==-1)
{
printf("- x ");
i=1;
goto q;
}
if(m1>0,m1!=1)
{
printf("+ %fx ",m1);
i=1;
goto q;
}
if(m1<0,m1!=-1)
{
m1=-m1;
printf("- %fx ",m1);
i=1;
}
//calcolo del q della prima retta
q:
if((q1==0)&&(i==1))
{
printf("");
goto eq2;
}
else if ((q1==0)&&(i==0))
{
printf("0");
goto eq2;
}
if(q1<0)
{
q1=-q1;
printf("- %f",q1);
goto eq2;
}
if(q1>0)
{
printf("+ %f",q1);
goto eq2;
}
}
else
printf("Errore 01\n");
//equazione della seconda retta
eq2:
q2a=y3-m2*x3;
q2b=y4-m2*x4;
if(q2a==q2b)
{
q2=q2a=q2b;
printf("\n\nEQUAZIONE DELLA SECONDA RETTA: \n\n");
// b=0 la seconda è verticale
int j;
j=0;
if(b==0)
{
printf("x = %d\n\n",x3);
j=1;
k=2;
goto controlli;
}
// inizia a scrivere la seconda se non è verticale
printf("y = ");
if(m2==1)
{
printf("x");
goto q1;
}
if(m2==-1)
{
printf("- x");
goto q1;
}
if(m2!=1,m2>0)
{
printf("+ %fx");
j=1;
goto q1;
}
if(m2!=-1,m2<0)
{
m2=-m2;
printf("- %fx",m2);
j=1;
goto q1;
}
if(m2==0)
{
printf("");
h=1;
goto q1;
}
if(m2==1)
{
printf("x ");
goto q1;
}
if(m2==-1)
{
printf("- x ");
goto q1;
}
if(m2>0,m2!=1)
{
printf("+ %fx ",m2);
j=1;
goto q1;
}
if(m2<0,m2!=-1)
{
m2=-m2;
printf("- %fx ",m2);
j=1;
goto q1;
}
//calcolo del q della seconda retta
q1:
if((q2==0)&&(j==1))
{
printf("");
goto controlli;
}
else if ((q2==0)&&(j==0))
{
printf("0");
goto controlli;
}
if(h==1,q2==0)
{
printf("");
goto controlli;
}
if(h==1,q2>0)
{
printf(" + %f",q2);
goto controlli;
}
if(h==1,q2<0)
{
q2=-q2;
printf(" - %f",q2);
goto controlli;
}
if(q2<0,q2!=-1)
{
q2=-q2;
printf(" - %f",q2);
goto controlli;
}
if(q2>0,q2!=1)
{
printf(" + %f",q2);
goto controlli;
}
if(q2==0)
{
printf("");
}
}
else
printf("Errore 01\n");
controlli:
//verifica se sono coincidenti
if((m1==m2)&&(q1==q2))
{
printf("\n\nLe rette sono coincidenti infatti hanno equazioni uguali\n\n");
goto vaffanculo;
}
//q==1 e k==2 tutte e 2 le rette sono verticali e quindi parallele
if((q==1)&&(k==2))
{
printf("\n\nle rette sono parallele\n\n");
goto vaffanculo;
}
//verifica se sono parallele
if((a==0)&&(b==0))
{
printf("\n\nle rette sono parallele\n\n");
goto vaffanculo;
}
m1=c/a;
m2=d/b;
h=0;
if(m1==m2)
{
printf("\n\nLe rette sono parallele\n\n");
h=1;
}
else
//rette perpendicolari e incidenti
if(m1==(-1/m2)||m2==(-1/m1))
{
xp=((-q2+q1)/(m2-m1));
yp=(m2*xp)+q2;
if((m1==0)&&(i==0))
{
xp=x1;
yp=q1;
}
else
{
xp=x2;
yp=q2;
}
printf("\n\nLe rette sono perpendicolari e si incontrano nel punto P di coordinate:\n\n");
printf("P(%f,%f)\n\n",xp,yp);
h=1;
goto vaffanculo;
}
else
{
if(h==0)
xp=((-q2+q1)/(m2-m1));
yp=(m2*xp)+q2;
printf("\n\nLe rette sono incidenti e si incontrano nel punto P di coordinate:\n\n");
printf("P(%f,%f)\n\n",xp,yp);
goto vaffanculo;
}
//una verticale e una qualsiasi
if((q==1)&&(k!=2))
{
xp=x1;
yp=m2*x1+q2;
printf("\n\nLe rette sono incidenti e si incontrano nel punto P di coordinate:\n\n");
printf("P(%f,%f)\n\n",xp,yp);
goto vaffanculo;
}
if((q==1)&&(k!=2))
{
xp=x3;
yp=m1*x3+q1;
printf("\n\nLe rette sono incidenti e si incontrano nel punto P di coordinate:\n\n");
printf("P(%f,%f)\n\n",xp,yp);
}
vaffanculo:
system("pause");
}
InterNik":3jw8yvj4 ha detto:
tranquillo non ti preoccupare non ci sono assolutamente problemi....non c'è nessuna fretta :OK) :OK) :OK) :OK) :OK)
// questo e' un programma-C in stile simil-C++, ovvero con una logica vicina
// a quella che si utilizza in C++ con gli oggetti, i costruttori, metodi etc
// mi hai chiesto la versione C, quindi non ho utilizzato classi. Spero tuttavia
// che renda l'idea di "come" si ragiona.
// Nelle more segnalo che il funzionamento dal punto di vista matematico non e'
// certo (non ho provato tutte le possibilita')!
// Spesso non ho usato forme "furbe" che sarebbero state troppo a scapito della
// leggiblita'
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
using namespace std;
double eps=0.0001; // definiamo un concetto approssimato di "zero"
// la struttura (=miniclasse) punto modella un punto reale. Il flag valido
// serve come flag nei casi in cui NON rappresenti un punto reale
struct punto
{
double x;
double y;
int valido; // se non vero il punto ha coordinate non reali
};
// la retta viene caratterizzata da due punti (anche se in verita' dal punto di vista
// "serio" e' sbagliato, la retta ha solo tre parametri a,b,c (ax+by+c=0)
// e quindi non ha senso metterci dentro "due" punti. Bisognerebbe lasciarli fuori
// ed, eventualmente, "ricrearli" alla bisogna. Questo, dal punto di vista C++, e' un
// errore GRAVE. Dal punto di vista-C... puoi fare come vuoi, e questo e' un programma
// C
struct retta
{
punto punto1; // mmmhhh...
punto punto2;
double delta_x;
double delta_y;
double m; // memorizzazione in formato cartesiano
double q;
int Verticale; // attenzione questo flag implica b=0!
int Orizzontale;
};
// questo e' una sorta di... costruttore C++ in C.
// la strategia e'... quick-and-dirty. In C++ sarebbe ben diversa, col costruttore
// di default, quello di copia, etc.etc. Inoltre uso un puntatore alla retta, mentre
// in C++ avrei usato un riferimento. Cmq...
void costruttoreRetta(retta* miaRetta, double x1,double y1,double x2,double y2)
{
(*miaRetta).punto1.x=x1;
(*miaRetta).punto2.x=x2;
(*miaRetta).punto1.y=y1;
(*miaRetta).punto2.y=y1;
(*miaRetta).m=0; // ridondante, messo per "buona abitudine2
(*miaRetta).q=0; // ridondante
(*miaRetta).delta_x=x2-x1;
(*miaRetta).delta_y=y2-y1;
(*miaRetta).Orizzontale = int ( fabs((*miaRetta).delta_y)<eps);
(*miaRetta).Verticale = int ( fabs((*miaRetta).delta_x)<eps);
if ((*miaRetta).Verticale)
{
(*miaRetta).q=x1; //la retta e' verticale
(*miaRetta).m=0;
}
else
if ((*miaRetta).Orizzontale)
{
(*miaRetta).q=y1; // la retta e' orizzontale (mi basterebbe sapere m=0
(*miaRetta).m=0; // quindi e' ridondante, solo per comodita'
}
else
{ // retta "normale". A questo punto si vede bene
// che potrei togliere punto1 e punto2 dalla struct
// pero' li tengo lo stesso
(*miaRetta).m=(*miaRetta).delta_y/(*miaRetta).delta_x;
(*miaRetta).q=y1-(*miaRetta).m*x1;
}
}
// questo e' un simil-metodo C++ che converte una retta in una stringa, discriminando
// i 3 casi diversi. Bisognerebbe aggiungervi dei controlli sul bufferOutput (e' null?)
// sull'inizializzazione di miaRetta etc.etc...
void trascriviRetta(retta miaRetta,char* bufferOutput)
{
if (miaRetta.Verticale)
sprintf(bufferOutput,"x=%+10.4f",miaRetta.q);
else
if (miaRetta.Orizzontale)
sprintf(bufferOutput,"y=%+10.4f",miaRetta.q);
else
sprintf(bufferOutput,"y=%+10.4fx %+10.4f",miaRetta.m,miaRetta.q);
}
// questa funzioncina verifica la condizione per le due rette. Nel caso C++
// avresti un unico parametro, l'altro implicito (this)
// anche qui, per facilita' di lettura, le condizioni sono tutte esplicitate
int perpendicolareA(retta retta1,retta retta2)
{
if ((retta1.Verticale && retta2.Orizzontale))
return 1;
else
if
(retta1.Orizzontale && retta1.Verticale)
return 1;
else
return int ( fabs(retta1.m- (-1.0/retta2.m))<eps);
}
// come sopra per la condizione di ||->tra l'altro serve per verificare se
// esiste una intersezione
int parallelaA(retta retta1,retta retta2)
{
if ((retta1.Verticale && retta2.Orizzontale))
return 0;
else
if
(retta1.Orizzontale && retta1.Verticale)
return 0;
else
return int (fabs(retta1.m-retta2.m)<eps);
}
// questa funzioncina calcola il punto (o almeno... spero! e' passata una
// vita da analisi I !!!) di intersezione.
// Verifica, prima, che questo esista.
punto calcolaIntersezione(retta retta1, retta retta2)
{
punto incontro;
incontro.valido=1; // per default il punto e' reale [qui ci vorrebbe il costruttore di default]
// e' superfluo ma meglio metterlo
if (parallelaA(retta1,retta2))
{
incontro.valido=0; // parallele -> no incontro
}
else
{
if (retta1.Verticale)
{
incontro.x=retta1.punto1.x;
incontro.y=retta2.m*incontro.x+retta2.q;
incontro.valido=1;
}
else
if (retta2.Verticale)
{
incontro.x=retta2.punto1.x;
incontro.y=retta1.m*incontro.x+retta1.q;
incontro.valido=0;
}
else
{
incontro.x=(retta1.q-retta2.q)/(retta2.m-retta1.m);
incontro.y=retta2.m*incontro.x+retta2.q;
incontro.valido=1;
}
}
return incontro;
}
// minimetodo di trascizione punto, anche qui senza controlli
void trascriviPunto(punto mioPunto,char* bufferOutput)
{
if (mioPunto.valido)
sprintf(bufferOutput,"x=%+10.4fx y=%+10.4f",mioPunto.x,mioPunto.y);
else
sprintf(bufferOutput,"PUNTO NON REALE");
}
// questo e' il main di un programma tipoco da console
// che ritorna un intero. come gia' detto argc e argv sono i parametri
// a riga di comando
int main(int argc, char *argv[])
{
double x1_1,y1_1, x2_1,y2_1;
double x1_2,y1_2, x2_2,y2_2;
// commento questa parte altrimenti si fatica a fare le prove!
/*
printf("PUNTI SULLA PRIMA RETTA\n\n\n");
printf("Inserire la x del primo punto: x1_1 ");
scanf("%deltay_2",&x1_1);
printf("Inserire la y del primo punto: y1_1 ");
scanf("%deltay_2",&y1_1);
printf("Inserire la x del secondo punto: x2_1 ");
scanf("%deltay_2",&x2_1);
printf("Inserire la y del secondo punto: y2_1 ");
scanf("%deltay_2",&y2_1);
system("cls");
printf("PUNTI SULLA SECONDA RETTA\n\n\n");
printf("Inserire la x del primo punto: (x1_2) ");
scanf("%deltay_2",&x1_2);
printf("Inserire la y del primo punto: (y1_2) ");
scanf("%deltay_2",&y1_2);
printf("Inserire la x del secondo punto: (x2_2) ");
scanf("%deltay_2",&x2_2);
printf("Inserire la y del secondo punto: (y2_2) ");
scanf("%deltay_2",&y2_2);
*/
x1_1=1; //1
y1_1=3; //3
x2_1=6; //6
y2_1=5; //5
x1_2=2; //2
y1_2=5; //5
x2_2=6; //6
y2_2=4; //4
retta retta1;
retta retta2;
int flagParallele; // logica falso (0), vero (altrimenti)
int flagPerpendicolari;
char stringaRetta[100]; // conversione in stringa di una retta
char stringaPunto[100]; // conversione in stringa di un punto
// creo le due rette in modo "simil-C++"
costruttoreRetta(&retta1,x1_1,y1_1,x2_1,y2_1);
costruttoreRetta(&retta2,x1_2,y2_2,x2_2,y2_2);
system("cls");
// stampo qualche informazione
printf("retta1 verticale %d\n",retta1.Verticale);
printf("retta2 verticale %d\n",retta1.Verticale);
printf("retta1 orizzonta %d\n",retta1.Orizzontale);
printf("retta2 orizzonta %d\n",retta1.Orizzontale);
// ed ora converto le rette nella rappresentazione a stringa
// (C++: incapsulamento, isolamento. In verita' avrei dovuto
// fare l'overload di un operatore (tipo <<) per scrivere su stream
// tipo cout. Ma questo e' un programma C!!!
trascriviRetta(retta1,stringaRetta);
printf("Equazione retta 1: %s\n",stringaRetta);
trascriviRetta(retta2,stringaRetta);
printf("Equazione retta 2: %s\n",stringaRetta);
flagPerpendicolari =perpendicolareA(retta1,retta2);
flagParallele =parallelaA(retta1,retta2);
printf("\n");
// calcolo il punto d'incontro. Se non esiste incontro.valido non e' "vero"
punto incontro;
incontro=calcolaIntersezione(retta1,retta2);
trascriviPunto(incontro,stringaPunto);
if (flagPerpendicolari)
printf("Sono perpendicolari\n");
else
printf("Non sono perpendicolari\n");
if (flagParallele)
printf("Sono parallele (nessun punto di incontro)\n");
else
{
printf("NON sono parallele\n");
printf("\n\n");
printf("punto di incontro %s\n",stringaPunto);
}
system("pause");
return EXIT_SUCCESS;
}
// a quella che si utilizza in C++ con gli oggetti, i costruttori, metodi etc
// mi hai chiesto la versione C, quindi non ho utilizzato classi. Spero tuttavia
// che renda l'idea di "come" si ragiona.
// Nelle more segnalo che il funzionamento dal punto di vista matematico non e'
// certo (non ho provato tutte le possibilita')!
// Spesso non ho usato forme "furbe" che sarebbero state troppo a scapito della
// leggiblita'
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
using namespace std;
double eps=0.0001; // definiamo un concetto approssimato di "zero"
// la struttura (=miniclasse) punto modella un punto reale. Il flag valido
// serve come flag nei casi in cui NON rappresenti un punto reale
struct punto
{
double x;
double y;
int valido; // se non vero il punto ha coordinate non reali
};
// la retta viene caratterizzata da due punti (anche se in verita' dal punto di vista
// "serio" e' sbagliato, la retta ha solo tre parametri a,b,c (ax+by+c=0)
// e quindi non ha senso metterci dentro "due" punti. Bisognerebbe lasciarli fuori
// ed, eventualmente, "ricrearli" alla bisogna. Questo, dal punto di vista C++, e' un
// errore GRAVE. Dal punto di vista-C... puoi fare come vuoi, e questo e' un programma
// C
struct retta
{
punto punto1; // mmmhhh...
punto punto2;
double delta_x;
double delta_y;
double m; // memorizzazione in formato cartesiano
double q;
int Verticale; // attenzione questo flag implica b=0!
int Orizzontale;
};
// questo e' una sorta di... costruttore C++ in C.
// la strategia e'... quick-and-dirty. In C++ sarebbe ben diversa, col costruttore
// di default, quello di copia, etc.etc. Inoltre uso un puntatore alla retta, mentre
// in C++ avrei usato un riferimento. Cmq...
void costruttoreRetta(retta* miaRetta, double x1,double y1,double x2,double y2)
{
(*miaRetta).punto1.x=x1;
(*miaRetta).punto2.x=x2;
(*miaRetta).punto1.y=y1;
(*miaRetta).punto2.y=y1;
(*miaRetta).m=0; // ridondante, messo per "buona abitudine2
(*miaRetta).q=0; // ridondante
(*miaRetta).delta_x=x2-x1;
(*miaRetta).delta_y=y2-y1;
(*miaRetta).Orizzontale = int ( fabs((*miaRetta).delta_y)<eps);
(*miaRetta).Verticale = int ( fabs((*miaRetta).delta_x)<eps);
if ((*miaRetta).Verticale)
{
(*miaRetta).q=x1; //la retta e' verticale
(*miaRetta).m=0;
}
else
if ((*miaRetta).Orizzontale)
{
(*miaRetta).q=y1; // la retta e' orizzontale (mi basterebbe sapere m=0
(*miaRetta).m=0; // quindi e' ridondante, solo per comodita'
}
else
{ // retta "normale". A questo punto si vede bene
// che potrei togliere punto1 e punto2 dalla struct
// pero' li tengo lo stesso
(*miaRetta).m=(*miaRetta).delta_y/(*miaRetta).delta_x;
(*miaRetta).q=y1-(*miaRetta).m*x1;
}
}
// questo e' un simil-metodo C++ che converte una retta in una stringa, discriminando
// i 3 casi diversi. Bisognerebbe aggiungervi dei controlli sul bufferOutput (e' null?)
// sull'inizializzazione di miaRetta etc.etc...
void trascriviRetta(retta miaRetta,char* bufferOutput)
{
if (miaRetta.Verticale)
sprintf(bufferOutput,"x=%+10.4f",miaRetta.q);
else
if (miaRetta.Orizzontale)
sprintf(bufferOutput,"y=%+10.4f",miaRetta.q);
else
sprintf(bufferOutput,"y=%+10.4fx %+10.4f",miaRetta.m,miaRetta.q);
}
// questa funzioncina verifica la condizione per le due rette. Nel caso C++
// avresti un unico parametro, l'altro implicito (this)
// anche qui, per facilita' di lettura, le condizioni sono tutte esplicitate
int perpendicolareA(retta retta1,retta retta2)
{
if ((retta1.Verticale && retta2.Orizzontale))
return 1;
else
if
(retta1.Orizzontale && retta1.Verticale)
return 1;
else
return int ( fabs(retta1.m- (-1.0/retta2.m))<eps);
}
// come sopra per la condizione di ||->tra l'altro serve per verificare se
// esiste una intersezione
int parallelaA(retta retta1,retta retta2)
{
if ((retta1.Verticale && retta2.Orizzontale))
return 0;
else
if
(retta1.Orizzontale && retta1.Verticale)
return 0;
else
return int (fabs(retta1.m-retta2.m)<eps);
}
// questa funzioncina calcola il punto (o almeno... spero! e' passata una
// vita da analisi I !!!) di intersezione.
// Verifica, prima, che questo esista.
punto calcolaIntersezione(retta retta1, retta retta2)
{
punto incontro;
incontro.valido=1; // per default il punto e' reale [qui ci vorrebbe il costruttore di default]
// e' superfluo ma meglio metterlo
if (parallelaA(retta1,retta2))
{
incontro.valido=0; // parallele -> no incontro
}
else
{
if (retta1.Verticale)
{
incontro.x=retta1.punto1.x;
incontro.y=retta2.m*incontro.x+retta2.q;
incontro.valido=1;
}
else
if (retta2.Verticale)
{
incontro.x=retta2.punto1.x;
incontro.y=retta1.m*incontro.x+retta1.q;
incontro.valido=0;
}
else
{
incontro.x=(retta1.q-retta2.q)/(retta2.m-retta1.m);
incontro.y=retta2.m*incontro.x+retta2.q;
incontro.valido=1;
}
}
return incontro;
}
// minimetodo di trascizione punto, anche qui senza controlli
void trascriviPunto(punto mioPunto,char* bufferOutput)
{
if (mioPunto.valido)
sprintf(bufferOutput,"x=%+10.4fx y=%+10.4f",mioPunto.x,mioPunto.y);
else
sprintf(bufferOutput,"PUNTO NON REALE");
}
// questo e' il main di un programma tipoco da console
// che ritorna un intero. come gia' detto argc e argv sono i parametri
// a riga di comando
int main(int argc, char *argv[])
{
double x1_1,y1_1, x2_1,y2_1;
double x1_2,y1_2, x2_2,y2_2;
// commento questa parte altrimenti si fatica a fare le prove!
/*
printf("PUNTI SULLA PRIMA RETTA\n\n\n");
printf("Inserire la x del primo punto: x1_1 ");
scanf("%deltay_2",&x1_1);
printf("Inserire la y del primo punto: y1_1 ");
scanf("%deltay_2",&y1_1);
printf("Inserire la x del secondo punto: x2_1 ");
scanf("%deltay_2",&x2_1);
printf("Inserire la y del secondo punto: y2_1 ");
scanf("%deltay_2",&y2_1);
system("cls");
printf("PUNTI SULLA SECONDA RETTA\n\n\n");
printf("Inserire la x del primo punto: (x1_2) ");
scanf("%deltay_2",&x1_2);
printf("Inserire la y del primo punto: (y1_2) ");
scanf("%deltay_2",&y1_2);
printf("Inserire la x del secondo punto: (x2_2) ");
scanf("%deltay_2",&x2_2);
printf("Inserire la y del secondo punto: (y2_2) ");
scanf("%deltay_2",&y2_2);
*/
x1_1=1; //1
y1_1=3; //3
x2_1=6; //6
y2_1=5; //5
x1_2=2; //2
y1_2=5; //5
x2_2=6; //6
y2_2=4; //4
retta retta1;
retta retta2;
int flagParallele; // logica falso (0), vero (altrimenti)
int flagPerpendicolari;
char stringaRetta[100]; // conversione in stringa di una retta
char stringaPunto[100]; // conversione in stringa di un punto
// creo le due rette in modo "simil-C++"
costruttoreRetta(&retta1,x1_1,y1_1,x2_1,y2_1);
costruttoreRetta(&retta2,x1_2,y2_2,x2_2,y2_2);
system("cls");
// stampo qualche informazione
printf("retta1 verticale %d\n",retta1.Verticale);
printf("retta2 verticale %d\n",retta1.Verticale);
printf("retta1 orizzonta %d\n",retta1.Orizzontale);
printf("retta2 orizzonta %d\n",retta1.Orizzontale);
// ed ora converto le rette nella rappresentazione a stringa
// (C++: incapsulamento, isolamento. In verita' avrei dovuto
// fare l'overload di un operatore (tipo <<) per scrivere su stream
// tipo cout. Ma questo e' un programma C!!!
trascriviRetta(retta1,stringaRetta);
printf("Equazione retta 1: %s\n",stringaRetta);
trascriviRetta(retta2,stringaRetta);
printf("Equazione retta 2: %s\n",stringaRetta);
flagPerpendicolari =perpendicolareA(retta1,retta2);
flagParallele =parallelaA(retta1,retta2);
printf("\n");
// calcolo il punto d'incontro. Se non esiste incontro.valido non e' "vero"
punto incontro;
incontro=calcolaIntersezione(retta1,retta2);
trascriviPunto(incontro,stringaPunto);
if (flagPerpendicolari)
printf("Sono perpendicolari\n");
else
printf("Non sono perpendicolari\n");
if (flagParallele)
printf("Sono parallele (nessun punto di incontro)\n");
else
{
printf("NON sono parallele\n");
printf("\n\n");
printf("punto di incontro %s\n",stringaPunto);
}
system("pause");
return EXIT_SUCCESS;
}
Non e' un granche', specialmente perche' e' una sorta di mischione
C / C++, non l'ho neppure provato molto :culo)
Vedi te se ti va bene :cesso)
riguardando mi sembra che qui ci vada "valido=1"
e' domenica mattina, abbi comprensione! ciao vado a magnà.
if (retta2.Verticale)
{
incontro.x=retta2.punto1.x;
incontro.y=retta1.m*incontro.x+retta1.q;
incontro.valido=0;
C / C++, non l'ho neppure provato molto :culo)
Vedi te se ti va bene :cesso)
riguardando mi sembra che qui ci vada "valido=1"
e' domenica mattina, abbi comprensione! ciao vado a magnà.
if (retta2.Verticale)
{
incontro.x=retta2.punto1.x;
incontro.y=retta1.m*incontro.x+retta1.q;
incontro.valido=0;
Bhe è molto ben fatto questo programma si vede che tu sei un programmatore senior io non ci capisco quasi nulla :mecry)
Più che senior... ld) ...
Il funzionamento è ben più semplice di quello che sembra.
Dal momento che il problema è "complesso" (si fa per dire)... una buona strategia e' quella divide-et-impera bottom-up.
:fuori)
Ovvero iniziare a definirsi le entità "base" su cui costruire (qualcuno direbbe progettare, ma sono allergico al termine) il tutto.
Se rifletti cosa ti serve? (nota: tralascio tutta la "vera" progettazione del software)
Ti serve un "qualcosa" che rappresenti un punto.
Un metodo per "scrivere" come e' fatto il punto
Un qualcosa che sia una retta.
Ti serve un metodo per "creare" una retta, dati i due punti da cui passa.
Ti serve un metodo che "scriva" come è fatta la retta.
TI serve un metodo che dica se due rette sono parallele
Se sono perpendicolari
Dove si incontrano, riportando il punto d'incontro.
Questa è, grosso modo, la "roba" che ti serve.
Una volta che te la sei costruita il programma si risolve in
"crea le rette"
"guarda se sono perpendicolari o parallele"
"trova il punto d'incontro"
"scrivi il punto d'incontro"
Dentro le "rette" ed i "punti" ci metti i "metodi" che fanno quello che ti serve.
La modellazione della "retta" e' discutibile, in quanto invece di tenere i 3 parametri a,b,c tiene m,q + un flag per quando e' verticale, ma la cosa "peggiore" e' il fatto che contenga due punti.
ovviamente il concetto di "retta" e' definito da a,b,c, i due punti non c'entrano->non ci andrebbero dentro.
ci vorrebbe il concetto di "retta" ed eventualmente il concetto-derivato retta-che-passa-per-due-punti.
Oppure (più elegante) retta-e-basta.
Se le varie condizioni le "spezzi" all'interno dei metodi puoi tenere sotto controllo la difficolta' complessiva, senza dover fare dei test complicatissimi di tutte le varie possibilita'.o)
Poi ci sono "cosucce" di tipo matematico computazionale, ad esempio riguardo ai concetti di zero od uguaglianza.
Non puoi fare if (a==b) se a e b sono in virgola mobile, perchè esistono degli errori di rappresentazione tali per cui non è detto (anzi, quasi mai) che la rappresentazione di a sia effettivamente "coincidente" con a reale.
DUe esempi scemi, magari si capisce: 1/3 e pigreco.
Non puoi ottenere una rappresentazione di numeri periodici o irrazionali (in verità anche dei razionali - se non usi classi apposite - cmq fai finta di niente...)
Ragion per cui non puoi chiederti se a==b, bensi se la DISTANZA di a da b è "piccola" rispetto a quello che ti aspetti.
Se a=0.999999 e b=1 puoi dire "a==b" ?
In verita' qui si aprirebbe tutto un discorso sulle metriche, sulle distanze, e sul perchè il "modulo" ha certe caratteristiche mentre si potrebbe usare il "quadrato", oppure altre cose più carine.
Non so a che livello sia il tuo corso (immagino basico), cmq chiedi, magari qualcuno più esperto di me ti darà qualche buona dritta... (devo rimanere coi piedi per terra :crepap)
---
Consiglio finale: se affronti un problema che ti sembra "difficile" cerca di capire "cosa ti serve" per risolverlo, ed inizia a farti gli strumenti
Un po' come dire "per stringere una vite mi serve un cacciavite. Per farmi un cacciavite mi serve del metallo, un manico. Per fare il manico mi serve un pezzo di legno, un qualcosa per sagomarlo etc.etc".
Una volta che hai "il cacciavite" girare la vite è facile.
Per fare lo "sborrone" è un approccio a fontana top-down bottom-up, ovvero il metodo di progettazione che va di moda oggi :fuori) :vomito) :shakko)
Vabbè fai finta di niente...hmamma)
ld) ...Il funzionamento è ben più semplice di quello che sembra.
Dal momento che il problema è "complesso" (si fa per dire)... una buona strategia e' quella divide-et-impera bottom-up.
:fuori)
Ovvero iniziare a definirsi le entità "base" su cui costruire (qualcuno direbbe progettare, ma sono allergico al termine) il tutto.
Se rifletti cosa ti serve? (nota: tralascio tutta la "vera" progettazione del software)
Ti serve un "qualcosa" che rappresenti un punto.
Un metodo per "scrivere" come e' fatto il punto
Un qualcosa che sia una retta.
Ti serve un metodo per "creare" una retta, dati i due punti da cui passa.
Ti serve un metodo che "scriva" come è fatta la retta.
TI serve un metodo che dica se due rette sono parallele
Se sono perpendicolari
Dove si incontrano, riportando il punto d'incontro.
Questa è, grosso modo, la "roba" che ti serve.
Una volta che te la sei costruita il programma si risolve in
"crea le rette"
"guarda se sono perpendicolari o parallele"
"trova il punto d'incontro"
"scrivi il punto d'incontro"
Dentro le "rette" ed i "punti" ci metti i "metodi" che fanno quello che ti serve.
La modellazione della "retta" e' discutibile, in quanto invece di tenere i 3 parametri a,b,c tiene m,q + un flag per quando e' verticale, ma la cosa "peggiore" e' il fatto che contenga due punti.
ovviamente il concetto di "retta" e' definito da a,b,c, i due punti non c'entrano->non ci andrebbero dentro.
ci vorrebbe il concetto di "retta" ed eventualmente il concetto-derivato retta-che-passa-per-due-punti.
Oppure (più elegante) retta-e-basta.
Se le varie condizioni le "spezzi" all'interno dei metodi puoi tenere sotto controllo la difficolta' complessiva, senza dover fare dei test complicatissimi di tutte le varie possibilita'.
o) Poi ci sono "cosucce" di tipo matematico computazionale, ad esempio riguardo ai concetti di zero od uguaglianza.
Non puoi fare if (a==b) se a e b sono in virgola mobile, perchè esistono degli errori di rappresentazione tali per cui non è detto (anzi, quasi mai) che la rappresentazione di a sia effettivamente "coincidente" con a reale.
DUe esempi scemi, magari si capisce: 1/3 e pigreco.
Non puoi ottenere una rappresentazione di numeri periodici o irrazionali (in verità anche dei razionali - se non usi classi apposite - cmq fai finta di niente...)
Ragion per cui non puoi chiederti se a==b, bensi se la DISTANZA di a da b è "piccola" rispetto a quello che ti aspetti.
Se a=0.999999 e b=1 puoi dire "a==b" ?
In verita' qui si aprirebbe tutto un discorso sulle metriche, sulle distanze, e sul perchè il "modulo" ha certe caratteristiche mentre si potrebbe usare il "quadrato", oppure altre cose più carine.
Non so a che livello sia il tuo corso (immagino basico), cmq chiedi, magari qualcuno più esperto di me ti darà qualche buona dritta... (devo rimanere coi piedi per terra :crepap)
---
Consiglio finale: se affronti un problema che ti sembra "difficile" cerca di capire "cosa ti serve" per risolverlo, ed inizia a farti gli strumenti
Un po' come dire "per stringere una vite mi serve un cacciavite. Per farmi un cacciavite mi serve del metallo, un manico. Per fare il manico mi serve un pezzo di legno, un qualcosa per sagomarlo etc.etc".
Una volta che hai "il cacciavite" girare la vite è facile.
Per fare lo "sborrone" è un approccio a fontana top-down bottom-up, ovvero il metodo di progettazione che va di moda oggi :fuori) :vomito) :shakko)
Vabbè fai finta di niente...
hmamma)ok grazie ho capito gia qualcosa di piu.
Il mio corso è a livello demenziale infatti questi sono programmi che ho deciso di fare io e un mio amico per allenarci un po....Quelli che ci danno sono ad esempio uno che somma 2 numeri che fa il fattoriale di un numero e cose del genere
Il mio corso è a livello demenziale infatti questi sono programmi che ho deciso di fare io e un mio amico per allenarci un po....Quelli che ci danno sono ad esempio uno che somma 2 numeri che fa il fattoriale di un numero e cose del genere
Ho un altro quesito:
C'è un modo di inserire un cronometro in modo che dopo l'esecuzione del programma mi dica quanto ci ha messo per fare i conti??
C'è un modo di inserire un cronometro in modo che dopo l'esecuzione del programma mi dica quanto ci ha messo per fare i conti??
mezzostordito":t6ckmc4i ha detto:
Dunque.
Prendi il tempo prima dell'esecuzione delle operazioni che devi fare, lo prendi dopo che le hai fatte... e calcoli la differenza.
Devi includere la libreria time con:
Codice:
#include <time.h>Poi fai:
Codice:
clock_t tempoiniziale=clock();
bla bla bla // qui ci metti il corpo del tuo programma
clock_t tempofinale=clock();
clock_t tempoesecuzione=(tempofinale-tempoiniziale);Occhio che -mi sembra- le variabili di tipo clock_t utilizzano l'orologio di sistema e i millisecondi come tempo di riferimento.
Quindi se il codice che devi eseguire è relativamente breve e semplice, potrebbe non impiegarci abbastanza tempo e quindi darti come risultato uno zero.
:OK)
PS: spero di non aver detto troppe vaccate...
:asd)