Assegnamento di Array a Puntatori in C

Utilizzando gcc come compilatore su Linux dimostreremo che l'assegnamento di un array ad un puntatore non e' possibile se non per i soli primi tre elementi dell'array, nel caso di funzioni esterne al main, eventuali altre funzioni  che utilizzano cicli iterativi per l'assegnamento dei singoli elementi provocano "segmentation fault". Ovviamente questo implica anche che non sia possibile assegnare una stringa di lunghezza variabile (con scanf) ad un puntatore esterno al main, infatti il valore assegnato per default al puntatore e' di 4 caratteri con conseguente perdita di valori per stringhe superiori a 4 nel caso debba essere fatta una ricerca con una funzione al di fuori del main, in C, e' solo possibile il passaggio per riferimento di un array, di lunghezza variabile ottenuto con scanf. Inoltre non esistono funzioni delle librerie C, utilizzate anche dal C++, C++11 e dal Objective-C, che  forniscono una sottostringa ricercata all'interno di un vettore testo, quindi in C e derivati la ricerca di una stringa ottenuta da un utente esterno rispetto al testo conosciuto puo' essere fatta se all'interno della funzione si include lo scanf() con l'array a lunghezza variabile che mantiene una dimensione superiore a 4 per la durata della funzione. Vedremo inoltre che l'operatore di assegnamento == non riconosce i caratteri char tra gli elementi di un array e l'altro, mentre il Java li riconosce. Poi proveremo ad avvicinarci alla logica numerica del C, supponendo per assurdo di dover riscrivere una codifica ASCII, o un alfabeto associato a degli interi in ingresso, e vedremo che in tal caso l'operatore di assegnamento == funziona, ma la logica iterativa dei cicli for e while, identici a quelli utilizzati per il Java, diventa instabile e fornisce risposte differenti asseconda, della quantita' e del valore dei codici numerici inseriti.

Il codice C e' il seguente:

# include <stdio.h>
# include <stdlib.h>
# include <string.h>
int dim =0;
int dimRidondante =0;
int dim2 = 0;
int dim3 = 0;
int i;
char *p;
char array[];
void stampaPuntatoreUndef(int dimensione, char *p);
void stampArray(int dimensione, char array[]);
void assegnamentoArrayAPuntatore(int  dimensioneArray, char array[]);
void main(){
  printf("inserire la lunghezza della stringa: \n");
  scanf("%d",&dim);
  printf("inserire la  stringa:\n");
  for(i=0; i<=dim; i++){
    scanf("%c",&array[i]);
    //p++;
  }
  dim2 = strlen(array);
  printf("la dimensione dell'array e':%d\n", dim2);
  stampArray(dim2, array);
  //assegnamentoArrayAPuntatore(dim2, array);
  p=array;
 
  dimRidondante = strlen(p);
  printf("la dimensione letta del puntatore e':%d\n",dimRidondante);
  dim3 = strlen(array);
  printf("la dimensione dell'array dopo l'assegnamento e':%d\n", dim3);
  stampaPuntatoreUndef(dimRidondante, p);
  stampArray(dim2, array);
}
stampaPuntatoreUndef(int dimensione, char *p){
  int j;
  for(j=0; j<=dimensione;j++){
    printf("%c",*p);
    p++;
  }
  printf("\n");
}
void stampArray(int dimensione, char array[]){
  int i;
  for(i=0; i<dimensione;i++){
    printf("%c",array[i]);
  }
 printf("\n");
}
/*void assegnamentoArrayAPuntatore(int dimensioneArray, char array[]){
  int i;
  for(i=0;i<=dimensioneArray;i++){
    printf("i=%d   ",i);
    p[i]=array[i];
  }
}
*/

a video otteniamo con l'assegnamento normale:

assegnamento a puntatori in C 

In cui in basso compare il programma con i commenti come riportato nel codice di su, mentre in alto compare l'output del programma senza i commenti, utilizzando anziche' il normale assegnamento = la funzione assegnamentoArrayAPuntatore.

Nel programma in basso con l'assegnamento = si nota che il segmentation fault avviene in modo implicito dopo l'assegnazionne del terzo elemento in cui prova diventa proh?.

Mentre nel programma in alto in cui la funzione assegna elemento per elemento i valori dell'array al puntatore con l'aritmetica dei puntatori si ha un segmentation fault esplicito.

Tra un esecuzione e l'altra del codice sono presenti i risultati di compilazione da parte di gcc. Mentre il nome stampaPuntatoreUndef che segue i simboli ./ identifica l'esecuzione del codice. Il titolo Undef identifica che la lunghezza della stringa in ingresso e' variabile ed assegnata dall'esterno, come se  fosse inserita per un find successivo. Mentre l'aritmetica dei puntatori e l'assegnamento funziona se la stringa e' passata direttamente nel codice da compilare. Quindi si conclude che i puntatori non possono essere utilizzati nel caso di stringhe  a lunghezza variabile inserite dall'esterno. Mentre funzionano bene per stringhe preinserite, nel codice e poi compilate.

***************************************************************************************************************************************

Ora vedremo una funzione di ricerca che  passa i parametri per riferimento, perdendo cosi' la dimensione dell'array, per dimensioni superiori a 4.

Il codice e':

#include <stdio.h>
#include <stdlib.h>
char arrayStringheSenzaNull[]="ti voglio tanto bene";
void ricercaStringa(char s[], int dim, char find[]);
char trova[];
void stampaLaParola(char find[]);
int dimensione, dimensioneVettore;
int indice = 0;
char parolaSmezzata[];
char parola;
int dimensioneParola=0;
int dim = 0;
int i;
int y=0;
int count = 0;
void main(){
  printf("Inserire la lunghezza della parola da cercare:");
  scanf("%d", &dimensioneParola);
  printf("Inserire la parola da cercare:");
  for(i=0;i<=dimensioneParola;i++){
  scanf("%c",&trova[i]);
  }
  dimensioneVettore = sizeof(arrayStringheSenzaNull);
  printf("dimensioneParola == %d in main\n", dimensioneParola);
  ricercaStringa(arrayStringheSenzaNull, dimensioneVettore, trova);
}
ricercaStringa(char s[], int dimensioneVettore, char find[]){
 
  printf("sono dentro ricerca stringa\n");
  if( count==0){
    dimensioneParola = sizeof(find);
    printf("dimensioneParola==%d in ricerca stringa\n",dimensioneParola);
    count++;
  }
  while(y<dimensioneVettore){
  for(i=0; ((i<dimensioneVettore)&&(s[i]== find[indice]));){
    printf("sono dentro il for di ricercaStringa fuori dall'if\n");
    if(s[i]== find[indice]){
    indice++;
    printf("sono dentro l'if del for di ricerca stringa\n");
    dim = sizeof(find)/sizeof(find[0]);
    int k=0;
    int j=0;
    while(j<dim ){
      parolaSmezzata[j] = find[k];
      j++;
      k++;
    } i++;
    ricercaStringa(find, dimensioneParola, parolaSmezzata);
    }
  }
  y++;
  }
  printf("y == %d, dimensioneVettore == %d, i == %d\n",y, dimensioneVettore, i);
  return ((y==dimensioneVettore)?stampaLaParola(find):printf("parolaNonTrovata\n"));
}
stampaLaParola(char find[]){
  int i=0;
  printf("sono dentro stampa la  parola\n");
  int dimensioneParola = sizeof(find);
  printf("La dimensione della parola e':%d",dimensioneParola);
  for(i; i<dimensioneParola ; i++ ){
    printf("%c",find[i]);
  }
  printf("\n");
}

L'output ottenuto con gcc e':

[root@localhost find]# gcc -Wall RicercaStringa.c -o RicercaStringa
RicercaStringa.c:16:6: warning: return type of ‘main’ is not ‘int’ [-Wmain]
RicercaStringa.c:27:1: warning: return type defaults to ‘int’ [-Wreturn-type]
RicercaStringa.c:27:1: warning: conflicting types for ‘ricercaStringa’ [enabled by default]
RicercaStringa.c:4:6: note: previous declaration of ‘ricercaStringa’ was here
RicercaStringa.c:57:1: warning: return type defaults to ‘int’ [-Wreturn-type]
RicercaStringa.c:57:1: warning: conflicting types for ‘stampaLaParola’ [enabled by default]
RicercaStringa.c:6:6: note: previous declaration of ‘stampaLaParola’ was here
RicercaStringa.c: In function ‘stampaLaParola’:
RicercaStringa.c:62:3: warning: statement with no effect [-Wunused-value]
RicercaStringa.c: At top level:
RicercaStringa.c:5:6: warning: array ‘trova’ assumed to have one element [enabled by default]
RicercaStringa.c:9:6: warning: array ‘parolaSmezzata’ assumed to have one element [enabled by default]
[root@localhost find]# ./RicercaStringa
Inserire la lunghezza della parola da cercare:5
Inserire la parola da cercare:bene
dimensioneParola == 5 in main
sono dentro ricerca stringa
dimensioneParola==4 in ricerca stringa
y == 21, dimensioneVettore == 21, i == 0
sono dentro stampa la  parola
La dimensione della parola e':4
ben

in cui si nota la perdita della dimensione della parola cercata.

Non sono presenti funzioni che restituiscano la stringa in <string.h>

*****************************************************************************************************************************************

Resta da dimostrare che con lo scanf() all'interno della funzione di ricerca sia possibile trovare una stringa ricercata in un vettore di testo in C.

Questo non e' possibile poiche' l'operatore di uguaglianza in C ==, non confronta gli elementi dell'array all'interno di un ciclo, lo dimostriamo utilizzando il seguente codice  che ovvia al problema della perdita di dimensione del vettore con il passaggio di parametri per riferimento, poiche' inseriamo direttamente nella funzione lo scanf(), pero' l'operatore di assegnamento non riconosce l'uguaglianza tra singolo carattere di due stringhe, in cui una e' un vettore stringa composto da piu' stringhe ed una e' la sottostringa. Il codice e' il seguente:

#include <stdio.h>
#include <stdlib.h>
# include <string.h>
char arrayStringheSenzaNull[]="ti voglio tanto bene";
//void ricercaStringa(char s[], int dim, char find[]);
void ricercaStringa();
int  dimensioneVettore=0;
int dimensioneParola=0;
int b=0;
char trova[];
void main(){
  ricercaStringa();
}
ricercaStringa(){
  int k=0;
  int y=0;
  int i=0;
  //char trova[];
  printf("Inserire la lunghezza della parola da cercare:");
  scanf("%d", &dimensioneParola);
  printf("Inserire la parola da cercare:");
  for(b=0;b<=dimensioneParola;b++){
  scanf("%c",&trova[b]);
  }
    dimensioneVettore = sizeof(arrayStringheSenzaNull);
    printf("dimensioneVettore == %d,\n", dimensioneVettore);
    dimensioneParola = strlen(trova);
    printf("dimensioneParola==%d in ricerca stringa\n",dimensioneParola);
 
    while(k<dimensioneVettore){
      printf("sono dentro il while\n");
  if(arrayStringheSenzaNull[k]== trova[0]){
    printf("sono dentro il primo if di ricercaStringa ho trovato la prima corrispondenza\n");
    for(y=0; y<= dimensioneParola; y++){
      if(arrayStringheSenzaNull[k]==trova[y]){
    k++;
    printf("Sono dentro l'if ho trovato la corrispondenza n:%d\n",y);
    if(y==dimensioneParola){
      printf("la parola cercata e' stata trovata ed e':\n");
    }
      }
    }
    //ricercaStringa(find, dimensioneParola, parolaSmezzata);
    //implica che non si possa fare una ricerca ricorsiva, per via del passaggio
    //di paramentri per riferimento per valore
  }
  k++;
  }
 }

Compilando con gcc ed inserendo la dimensione dell'array e successivamente la  stringa: "bene" appartenente al vettore stringa principale "ti voglio tanto bene", notiamo  che non viene riconoscuita l'uguaglianza nel confronto tra i singoli elementi, e notiamo che la percorrenza del vettore Stringa principale di 21 caratteri viene eseguito, in quanto "sono dentro il while" compare per 21 volte.

[root@localhost find]# gcc -Wall RicercaStringaNoMain.c -o RicercaStringaNoMain
RicercaStringaNoMain.c:11:6: warning: return type of ‘main’ is not ‘int’ [-Wmain]
RicercaStringaNoMain.c:14:1: warning: return type defaults to ‘int’ [-Wreturn-type]
RicercaStringaNoMain.c:14:1: warning: conflicting types for ‘ricercaStringa’ [enabled by default]
RicercaStringaNoMain.c:6:6: note: previous declaration of ‘ricercaStringa’ was here
RicercaStringaNoMain.c: In function ‘ricercaStringa’:
RicercaStringaNoMain.c:17:7: warning: unused variable ‘i’ [-Wunused-variable]
RicercaStringaNoMain.c: At top level:
RicercaStringaNoMain.c:10:6: warning: array ‘trova’ assumed to have one element [enabled by default]
[root@localhost find]# ./RicercaStringaNoMain
Inserire la lunghezza della parola da cercare:5
Inserire la parola da cercare:bene
dimensioneVettore == 21,
dimensioneParola==6 in ricerca stringa
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
[root@localhost find]#

Per quanto riguarda il C oltre ad una ricerca iterativa ovviamente non e' possibile la ricerca ricorsiva per via  della perdita della dimensione dell'array nel passaggio per riferimento tra una  funzione e l'altra.

Ora resta da dimostrare se con la ridefinizione dell'operatore di uguaglianza == in C++, sia possibile tale confronto. Poiche' in C abbiamo visto che non e' possibile  la gestione delle stringhe.
Possiamo iniziare col dire che nello Stroustrup (3a edizione) stampa anno 2012 mese di settembre non compare la ridefinizione dell'operatore di uguaglianza. Si ricorda che Bjarne Stroustrup e' il creatore del C++.

Si puo' dire che il C++ si basa sul C, e la ridefinizione degli operatori in realta' e' un overload degli operatori, e tale sovraccarico si riferisce sempre agli operatori base del C, quindi se non funziona in C l'operatore di uguaglianza per le  stringhe  di un array non puo' funzionare neanche in C++, come possiamo vedere dall'esempio  che conferma la  teoria sul riferimento al confronto del linguaggio base.

Overload Dell'operatore di assegnamento

*****************************************************************************************************************************************

Vedremo se e' possibile il confronto tra stringhe  in Java.
In Java e' possibile la ricerca di una sottostringa all' interno di una stringa il cui tipo e' char per entrambe. Quindi sotto questo profilo il Java e' superiore al C.

Il codice e' il seguente, (il compilatore usato e' quello fornito dalla JDK, "javac" e la "java" e' l'esecutore), non utilizzeremo nessun IDE:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;

public class ricercaString{
    static char arrayStringheSenzaNull[]={'T','i',' ','v','o','g','l','i','o',' ','t','a','n','t','o',' ','b','e','n','e'};
  public static void ricercaString() throws IOException{
    int k=0;
    int y=0;
    int g=0;
    int indice=0;
    String theString;
    System.out.printf("Inserire la lunghezza della parola da cercare:\n");
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String stringa = br.readLine();
    int dimensioneParola = Integer.parseInt(stringa);
    System.out.printf("Inserire la parola da cercare:");
    //char trova[] = br.readLine();//verificare se occorre un for
    // char trova[0] = (char) System.in.read();
    Scanner s = new Scanner(System.in);
    //char trova = (char) s.nextLine();
    theString = s.nextLine();
    char trova[] = theString.toCharArray();    
    int dimensioneVettore = arrayStringheSenzaNull.length;
    System.out.printf("dimensione vettore == %d, ", dimensioneVettore);
     dimensioneParola = trova.length;
    System.out.printf(" dimensioneParola==%d in ricerca stringa\n",dimensioneParola);
    System.out.printf("la parola inserita e':");
    for(g=0;g<dimensioneParola;g++){
      System.out.printf("%c", trova[g]);
    }
    System.out.println();
    while(k<dimensioneVettore){
      System.out.println("sono dentro il while");
  if(arrayStringheSenzaNull[k]== trova[0]){
    System.out.println("sono dentro il primo if di ricercaStringa ho trovato la prima corrispondenza\n");
    for(y=0; y<dimensioneParola; y++){
      if(arrayStringheSenzaNull[k]==trova[y]){
    System.out.printf("Sono dentro l'if ho trovato la corrispondenza n:%d\n",y);
    if(y==(dimensioneParola-1)){
      System.out.printf("la parola cercata e' stata trovata ed e':");
      for(g=0;g<dimensioneParola;g++){
        System.out.printf("%c", trova[g]);
        }
        System.out.println();
      indice=k-y;
    System.out.printf("Corrisponde all'indice:%d",indice);
    System.out.println();
    }
      }
    k++;
    }
    //System.out.printf("Dimensione vettore: %d valore di k:%d\n",dimensioneVettore,k);
    //ricercaStringa(find, dimensioneParola, parolaSmezzata);
    //implica che si possa fare una ricerca ricorsiva,
  }
  k++;
  }
  }
public static void main(String[] args) throws IOException{
 
  ricercaString();
  }
}

l'esecuzione attraverso la virtual machine fornisce:

[root@localhost Java]# javac ricercaString.java
[root@localhost Java]# java ricercaString
Inserire la lunghezza della parola da cercare:
4
Inserire la parola da cercare:bene
dimensione vettore == 20,  dimensioneParola==4 in ricerca stringa
la parola inserita e':bene
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il primo if di ricercaStringa ho trovato la prima corrispondenza

Sono dentro l'if ho trovato la corrispondenza n:0
Sono dentro l'if ho trovato la corrispondenza n:1
Sono dentro l'if ho trovato la corrispondenza n:2
Sono dentro l'if ho trovato la corrispondenza n:3
la parola cercata e' stata trovata ed e':bene
Corrisponde all'indice:16
[root@localhost Java]#

In cui si nota che l'operatore di uguaglianza per caratteri char, in Java funziona, ed e' possibile la ricerca di sottostringhe in stringhe, nel caso di char.

Ora verificheremo che e' possibile utilizzando anche il tipo String.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;


public class ricercaString{
    //static char arrayStringheSenzaNull[]={'T','i',' ','v','o','g','l','i','o',' ','t','a','n','t','o',' ','b','e','n','e'};
    static String arrayStringhe ="Ti voglio tanto bene";
  public static void ricercaString() throws IOException{
    int i=0;
    String trova;
    System.out.printf("Inserire la lunghezza della parola da cercare:\n");
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String stringa = br.readLine();
    int dimensioneParola = Integer.parseInt(stringa);
    System.out.printf("Inserire la parola da cercare:");
    //char trova[] = br.readLine();//verificare se occorre un for
    // char trova[0] = (char) System.in.read();
    Scanner s = new Scanner(System.in);
    //char trova = (char) s.nextLine();
    trova = s.nextLine();
    int dimensioneVettore = arrayStringhe.length();
    System.out.printf("dimensione vettore == %d, ", dimensioneVettore);
     dimensioneParola = trova.length();
    System.out.printf(" dimensioneParola==%d in ricerca stringa\n",dimensioneParola);
    System.out.printf("la parola inserita e':%s\n",trova);
    while(i<dimensioneVettore){
    if(arrayStringhe.regionMatches(i, trova, 0, dimensioneParola)){
     System.out.printf("La parola ");
     System.out.println(arrayStringhe.substring(i));
     System.out.printf("e' stata trovata all'indice: %d\n",i);
    }
    i++;
      }
    }

public static void main(String[] args) throws IOException{
  ricercaString();
  //ricercaChar();
  }
}

l'esecuzione e':

[root@localhost Java]# javac ricercaString.java
[root@localhost Java]# java ricercaString
Inserire la lunghezza della parola da cercare:
4
Inserire la parola da cercare:bene
dimensione vettore == 20,  dimensioneParola==4 in ricerca stringa
la parola inserita e':bene
La parola bene
e' stata trovata all'indice: 16
[root@localhost Java]#

*****************************************************************************************************************************************

Ora proveremo ad avvicinarci alla logica C, in cui l'operatore di assegnamento funziona solo per di tipo intero, e la ridefinizione di tale operatore per i linguaggi derivati puo' essere fatta solo considerando il tipo int; Ma ci accorgeremo che nonostante l'operatore di assegnamento funzioni, la logica iterativa, che e' la stessa di quella inserita nel Java, diventa instabile, e non funziona correttamente, fornendo risposte differenti asseconda della quantita' e del valore inserito dei numeri in ingresso.

Convertiamo in formato numerico  la stringa ASCII "ti voglio tanto bene" (ovviamente per stringhe derivanti dal latino), della quale consideriamo il Lower case:

ti voglio tanto bene=116,105,32,118,111,103,108,105,111,32,116,97,110,116,110,116,110,32,98,101,110,101

Il codice e' il seguente:

#include <stdio.h>
#include <stdlib.h>
# include <string.h>
int arrayInt[]={116,105,32,118,111,103,108,105,111,32,116,97,110,116,110,116,110,32,98,101,110,101};
void ricercaStringaNumerica();
int dimensioneStringa=0;
int dimensioneArray=0;
int trova[];
void main(){
  ricercaStringaNumerica();
}
ricercaStringaNumerica(){
  int i;
  int y;
  int k=0;
  int b=0;
  printf("Inserire la lunghezza della parola da cercare:\n");
  scanf("%d",&dimensioneStringa);
  printf("Inserire la stringa numerica in decimale:\n");
  for(i=0; i<dimensioneStringa;i++){
    scanf("%d",&trova[b]);//probabilmente e' necessario inserire ogni numero dopo invio
  }
  dimensioneArray= sizeof(arrayInt)/sizeof(arrayInt[0]);
  printf("dimensione Array interi == %d,\n", dimensioneArray);
  printf("dimensione Stringa numerica in ingresso == %d\n", dimensioneStringa);
 
  while(k<=dimensioneArray){
    printf("sono dentro il while\n");
    if(arrayInt[k]==trova[0]){
      printf("sono dentro il primo if di ricercaStringa ho trovato la  prima corrispondenza\n");
      for(y=0; y<=dimensioneStringa;y++){
    if(arrayInt[k]==trova[y]){
      k++;
      printf("sono dentro l'if ho trovato la corrispondenza n:%d\n",y);
      if(y==dimensioneStringa){
        printf("la parola cercata e' stata trovata ed  e':\n");
      }
    }
      }
    }
    k++;
  }
}

La compilazione e l'esecuzione forniscono il seguente risultato:

[root@localhost find]# gcc -Wall RicercaDecimalePerStringa.c -o RicercaDecimalePerStringa
RicercaDecimalePerStringa.c:9:6: warning: return type of ‘main’ is not ‘int’ [-Wmain]
RicercaDecimalePerStringa.c:12:1: warning: return type defaults to ‘int’ [-Wreturn-type]
RicercaDecimalePerStringa.c:12:1: warning: conflicting types for ‘ricercaStringaNumerica’ [enabled by default]
RicercaDecimalePerStringa.c:5:6: note: previous declaration of ‘ricercaStringaNumerica’ was here
RicercaDecimalePerStringa.c:8:5: warning: array ‘trova’ assumed to have one element [enabled by default]
[root@localhost find]# ./RicercaDecimalePerStringa
Inserire la lunghezza della parola da cercare:
2
Inserire la stringa numerica in decimale:
116
105
dimensione Array interi == 22,
dimensione Stringa numerica in ingresso == 2
sono dentro il while
sono dentro il while
sono dentro il primo if di ricercaStringa ho trovato la  prima corrispondenza
sono dentro l'if ho trovato la corrispondenza n:0
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il primo if di ricercaStringa ho trovato la  prima corrispondenza
sono dentro l'if ho trovato la corrispondenza n:0
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
[root@localhost find]# ./RicercaDecimalePerStringa
Inserire la lunghezza della parola da cercare:
3
Inserire la stringa numerica in decimale:
101
110
101
dimensione Array interi == 22,
dimensione Stringa numerica in ingresso == 3
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il primo if di ricercaStringa ho trovato la  prima corrispondenza
sono dentro l'if ho trovato la corrispondenza n:0
sono dentro il while
sono dentro il primo if di ricercaStringa ho trovato la  prima corrispondenza
sono dentro l'if ho trovato la corrispondenza n:0
sono dentro l'if ho trovato la corrispondenza n:1
sono dentro l'if ho trovato la corrispondenza n:2
[root@localhost find]# ./RicercaDecimalePerStringa
Inserire la lunghezza della parola da cercare:
6
Inserire la stringa numerica in decimale:
118
111
103
108
105
111
dimensione Array interi == 22,
dimensione Stringa numerica in ingresso == 6
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il primo if di ricercaStringa ho trovato la  prima corrispondenza
sono dentro l'if ho trovato la corrispondenza n:0
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il primo if di ricercaStringa ho trovato la  prima corrispondenza
sono dentro l'if ho trovato la corrispondenza n:0
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
sono dentro il while
[root@localhost find]#

Per completezza sono stati inseriti in ingresso i valori: 116,105 poi 101,110,101 poi 118,111,103,108,105,111;

In cui si notano risposte completamente differenti e incorrette asseconda della lunghezza e della sequenza e quindi del valore della stringa fornita in ingresso. In Java invece con la stessa logica iterativa e utilizzando le stringhe  o char il codice funziona.

Vedremo se nel COBOL linguaggio utilizzato nelle banche  funziona l'operatore di assegnamento, per char. Poiche' in teoria si ha una conversione da linguaggio di alto livello ad un linguaggio macchina, anche se con il Java questo non sarebbe necessario le banche continuano ad usare il COBOL poiche' i loro database sono di vecchia data. In COBOL non e' possibile comparare gli array sia perche' vengono sostituiti da tabelle, sia perche' e' un linguaggio piu' obsoleto del C.