ok, problema risolto :|

in pratica l'errore stava nelle condizioni del do while del main! infatti non c'era la scelta 'f' nella condizione e il programma acquisiva il tutto e poi terminava il loop e usciva con return 0;

in ogni caso ho apportato lo stesso alcune modifiche, visto che mi sono accorto dell'errore oggi con il debugger(ho scoperto finalmente come passare i parametri a ddd xD).

nella funzione che acquisice da file ci ho messo un semplice getline, una stringa con dimensioni uguali al parametro più lungo, e trasformato tutti i parametri in stringhe per evitare eventuali errori di conversione da char a int (per il cpa e il civico).

per onor di cronaca il codice ora è così:

codice:
/*
  1) aggiungere al programma persona/persona2/persona3 una funzionalita' che legga 
  la lista iniziale di persone da file. 
*/

#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iostream>

using namespace std;


const int N_MAX_PERSONE = 10;
const int N_MAX_NOME = 20;
const int N_MAX_COGNOME = 30;
const int N_MAX_NUMERO = 6;
const int N_MAX_CHAR_PER_CAMP = 30;

struct address {
  char via[N_MAX_NOME];
  char civico[N_MAX_NUMERO];
  char comune[N_MAX_NOME];
  char cap[N_MAX_NUMERO];
  char prov[3];
};

struct persona {
  char nome[N_MAX_NOME];
  char cognome[N_MAX_COGNOME];
  address indirizzo;
};

struct gruppo {
  int npers;
  persona* nomi[N_MAX_PERSONE];
  persona* cognomi[N_MAX_PERSONE];
};

void leggi_indirizzo(address& a);
void stampa_indirizzo(address a);
void leggi_nome(char s[]);
void stampa_nome(char s[]);
void leggi_cognome(char s[]);
void stampa_cognome(char s[]);
void leggi_persona(persona& p);
void stampa_persona(persona p);
void stampa_persone(persona* p[], int n);
void inizializza_gruppo(gruppo& g);
void inserisci_persona_gruppo(persona& p, gruppo& g);
void stampa_gruppo_per_nome(gruppo g);
void stampa_gruppo_per_cognome(gruppo g);

void file_acquire(int argc, char* argv[], persona& p, gruppo& g);

void swap(persona& p1, persona& p2);
void ordina_per_nome(persona* p[], int n);
void ordina_per_cognome(persona* p[], int n);
persona* cerca_per_nome(char nome[], gruppo g);
persona* cerca_per_nome1(char nome[], persona* p[], int inizio, int fine);
persona* cerca_per_cognome(char cognome[], gruppo g);
persona* cerca_per_cognome1(char cognome[], persona* p[], int inizio, int fine);


int main(int argc, char* argv[]) {
  persona* pos;
  char cognome[N_MAX_COGNOME];
  char nome[N_MAX_NOME];
  persona p;
  gruppo g;
  char s[2];

  inizializza_gruppo(g);   
  do {    
    cout << endl;
    cout << " i: inserisci\n";
    cout << " f: leggi da file\n";
    cout << " n: stampa per ordine di nome\n";
    cout << " c: stampa per ordine di cognome\n";
    cout << " o: cerca per nome\n";
    cout << " g: cerca per cognome\n";
    cout << " e: esci\n";
    cout << "\nInserisci Scelta: ";
    cin >> s;

    switch(s[0]) {
    case 'i': leggi_persona(p); 
      inserisci_persona_gruppo(p, g);
      break;
    case 'f': file_acquire(argc, argv, p, g); break;
    case 'n': stampa_gruppo_per_nome(g); break;
    case 'c': stampa_gruppo_per_cognome(g); break;
    case 'o': leggi_nome(nome);
      pos = cerca_per_nome(nome, g); 
      if(pos == NULL)
	cout << "Non trovato\n";
      else {
	cout << "Trovato: "  << endl;
	stampa_persona(*pos);
      }
      break;
    case 'g': leggi_cognome(cognome);
      pos = cerca_per_cognome(cognome, g); 
      if (pos == NULL)
	cout << "Non trovato\n";
      else {
	cout << "Trovato: "  << endl;
	stampa_persona(*pos);
      }
      break;
    case 'e': break;
    default: cout << "scelta non capita\n";
    }
  }
  while(s[0] == 'i' || s[0] == 'f' || s[0] == 'n' || s[0] == 'c' || s[0] == 'o' || s[0] == 'g');
}


//  FUNZIONI

void leggi_indirizzo(address& a) {
  cout << "\n Inserisci via: ";
  cin >> a.via;
  cout << "\n Inserisci civico: ";
  cin >> a.civico;
  cout << "\n Inserisci comune: ";
  cin >> a.comune;
  cout << "\n Inserisci cap: ";
  cin >> a.cap;
  cout << "\n Inserisci prov: ";
  cin >> a.prov;
}

void stampa_indirizzo(address a) {
  cout << "Via: " << a.via << endl;
  cout << "Civico: " << a.civico << endl;
  cout << "Comune: " << a.comune << endl;
  cout << "cap: " << a.cap << endl;
  cout << "prov: " << a.prov << endl;
  cout << endl;
}

void leggi_nome(char s[]) {
  cout << "\n Inserisci nome: ";
  cin >> s;
}

void stampa_nome(char s[]) {
  cout << "nome: " << s << endl;
}

void leggi_cognome(char s[]) {
  cout << "\n Inserisci cognome: ";
  cin >> s;
}

void stampa_cognome(char s[]) {
  cout << "cognome: " << s << endl;
}

void leggi_persona(persona& p) {
  leggi_nome(p.nome);
  leggi_cognome(p.cognome);
  leggi_indirizzo(p.indirizzo);
}

void stampa_persona(persona p) {
  stampa_nome(p.nome);
  stampa_cognome(p.cognome);
  stampa_indirizzo(p.indirizzo);
}

void inizializza_gruppo(gruppo& g) {
  g.npers = 0;
}

void inserisci_persona_gruppo(persona& p, gruppo& g) {
  persona* tmp;
  tmp = new(persona);
  *tmp = p;
  g.nomi[g.npers] = tmp;
  g.cognomi[g.npers] = tmp;
  g.npers++;
  ordina_per_nome(g.nomi, g.npers);
  ordina_per_cognome(g.cognomi, g.npers);
}

void stampa_gruppo_per_nome(gruppo g) {
  stampa_persone(g.nomi, g.npers);
}

void stampa_gruppo_per_cognome (gruppo g) {
  stampa_persone(g.cognomi, g.npers);
}

void stampa_persone(persona* p[], int n) {
  int i;
  for(i = 0; i < n; i++)
    stampa_persona(*p[i]);
}

void file_acquire(int argc, char* argv[], persona& p, gruppo& g) {
  if(argc != 2) {
    cerr << "Impossibile acquisire da file. Utilizzo: ./a.out <sourcefile>\n";
    exit(0); }
  else {
    fstream myin;
    myin.open(argv[1], ios::in);
    if(myin.fail()) {
      cerr << "Errore, file " << argv[1] << " non trovato.\n";
      exit(0); }
    else {
      char camp[N_MAX_CHAR_PER_CAMP];
      int camp_person_counter = 0;
      while(myin.getline(camp, N_MAX_CHAR_PER_CAMP)) {
	  camp_person_counter++;
	  switch(camp_person_counter) {
	    case 1: strcpy(p.nome, camp); break;
	    case 2: strcpy(p.cognome, camp); break;
	    case 3: strcpy(p.indirizzo.via, camp); break;
	    case 4: strcpy(p.indirizzo.civico, camp); break;
	    case 5: strcpy(p.indirizzo.comune, camp); break;
	    case 6: strcpy(p.indirizzo.cap, camp); break;
	    case 7:
	      strcpy(p.indirizzo.prov, camp);
	      inserisci_persona_gruppo(p, g);
	      camp_person_counter = 0;
	      break; }
      }
    }
  }
}

void swap(persona*& p1, persona*& p2) {
  persona* temp;
  temp = p1; 
  p1 = p2; 
  p2 = temp;
}

//procedura di bubble sort, per nome
void ordina_per_nome(persona* p[], int n) {
  for(int i = (n - 1); i > 0; i--)
    for(int j = 0; j < i; j++)
      if(strcmp(p[j]->nome, p[j+1]->nome) > 0)
	swap(p[j], p[j+1]);   
}

//procedura di bubble sort, per cognome
void ordina_per_cognome(persona* p[], int n) {
  for(int i = (n - 1); i > 0; i--)
    for(int j = 0; j < i; j++)
      if(strcmp(p[j]->cognome, p[j+1]->cognome) > 0)
	swap(p[j], p[j+1]);   
}

persona* cerca_per_nome(char nome[], gruppo g) {
  return cerca_per_nome1(nome, g.nomi, 0, (g.npers - 1));
}

//procedura di ricerca dicotomica, per nome
persona* cerca_per_nome1(char nome[], persona* p[], int inizio, int fine) {
  int pivot, cmp;
  if(inizio > fine) 
    return NULL;
  pivot = (inizio + fine) / 2;
  cmp = strcmp(p[pivot]->nome,nome);
  if(cmp == 0)  
    return p[pivot];
  else if (cmp > 0)
    return cerca_per_nome1(nome, p, inizio, (pivot - 1));
  else
    return cerca_per_nome1(nome, p , (pivot + 1), fine);
}

persona* cerca_per_cognome(char cognome[], gruppo g) {
  return cerca_per_cognome1(cognome, g.cognomi, 0, (g.npers - 1));
}


//procedura di ricerca dicotomica, per cognome
persona* cerca_per_cognome1(char cognome[], persona* p[], int inizio, int fine) {
  int pivot, cmp;
  if(inizio > fine) 
    return NULL;
  pivot = (inizio + fine) / 2;
  cmp = strcmp(p[pivot]->cognome, cognome);
  if(cmp == 0)  
    return p[pivot];
  else if(cmp > 0)
    return cerca_per_cognome1(cognome, p, inizio, (pivot - 1));
  else
    return cerca_per_cognome1(cognome, p, (pivot + 1), fine);
}
file input:
codice:
Tizio
Sempronio
Augusta
17
Bigville
15605
JK
Caio
Pincopallino
Artigiani
13
Monopoly
21200
TY
dalla serie: gli errori più semplici e stupidi sono quelli che ti rompono di più