problema traduzione da Visual Basic a Lazarus

[nomorelogic]

alexarmato66, quando posti del codice usa i blocchi "code", quelli col cancelletto

grazie

[alexarmato66]

qui avevo visto che sono permesse le stringhe.Mi sbaglio?
https://wiki.freepascal.org/Case#structure

The data type of selector has to be an ordinal type. FreePascal additionally allows strings.

[DragoRosso]

qui avevo visto che sono permesse le stringhe.Mi sbaglio?
https://wiki.freepascal.org/Case#structure

The data type of selector has to be an ordinal type. FreePascal additionally allows strings.

Confermo quandto dici, e non ne ero a conoscenza. Funziona solo con {$MODE ObjFPC)

Pur però potendolo fare, io sconsiglio vivamente ciò. Questo per varie motivazioni: intanto la codifca dei caratteri, la compatibilità, l'ottimizzazione, etc ...
Non sò il compilatore come si comporti visto che in termini generici questo dovrebbe essere risolto a livello di compilazione. Immagino usino l'HASH delle stringhe.

In genere usate i tipi, anche nei database. E se proprio non potete, alla lettura del database traformate la stringa letta in un "tipo" e usate questo tipo nel programma.

Non ve ne pentirete.

Saluti

[Stilgar]

Ciao
Solo qualche piccolo accorgimento nel codice.

Codice: [Seleziona]

type
  TNumeroValoriMassimo = 0..100; //<-- Dichiari solo una volta l'insieme, se hai bisogno di ridimensionare l'insieme, tocchi qui e ricompili.

type
  // Struttura dati che contiene i valore dei momenti di rottura della sezione  //
  // -------------------------------------------------------------------------- //
  TMomentiRottura = record
    mrx: double;                        // Momento di rottura con asse momento x
    mry: double;                        // Momento di rottura con asse momento y
    ang: double;                        // Rotazione dell//asse neutro rispetto all//asse x, antioraria positiva
    polix: array of poligono_sezione;   // Poligono che definisce la porzione di cls compressa della sezione
    sigmaSo: array of double;          // ' Array contenente le tensioni nelle barre di armatura a rottura
    sigmaPp: array of double;          // ' Array contenente le tensioni nei trefoli a rottura
    def_rottura: deform_sezione;        // configutrazione deformativa a rottura
    etacMax: double;                   // distanza tra l//asse neutro e la fibra maggiormente compressa a rottura
    etasMin: double;                   // distanza tra l//asse neutro e la fibra maggiormente tesa a rottura
    curvRottura: double;               // curvatura della sezione a rottura
  end;
  // Struttura dati in cui sono definiti i dati dei singoli poligoni che com-   //
  // pongono la sezione                                                         //
  // -------------------------------------------------------------------------- //
  TPoligonoSezione = record
    x: array[TNumeroValoriMassimo] of double;          // coordinata x del vertice
    y: array[TNumeroValoriMassimo] of double;          // coordinata y del vertice
    numv: integer;                      // numero di vertici del poligono
    fck: double;                        //' fck
    fd: double;                        // Resistenza massima di calcolo (per verifiche SLU)
    omog: double;                      // coefficiente di omogeneizzazione (per verifiche SLE)
    traz: boolean;                     // 0=non reagente a trazione; 1=reagente a trazione
    epsc0: double;                      // Deformazione in corrispondenza della fine della parte parabola/lineare del dominio
    epscu: double;                      // Deformazione ultima del dominio
    sigma: array[TNumeroValoriMassimo] of double;
  end;
  

Personalmente eviterei di utilizzare le stringhe nel case. Utilizzerei degli indici.
Utilizzando una combo box puoi ottenere l'indice dell'opzione selezionata attraverso

Codice: [Seleziona]

index

.  Restituisce -1 Se non è selezionato nulla.

Codice: [Seleziona]

procedure TForm1.calcoloGeometria1;
var
  tipo1: integer;
begin
  // -------------------------------------------------------------------------- //
  //'carica geometria 1  *********************************************************
  tipo1 := Form1.CB1.Index;// <-- Il cb mi fa supporre sia una combo box 
  case (tipo1) of
    indiceTrave:
    begin
      tipogetto[1] := Trave;
      nv[1] := StrToInt(Form1.EVertici1.Text);
      for k := 1 to nv[1] do
      begin
        X1[k] := StrToFloat(Form1.StringGrid1.Cells[1, k]);
        Y1[k] := StrToFloat(Form1.StringGrid1.Cells[2, k]);
      end;
      fck := StrToInt(Form1.CBcls1.Text);
    end;
    indiceGetto2aFase:
    begin
      tipogetto[1] := Getto;
      nv[1] := StrToInt(Form1.EVertici1.Text);
      for k := 1 to nv[1] do
      begin
        X1[k] := StrToFloat(Form1.StringGrid1.Cells[1, k]);
        Y1[k] := StrToFloat(Form1.StringGrid1.Cells[2, k]);
      end;


      fck := StrToInt(Form1.CBcls1.Text);


    end;


    indiceForo:
    begin
      tipogetto[1] := Foro;
      nv[1] := StrToInt(Form1.EVertici1.Text);


      for k := 1 to nv[1] do
      begin
        X1[k] := StrToFloat(Form1.StringGrid1.Cells[1, k]);
        Y1[k] := StrToFloat(Form1.StringGrid1.Cells[2, k]);
      end;
      fck := StrToInt(Form1.CBcls1.Text);
    end;


  end;


end;
//******************************************************************************

[doc]

@alexarmato66

Ciao, ma quindi esaminando la riga

Codice: [Seleziona]

type
  TNumeroValoriMassimo = 0..100; //<-- Dichiari solo una volta l'insieme, se hai bisogno di ridimensionare l'insieme, tocchi qui e ricompili

il tuo programma è limitato a 101 campi.....
Non ti conviene usare oggetti/elementi dinamici (io, personalmente, uso solo array dinamici per le matrici usate nei calcoli) in modo da non avere questa limitazione? Anche perchè leggo "...se hai bisogno di ridimensionare l'insieme, tocchi qui e ricompili." il che ti costringe a nuove compilazioni ogni volta che devi ridimensionare questo insieme.
Era solo un suggerimento, per il resto ottimo lavoro.

[Stilgar]

hihihihiNovel aveva un'array per il numero degli utenti gestiti dal server di rete

[alexarmato66]

Grazie a tutti.Sto cercando di utilizzare solo array dinamiche.Avevo però
un dubbio sulla traduzione da VB del seguente frammento( avete un suggerimento?):

ReDim dominio_slu.mrx(1 To NMaxDom)   

[DragoRosso]

In modo simile a quanto già suggerito:

Codice: [Seleziona]

Type 
  TDominio_slu = record
      mrx: array of ???????????       <---- definire il tipo
  end;

//Nel codice
var dominio_slu: TDominio_slu; 

SetLength(dominio_slu.mrx, NMaxDom+1);     //L'array parte de 0 non da 1

[alexarmato66]

grazie.
E' possibile in Lazarus fare un wrapper?:

Function Punto_Interno_poligonoB(xP : Double; yP : Double; X:array of Double; Y:array of Double; nv : Integer) : Byte  ;
begin
    Inside (X, Y, nv, xP, yP, Punto_Interno_poligonoB );
End ;   

[DragoRosso]

Per wrapper si intende una "transcodifca" normalmente con metodi che consenta di chiamare funzioni o altro costruiti con altri linguaggi.

Un esempio di wrapper sono le Api di Windows, codificate in Pascal.

grazie.
E' possibile in Lazarus fare un wrapper?:

Function Punto_Interno_poligonoB(xP : Double; yP : Double; X:array of Double; Y:array of Double; nv : Integer) : Byte  ;
begin
    Inside (X, Y, nv, xP, yP, Punto_Interno_poligonoB );
End ;   

Non ho compreso cosa richiedi.

[alexarmato66]

esiste  STEP in Lazarus?:
esempio
    For Y = yn + dX / 2# To ymaxpe Step dX   

[DragoRosso]

esiste  STEP in Lazarus?:
esempio
    For Y = yn + dX / 2# To ymaxpe Step dX   

No, non esiste. L'incremento della variabile di controllo è sempre di 1.
Si può ovviare con la funzione while o la funzione repeat.

Codice: [Seleziona]

Y := yn + dx /2;
while (Y <= ymaxpe) do
  begin
     //Inserisci qui il tuo codice

     //alla fine incrementa la variabile di controllo
     Y := Y + dx;
  end;

[Stilgar]

Alex.
Cosa intendi di preciso per wrapper? Io ho un'idea, magari non vorrei capire male quello che chiedi.


In Freepascal hai la possibilità di mettere dei metodi nei record.
Devi attivare i record "cazzuti" con alcune direttive del compilatore.


Forse non ti serve un wrapper.

Codice: [Seleziona]

{$ModeSwitch advancedrecords}
{$ModeSwitch typehelpers}     
type
  TPunto = record
  x, Y : Double;
  end;


  TPoligono = record
     punti : array of TPunto; 
     class operator Initialize(var aRec: TPoligono );  //<- "costruttore" del record 
     class operator Finalize(var aRec: TPoligono );   //<- "distruttore" del record 
     procedure aggiungiPunto(const punto : TPunto);
     function isPuntoIncluso(const pt : TPunto) : boolean;
  end;
  

[alexarmato66]

ByRef lo traduco con VAR ma ByVal?:


Public Sub Calcolo_precompressione(ByVal N_ As Double, ByVal Mx_ As Double, ByVal My_ As Double, _
                                    nd As Double, Mx As Double, My As Double)

[Stilgar]

Se fa la copia dei valori nello stack così.

Codice: [Seleziona]

procedure Calcolo_precompressione(N_ As :Double; Mx_ As:Double; My_ : Double, _nd : Double; Mx : Double, My : Double);

se passa un "riferimento" senza copiare nello stack i valori, ma depositando i puntatori alle variabili:

Codice: [Seleziona]

procedure Calcolo_precompressione(var N_ As :Double; var Mx_ As:Double; var My_ : Double; var _nd : Double; Mx : Double, My : Double);

Stilgar