[C] Ritornare array da funzione con puntatori

[ZhelezaPHP]

Ciao, ho scritto una funzione ( pur sapendo che esiste già tale funzione ) che, date 2 stringhe me le concatena e in un'altro array, mi inseriesci le 2 stringhe unite.
Il mio problema è che vorrei usare i puntatori per assegnare all'array Mat03 lo stesso indirizzo dell'array C all'interno della funzione. Ho cercato in giro ma non ho trovato nulla. Spero mi possiate aiutare. Il Codice è questo. Se volete provarlo, usate parole singolo per le stringhe es: cane, gatto, casa ecc..
Se avete bisogno perchè sono stato poco chiaro fatemelo sapere. io sono qui.
Grazie mille del vostro aiuto ^^.

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

 char CatenaStr ( char A[], char B[] ) {
      char C[40];
      int i;
      for ( i=0; A[i]!='\0'; i++ ) {
          C[i]=A[i];
      }
      for ( int j=0; B[j]!='\0'; j++,i++ ) {
          C[i]=B[j];
      }
      C[i]='\0';
      
      // printf("\n%s\n\n",C);
      
 }
      
 main ()
 {
      char Mat01[20],Mat02[20], Mat03[40];
      
      printf("Inserisci Testo01 : ");
      scanf("%s",&Mat01);
      printf("\nInserisci Testo02 : ");
      scanf("%s",&Mat02);
      
      // Richiamo la Funzione
      CatenaStr ( Mat01,Mat02);
      
      system("Pause");
 }

[linoma]

Usualmente si usa fare in questo modo

char *CatenaStr ( char *srcA,char *srcB,char *dst)
{
.
.
.
return dst;
}

[torn24]

ho fatto anche io ai miei tempi la stessa funzione , se ci ragioni sopra vedrai che è molto
limitata , inquando dichiari un array nella funzione limitato a un certo numero di caratteri,
puoi aumentare le dimensione ma è uno spreco enorme di memoria .
prova a dare un occhiata a questo codice reperito in rete .

char *strcat1 (char *dst, const char *src)
{
  char *p = dst;
  

  while (*p)//cicla fino a raggiungere il carattere terminatore di dst
    p++;
  while ((*p++ = *src++))//associa al carattere dst il carattere src e dopo incrementa entrambi 
    ;
  return dst;//ritorna dst che essendo passato per indirizzo è disponibile anche 
//direttamente modificato
}



















char *strcat2 (char *dst, const char *src)
{
  char *p ;
 int i=0;
  p=(char*)malloc((strlen(dst)+strlen(src))*sizeof(char));

  while (dst[i]!=0)
{
    p[i]=dst[i];
   i++;
}
   while (src[i-strlen(dst)]!=0)
{
    p[i]=src[i-strlen(dst)];
   i++;
}
   p[i]=0 ;
  return p;//ritorna p che dovra essere decollocato poi con free();


 }

[ZhelezaPHP]

Non capisco il vostro medoto.
I srcA e srcB che hai messo tu non voglio che siano parametri, e nemmeno la funzione.
Ora come tipo di funzione ho usato char, ma potevo usare anche un void.

Quel che intendo io è dirgli al programma di assegnare all'array Mat03 che trovo nel main,
l'indirizzo della variabile C alla fine della funzione :

 C[i]='\0';

una sorta di cosa simile
Mat03 = &C;
solo che in questo modo non funzione perchè sono variabili locali, una nel main e l'altra nella funzione.
Forse sono io che non riesco a farmi capire...

[linoma]

I consigli scritti da tutti noi diciamo che fanno parte della dottrina (scienza dell'informazione) della programmazione (almeno di qualche anno fa), le librerei standard del c sono legge. Puoi usare anche un, sempre nel main, qualcosa di simile

static char Mat03[40]

ed eviti di usarlo come parametro. Ma a mio modo di vere le cose la migliore soluzone e quella postata.

[ZhelezaPHP]

Ecco qui un esempio di quello che intendo ma con degli interi e non array:

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

 void Esempio ( int a, int *b ) {
      *b=*b+a;
      }
      
 main ()
 {
      int x,y;
      printf("Inserisci x : ");
      scanf("%d",&x);
      printf("\nInserisci y : ");
      scanf("%d",&y);
      Esempio(x,&y);
      printf("somma: %d\n\n",y);
      system("Pause");
 }

è un programma stupido, inserisci 2 numeri e ti da la somma. ma come vedete, ho assagnato a b della funzione l'indirizzo di y e quindi anche se non ritorna nulla, y vale (a+b)..
Quello che voglio fare è la stesso cosa ma con l'array nel programma di prima.
Spero di essermi spiegato a sufficenza.
Fatemi sapere e grazie ancora della vostra disponibilità.

[Who am I]

Se tu hai questi indirizzi di memoria:

mat01  0x1000
mat02  0x1a00
mat03  0x1b00

Essendo mat01, mat02 e mat03 array e non puntatori (tra l' altro il nome non è significativo, chiamali semmai arr01, arr02 e arr03), il loro indirizzo è inassegnabile.
Cioè mat03 non può stare a sinistra di un assegnamento, ogni espressione di assegnamento che ha come lvalue mat03 è sbagliata.

Lo puoi fare con i puntatori tenendo conto che ogni parametro in C viene passato per valore, e tenendo conto che alla fine della funzione ogni variabile allocata nell stack (quindi un array ad esempio) viene deallocata.
Per cui devi usare l' allocazione dinamica:

void CatenaStr ( char A[], char B[], char** C ) 
{
// C è un puntatore a puntatore perché se fosse un puntatore a 
// char, l' assegnamento sarebbe fatto solo sulla variabile di copia
// che è locale alla funzione
      
    const unsigned long l1,l2;
    l1=strlen(A);
    l2=strlen(B);
    // Ho memorizzato la lunghezza delle stringhe per evitare di chiamare 
    // troppe volte la strlen (sarebbe inefficiente)
    *C=(char*)malloc( (strlen(A) + strlen(B) +1)*sizeof(char));
    strcpy(*C,A);
    strcpy( &  ((*C)[l1]), B);
 }

int main ()
{
      char arr1[20], arr2[20], *ptr;
      
      printf("Inserisci Testo01 : ");
      scanf("%s",arr1);
      printf("\nInserisci Testo02 : ");
      scanf("%s",arr2);
      
      // Richiamo la Funzione
      CatenaStr ( arr1, arr2, &ptr);
      return 0;
 }

Tutto questo se ho capito bene cosa vuoi fare, perché non è spiegato molto chiaramente.
Spero sia questa la tua richiesta.

[lolide]

Secondo me passare come parametro anche l'array di destinazione ma allocarlo nella funzione crea confusione e potrebbe portare a qualche leak nel caso in cui passassi un array che punta ad un blocco allocato.

char src1[10];
char src2[10];
char* dst = new char[10];
...
concat(src1, src2, &dst);

...

void concat(char* src1, char* src2, char** dst) {
   // memory leak ... perdi il blocco allocato precedentemente
   // certo se ti ricordassi sempre di passare un puntatore non allocato gia' non succederebbe nulla, ma sempre meglio non rischiare
   *dst = (char*) malloc(sizeof(char) * 10);
}

O passi il puntatore di destinazione ma non l'allochi nella funzione, oppure non lo passi come parametro ma lo ritorni allocando lo spazio nella funzione.

char src1[10];
char src2[10];
char* dst = 0;
...
dst = concat(src1, src2);

...

char* concat(char* src1, char* src2) {
   // e' impossibile che ci sia un memory leak in questo modo
   char* dst = (char*) malloc(sizeof(char) * 10);
   ....
   return dst;
}

[Who am I]

Probabilmente vuole passarlo come parametro per esercizio.

[lolide]

Originariamente inviato da Who am I
Probabilmente vuole passarlo come parametro per esercizio.

Originariamente inviato da lolide
O passi il puntatore di destinazione ma non l'allochi nella funzione, oppure non lo passi come parametro ma lo ritorni allocando lo spazio nella funzione.

Allora io non allocherei lo spazio nella funzione, ma prenderei per buono il fatto che quel puntatore punti ad un area gia' allocata.

char src1[10];
char src2[10];
char dst[20];
...
char *p_dst = concat(src1, src2, &dst);

...

char *concat(char *src1, char *src2, char **dst) {
   // e' impossibile che ci sia un memory leak ma cmq sono possibili segfaults nel caso in cui dst non punti ad un'area allocata
   // potresti fare un controllo preventivo che dst sia > 0, cosa che cmq non ti renderebbe sicuro che non ci siano seg faults
   if (dst > 0) {
      ....
   }
   // se dst e' <= 0 c'e' stato un errore perche' dst non era allocato
   return dst;
}