C Ler um texto e transformá-lo em um Array Bidimencional

IzeraXD · 14 de dezembro de 2023

# primeiro limpo depos sujo into limpo na segunda chamada sai sujo kaku
# sujo = mais de uma letra por indice do array text_read [i][p]

# fiz esse para ajeitar mas não esta repetindo esta travando no primeiro for


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


/*  ----  ❀❀❀ Prototipagens ❀❀❀  ----  */
char Text_In_Array(int F_R_N_LINES,int F_R_N_Colums, FILE *Text_Array_Inside, char Text_Read [300][300] );
void limparBuffer(void);


/*  ----  ❀❀❀ Variables ❀❀❀  ----  */
// F_R_N_LINES-->line ; F_R_N_Colums --> colum
int F_R_N_LINES;                   // F_R_N_LINES-->line
int F_R_N_Colums;                 //  F_R_N_Colums --> colum

char Text_II[300][300];
char Text_Read [300][300];
char Text_Read2 [300][300];


int main (void){
    setlocale(LC_ALL,"pt_BR");
    /*  ----  ❀❀❀ Variables ❀❀❀  ----  */
    int pp,ii;
    char *X_Rline =(char*) calloc(120,sizeof(char));
    char Text_IV[300][300];
    char Text_V[300][300];

    printf("  -------------- Mano VI ---------  \n ");
   //

  // char Text_In_Array ( int  , FILE );

    /*  ----  ❀❀❀ Sending The Archive ❀❀❀  ----  */
    FILE *Text_I;

    // Text_In_Array ( F_R_N_LINES , F_R_N_Colums ,(FILE*) (Text_I = fopen("Text_In_Array.txt","r")), Text_Read ) ;
    Text_II[ii][pp] = ( Text_In_Array ( F_R_N_LINES , F_R_N_Colums ,(FILE*) (Text_I = fopen("Text_In_Array.txt","r")), Text_Read )) ;
    // strcpy(bebe2,"menina");
    // strcpy( Text_II, ( (char*) (Text_In_Array ( F_R_N_LINES , F_R_N_Colums ,(FILE*) (Text_I = fopen("Text_In_Array.txt","r")), Text_Read))) );

    // strcpy(Text_II,((char*) *&(Text_In_Array ( F_R_N_LINES , F_R_N_Colums ,(FILE*) (Text_I = fopen("Text_In_Array.txt","r")), Text_Read)) ));
    // memcpy(Text_II,texto1,strlen(texto1)-1* sizeof(char));

    printf("\n \n  Passo  I \n \n");



    printf("\n The For passo 2,5 \n");

    printf("\n \n --- Passo III --- \n \n");
    printf(" [0]tustus %s \n",&Text_II[0] );
    printf(" [1]tustus %s \n",&Text_II[1] );
    printf(" tustus %s \n",&Text_II[0][0] );
    printf(" tustus %s \n",&Text_II[0][1] );
    printf(" tustus %s \n",&Text_II[0][2] );
    printf(" tustus %s \n",&Text_II[1][0] );
    printf(" tustus %s \n",&Text_II[0][2] );
    printf(" tustus %s \n",&Text_II[0][3] );
    printf(" tustus %s \n",&Text_II[0][4] );
    printf(" tustus %s \n",&Text_II[0][5] );

    printf("\n" );
    printf(" ---- Lilu ---- \n" );
    printf(" Lilu %s \n",&Text_Read[0][0] );
    printf(" Lilu %s \n",&Text_Read[0][1] );
    printf(" Lilu %s \n",&Text_Read[0][2] );
    printf(" Lilu %s \n",&Text_Read[0][3] );
    printf(" Lilu %s \n",&Text_Read[0][4] );


    printf(" \n -------- Mano FIM -------- \n ");
    return(0);

};



char Text_In_Array(int F_R_N_LINES,int F_R_N_Colums, FILE *Text_Array_Inside, char Text_Read [300][300] ){
    printf(" \n -------- Entro -------- \n ");
	// char *Text_Array_Inside =(char*) calloc(2000,sizeof(char));
    // FILE *Texto_Load = (*Text_Array_Inside);
    // Texto_Load  ;
    char One_Letra[1];
    char One_Letra2 = (char*) calloc(1,sizeof(char));
    char *Read_Line = (char*) calloc(120,sizeof(char));
    char *Copy_Read_Line = (char*) calloc(120,sizeof(char));
   // char Text_Read [300][300];

    // int p,i;

        // Text_Array_Inside != EOF   feof   _IO_EOF_SEEN
        // for (int i = 0; (&Text_Array_Inside) != EOF  ; i ++) {
    for (int i = 0; i != 20 ; i ++){
        fgets(Read_Line,120,*(&Text_Array_Inside));
        printf("\n voce encontrou = %s \n",Read_Line);
        strcpy(Copy_Read_Line, Read_Line);
        for( int p=0; *(&Copy_Read_Line[p]) != '\n' ; p++ ) {
            *(&One_Letra2) = *(&Read_Line[p]) ;
            
            // getchar()
            // memcpy(*One_Letra2,&Read_Line[p],sizeof(char));
            // memcpy((Text_Read[i][p]),(char*) (&One_Letra2),sizeof(char));
            // strncpy( Text_Read[i][p], ((char*) ( getchar((&One_Letra2)))) ,sizeof(char));
            // strncpy( &Text_Read[i][p], (char*) (&One_Letra2),sizeof(char)); // funciona
            // strncpy( &Text_Read[i][p],&Read_Line[p],sizeof(char));
            // strncpy( &Text_Read[i][p],&Read_Line[p],1);
            // FILE *Text_D;
            // *Text_D = *(&One_Letra2); (char*)

           // One_Letra = ; getchar(&One_Letra2);
            // strcpy(Text_Read[i][p],fgetc((FILE*) (&One_Letra2)))  ;
            //fgets(Text_Read[i][p],sizeof(char),*(&One_Letra2))

            // limparBuffer();//funciona  funciona
            // printf("%c",(char*)*(&One_Letra2)); //funciona  funciona
            // One_Letra[0] = (char*) printf("%c",(char*)*(&One_Letra2)); //funciona  funciona funciona
            // fgets( &One_Letra[0], sizeof(char) , ("%c",(char*)*(&One_Letra2) )   );
            // fgets(One_Letra[0],sizeof(char),("%c",(char*) *(&One_Letra2) )  );
            // printf("cachorro %c",&One_Letra[0]);
            // One_Letra = (char*) printf("%c",&One_Letra2);
            // One_Letra[0] = (char*) ( printf("%c",&One_Letra2));
            // strcpy(&(Text_Read[i][p]), &One_Letra[0] ); //aaaaaa
            // strcpy(Text_Read[i][p]),("%c",(char*)*(&One_Letra2)) ); //aaaaaa
            // Text_Read[i][p] = (char*) "%c",*(&One_Letra2) ;
            // fgets(&(Text_Read[i][p]),1,("%c",*(&One_Letra2)));

            // One_Letra[0] = getchar() ((char*) printf("%c",(char*)*(&One_Letra2)));
            // One_Letra[0]  = (char*) (int*) getchar(*(&One_Letra2)) ;
            // ((char*) getchar() = printf("cachorro %c",*(&One_Letra2))) = One_Letra[0]  ;
            // printf("cachorro %s",&One_Letra[0]);

                  ;
            // printf("cachorro %c",*(&One_Letra2));
            //  = 
            // &Text_Read[i][p] = (char*) getchar((FILE*)) = (FILE*) printf("%c",*(&One_Letra2))                             
            // strcat(&Text_Read[i][p],(char*) fgets(  ( (char*) getchar()  )  , 1*sizeof(char) , ( (FILE*) printf("%c",*(&One_Letra2)) )  ));
            // strcpy( &Text_Read[i][p],  (char*) fgets(  ( (char*) getchar()  )  , 1*sizeof(char) , ( (FILE*) printf("%c",*(&One_Letra2)) )  ) )  ;
            
            
            strncpy( &Text_Read[i][p], (char*) fgets(   ( (char*) getchar()  )  , 1*sizeof(char) , ( (FILE*) printf("%c",*(&One_Letra2)) )  )    , 1* sizeof(char)  );
            // strncpy( &Text_Read[i][p],  (char*) ( fgets( ( (char*) getchar((FILE*))  )  , 1*sizeof(char) , ( (char*) printf("%c",*(&One_Letra2)) ) ))   , 1* sizeof(char)  ); //aaa
            // strncpy( &Text_Read[i][p], ((char*) getchar() = printf("cachorro %c",*(&One_Letra2))), 1* sizeof(char)  ); //aaaaaa funciona 
            // strcpy(Text_Read[i][p], One_Letra[0]  ); //aaaaaa funciona 
            // strcpy(&(Text_Read[i][p]), ( "%c",(&One_Letra2)) ); //aaaaaa funciona 
            // strcpy(&(Text_Read[i][p]), ( "%c",(&One_Letra2)) ); //aaaaaa funciona 
            // strcpy(Text_Read[i][p], fgetc( (FILE*) = *(&One_Letra2)  )   )   ;
            // fgets(Read_Line,120,*(&Text_Array_Inside));
            // strcpy(Text_Read[i][p],fgetc((FILE*) ((char*) (&One_Letra2))) )  ;
            // strcpy(Text_Read,One_Letra);
            printf(" Into %s. \n ",&Text_Read[i][p]);
            // fclose(Text_D);
            limparBuffer();
            // free(One_Letra2);

            // strlen(One_Letra)


            //strncpy( &Text_Read[i][p],(char*)((getchar(&Copy_Read_Line[p])) != 1 ),1);
            // strncpy( &Text_Read[i][p],(char)(getchar(&Copy_Read_Line[p])),1);
            // Text_Read[i][p] = getchar(strncpy( &Text_Read2[i][p], &Copy_Read_Line[F_R_N_Colums],1));
        	// printf(" Into %s. \n ",&Text_Read[i][p]);
    		//return Text_Read[i][p];
            //*One_Letra2 = *(&Read_Line[p]);

            // memcpy(&One_Letra2[p],&Read_Line[p],1* sizeof(char));
            // printf(" xumm %s. \n ",&One_Letra2[p]);
            // memcpy(&Text_Read[i][p],&Read_Line[p],1* sizeof(char));
            // printf(" Into %s. \n ",&Text_Read[i][p]);
           // limparBuffer();


            // (strncpy( &Text_Read[i][p],&Read_Line[p],1) = getchar() ) != 1*sizeof(char)   ){
            // ( memcpy(&Text_Read[i][p],&Read_Line[p],1* sizeof(char)) = getchar()) != sizeof(char)
            /*
            while ( (strncpy( &Text_Read[i][p],&Read_Line[p],1) = getchar() ) != sizeof(char) ) {
                printf(" Into %s. \n ",&Text_Read[i][p]);
                limparBuffer();
            };
            */
          // free(&One_Letra2);
        };
    };
    printf("\n" );
    printf(" ---- kaku ---- \n" );
    printf(" kaku %s \n",&Text_Read[0][0] );
    printf(" kaku %s \n",&Text_Read[0][1] );
    printf(" kaku %s \n",&Text_Read[0][2] );
    printf(" kaku %s \n",&Text_Read[0][3] );
    printf(" kaku %s \n",&Text_Read[0][4] );

    // strcpy(Text_Read2 ,Text_Read);

    // return ((*&Text_Read));

};

/* <>  Clear Buffer -->  void limparBuffer(void); limparBuffer();  </>   */
// /*
void limparBuffer(void){
    fflush(stdin);
    fflush(stdout);
  //  fflush(stderr);
    setbuf(stdin,NULL);
    setbuf(stdout,NULL);
   // scanf(%*c); // windows
    __fpurge(stdin);
    __fpurge(stdout);
    // mem_flush();
    // char c;
    // while ((c = getchar()) !='\n' );
    // while ((c =getchar()) !='\n' && c != EOF);

};

devair1010 · 14 de dezembro de 2023

@IzeraXD tem muitos erros de sintaxe nesse seu código , e a função "Text_In_Array" não retorna nada , e se retornasse alguma coisa precisaria usar a função "strcpy" para preencher a string ,

Text_II[ii][pp] = ( Text_In_Array ( F_R_N_LINES , F_R_N_Colums     ,
                  (FILE*) (Text_I = fopen("Text_In_Array.txt","r")), 
                  Text_Read )) ;  /// o sinal de igual "=" não preenche a string
precisa do strcpy :
strcpy( Text_II[ii][pp] , ( Text_In_Array ( F_R_N_LINES , F_R_N_Colums     ,
                  (FILE*) (Text_I = fopen("Text_In_Array.txt","r") ), 
                  Text_Read ) ) ) ;  /// o strcpy copia o texto e preenche a string

e esse Array bidimensional "TEXT_II" na verdade é um vetor de string's , pois tem apenas Duas Dimensões , e uma matriz de string precisam ter 3 Dimensões , e não precisa e nem pode ter esse símbolos "&" no printf , e se quer apenas pegar o texto do Arquivo e colocar no Array , não precisa de tantas coisas , como _fpurge fflush setbuf , pode ser algo assim :

#define     _WIN32_WINNT 0x600
#define     _h GetStdHandle(STD_OUTPUT_HANDLE)
#include    <stdio.h>
#include    <conio.h>
#include    <iso646.h>
#include    <stdlib.h>
#include    <string.h>
#include    <windows.h>
#include    <math.h>
#include    <time.h>
#include    <locale.h>
int main    ( int argc, char *argv[]                         )
{
    int letra,fundo;
    int i = 0;
    char txt[301] = "";
    char Array[300][300] = {};
    CONSOLE_SCREEN_BUFFER_INFO _c                            ;
    if( GetConsoleScreenBufferInfo     ( _h, & _c )          )
    {
        letra = (   _c.wAttributes & 0xFF )            & 0x0F;
        fundo = ( ( _c.wAttributes & 0xFF ) >> 4    )  & 0x0F;
    }
    SetConsoleTextAttribute( _h, 11 +       ( 0 << 4 )      );
    setlocale(LC_ALL,"");
    ///-------------------------------------------------------

    FILE* arq = fopen("nome_arquiv.txt","r");
    while(fgets(txt,300,arq) != 0)
    {
        txt[strlen(txt)-1] = 0;   /// remove o newLine pego por fgets
        strcpy( Array[i] , txt ); /// coloca na posi e incrementa
        printf("%3d - %s\n",i,Array[i]);
        i++;
    }
    fclose(arq);

    ///-------------------------------------------------------
    SetConsoleTextAttribute( _h, letra +  ( fundo << 4 )    );
    printf("\n\n\n");
    return   0;
}

arfneto · 14 de dezembro de 2023

F7: bidimensional é a grafia correta, como em dimensão.

Seu programa lê lexto e mostra texto, então mostre texto aqui e não essas imagens gigantes copiadas de sua tela. Ajude outros a ajudarem você: poste um mínimo arquivo de teste que mostra o que quer fazer, e um exemplo do seu problema acontencendo, em texto.

Isso seria algo melhor que as duas telas gigantes:

entrada.txt

Pokemon
Megaman
Megamente
Kyrbi
Kaku

Porque assim alguém pode copiar isso e colar em um arquivo e tentar reproduzir seu problema em minutos.

E poste a saída do seu programa. Mas nem posso postar aqui a saída do programa que mostrou, porque ele sequer compila direito ainda.

Sobre o programa:

Quase todo o código está comentado. Qual o propósito?

Esse comando, por exemplo:

            strncpy(
                &Text_Read[i][p],
                (char*)fgets(
                    ((char*)getchar()), 1 * sizeof(char),
                    ((FILE*)printf("%c", *(&One_Letra2)))),
                1 * sizeof(char));

é algo que deve muito evitar, em especial se está começando a programar nessa linguagem. No caso de seu programa está errado mesmo, mas é algo que deve evitar mesmo que saiba o quie está fazendo.

São muitas coisas que podem dar errado, isso se a ideia em si estiver certa.

`fgets` pode dar errado. Não está sequer testando e já passa o valor como argumento para `strncpy`. Não é boa ideia.
leia o manual: `printf` retorna um `int`. Qual seria o sentido de converter para `FILE~`, algo que nem é suposto para ser tratado pelo programador?
o operador `sizeof` retorna 1 para `char`. Então tudo isso seria para de algum modo copiar uma letrinha e um `NULL`?
pra que `strncpy`? Isso é algo que poderia ter comentado... Não seria melhor ver agora o tamanho da string e alocar do tamanho certo e copiar usando simplesmente strcpy?
Está certo de entende o que é `FILE*`? Tem um livro?

Mais sobre o código

Seu programa tem muitos dos erros comuns que vemos aqui, e então vou copiar de uma lista que tenho e listar umas coisas que provavelmente deve evitar

Não use acentos em nomes de variáveis ou comentários. Evite mesmo em strings a menos que o enunciado exija. Não vai aprender nada e só vai ter problemas. Mais ainda evite usar Unicode e coisas como emojis. Nada acrescenta ao código e não sair em muitas telas, ou vai sair outra coisa. E se imprimir o programa pode não sair nada ou algum lixo.
Evite comentários como "main é a função principal" ou "declaração de variáveis" ou coisas óbvias desse tipo. Comente o porque está fazendo algo, escreva para você mesmo no futuro, tipo daqui a 2 dias quando pode não lembrar para que era aquele ponteiro, por exemplo.
evite retornar void de funções: em geral é um desperdício. E muitas vezes um erro. Use argumentos nas funções, e retorne algo delas. É mais esperto e expressivo.
Use alguma ordem em suas funções, como a ordem alfabética por exemplo. Vai gostar disso quando seu programa tiver 50 funções ao invés de umas poucas. Muitos IDE mostram uma lista das funções, em geral na ordem em que foram declaradas, de modo que você pode clicar no nome e o editor vai direto para o código, mas se estiverem em ordem é claro que você só ganha.
Nunca use variáveis globais. Isso é um pesadelo e sempre vai cair na sua cabeça. Em geral é proibido em empresas e escolas. Não declare NADA que use memória fora de main().
Não declare mais que uma variável por linha. Não acrescenta nada e só dificulta a leitura. Inicialize todas as variáveis.
Nunca leia valores do teclado para alimentar seu programa antes dele estar rodando. Só vai te atrasar e não acrescenta absolutamente nada. Use constantes, use funções que retornam a estrutura preenchida. Leia de arquivos: é trivial em C. Ao terminar os testes aí sim incorpore a leitura. Um programa interativo é chato para testar. Durante o desenvolvimento ninguém quer interagir com o programa. Nunca escreva um programa interativo, mesmo que seja o objetivo final.
Alinhe seu código com algum critério. Evite longas linhas com mais de 60 colunas.
Use nomes significativos para as variáveis e fuja de coisas como aux, aux1 e aux2. E não use nomes de variáveis enormes porque em uma expressão fica muito difícil de ler.
não use fflush(): isso só está definido para fluxos de saída. Em alguns compiladores pode até funcionar, mas é um sinal de fez algo errado e não sabe como consumir os dados.
não use setbuf a menos que saiba a razão de fazer isso. streams usam buffers porque é esperto e não o contrário.
Não existe "lixo de teclado": necessidades como de flush() na entrada indicam apenas que não entendeu bem o que está lendo e o que é a entrada via teclado, free form: o usuário pode digitar qualquer coisa e é o seu programa que tem que se virar O teclado tem ao menos 105 teclas de liberdade e o usuário pode digitar qualquer coisa em qualquer ordem.
evite ler do teclado a menos que seja o objetivo do problema. Ler de arquivos é muito mais simples, seguro e fácil de reproduzir. Não há razão para ficar parado em frente a tela minutos inventando nomes de campos e coisas assim: o efeito é que vai acabar não testando direito porque é difícil controlar e repetir testes.
Não misture entrada de dados ou formatação com a apresentação dos dados ou a lógica do programa, Isso é um desastre para manutenção e desenvolvimento.
Um printf() de 6 linhas é **muito**, mas muito melhor que 6 printf() de 1 linha. E se só vai mostrar o texto puts() é ainda melhor e dezenas de vezes mais rápido que uma série de printf().

Escreva seu programa em torno dos dados.

O que quer criar é o que todo programa `C` recebe: uma lista de strings. Esse é o protótipo normal de `main`:

        int main( int argc, char** argv);

E são os argumentos que seu programa --- e todo programa `C` recebe: uma lista de strings com o que o usuário digitou na linha de comando. O primeiro argumento é sempre o nome do programa. Isso deveria ser ensinado no PRIMEIRO programa do aluno, aquele tal `Hello World`. Mas não sou eu quem ensina ou decide isso

Os dados:

o que o programa recebe? O que o programa cria?

O programa recebe o nome de um arquivo e cria uma lista de strings. Igualzinho ao que o sistema faz para todo programa `C`, como eu disse.

Então faça igual, já que dá certo para todo programa vai dar certo para o seu:


    char nome_arquivo[250];
    const char[] arquivo_padrao = "entrada.txt";

    typedef struct
    {
        unsigned n_linhas; // quantas linhas no arquivo?
        char**   L; // o vetor de linhas
    } Array;

Já seria um bom começo:

tem onde ler o nome do arquivo.
tem um nome padrão para o caso do cara não digitar nada. E assim para testar não tem que ficar digitando nomes de arquivo duzentas vezes. E pode ter arquivos de teste já separados.
na saída vai ter o tal `Array` onde diz que o texto carregado tem n_linhas e as linhas vão estar todas arrumamindas no vetor L.

Parece simples assim.

E

  #include <stdio.h>
typedef struct
{
    size_t N;  // quantas linhas no arquivo?
    char**   L;  // o vetor de linhas
} Array;

int main(int argc, char** argv)
{
    char nome_arquivo[250];
    const char arquivo_padrao[] = "entrada.txt";
    return 0;
}

já compila e roda. Claro, só para apoio moral porque não faz nada.

5 horas atrás, devair1010 disse:

e esse Array bidimensional "TEXT_II" na verdade é um vetor de string's , pois tem apenas Duas Dimensões , e uma matriz de string precisam ter 3 Dimensões

São mesmo duas dimensões. De todo modo entenda que C sequer tem arrays multidimensionais, como FORTRAN. Só existe array. Mas tem array de array, array de array de array e assim por diante...

Então se declarar o simples

	char** Linha;

e gravar seu arquivo lá, vai ter a linha 0 em Linha[0], a linha 3 em Linha[3] e tal.

Linha[0] é o que? char*, assim foi declarado. Então

Linha é char**
*Linha é char*, Linha[0] é char*
**Linha é uma letrinha, char, assim foi declarado.
assim sendo, Linha[12][0] é a primeira letra da linha 13
a ultima letra da terceira linha seria o que?

Seguindo com o exemplo que mostrei:

#include <stdio.h>
#include <stdlib.h>
typedef struct
{
    size_t N;  // quantas linhas no arquivo?
    char** L;  // o vetor de linhas
} Array;

int main(int argc, char** argv)
{
    char       nome_arquivo[250];
    const char arquivo_padrao[] = "entrada.txt";

    char* uma   = "uma linha";
    char* outra = "outra linha";

    Array exemplo = {.L = NULL, .N = 0};

    printf("exemplo tem %llu linhas\n", exemplo.N);

    exemplo.L     = (char**)malloc(2 * sizeof(char*));
    exemplo.L[1] = uma;
    exemplo.L[0]  = outra;
    exemplo.N     = 2;

    printf("exemplo tem %llu linhas\n", exemplo.N);

    return 0;
}

Isso mostra

exemplo tem 0 linhas
exemplo tem 2 linhas

Mas é claro que vai querer mostrar o que tem dentro do vetor, as linhas, então uma função assim

	int ch_mostra(Array*,const char*); // mostra as linhas na tela

Seria a popular "mão na roda" e ainda aceita um título pra você não ter que ficar colocando os ultra chatos printf aqui e ali... Seria difícil escrever?

int ch_mostra(Array* arr,const char* msg)
{ 
	if (arr == NULL) return - 1; // sem linhas
	if (msg != NULL) printf("%s", msg);
	printf("    Vetor tem %llu linhas\n", arr->N);
	for (size_t i = 0; i < arr->N; i += 1)
		printf("#%llu\t\"%s\"\n", i, arr->L[i]);
	printf("\n******\n\n");
	return 0;
}

10 linhas está ok.

E mudando o programa aí de cima

#include <stdio.h>
#include <stdlib.h>
typedef struct
{
    size_t N;  // quantas linhas no arquivo?
    char** L;  // o vetor de linhas
} Array;

int ch_mostra(Array*,const char*); // mostra as linhas na tela

int main(int argc, char** argv)
{
    char       nome_arquivo[250];
    const char arquivo_padrao[] = "entrada.txt";

    char* uma   = "uma linha";
    char* outra = "outra linha";

    Array exemplo = {.L = NULL, .N = 0};

    ch_mostra(&exemplo, "[array vazio]\n\n");

    exemplo.L     = (char**)malloc(2 * sizeof(char*));
    exemplo.L[1] = uma;
    exemplo.L[0]  = outra;
    exemplo.N     = 2;

    ch_mostra(&exemplo, "[array deve ter duas linhas]\n\n");

    return 0;
}

int ch_mostra(Array* arr,const char* msg)
{ 
    if (arr == NULL) return - 1; // sem linhas
    if (msg != NULL) printf("%s", msg);
    printf("    Vetor tem %llu linhas\n", arr->N);
    for (size_t i = 0; i < arr->N; i += 1)
        printf("#%llu\t\"%s\"\n", i, arr->L[i]);
    printf("\n******\n\n");
    return 0;
}

E na tela mostra

[array vazio]

    Vetor tem 0 linhas

******

[array deve ter duas linhas]

    Vetor tem 2 linhas
#0      "outra linha"
#1      "uma linha"

******

É melhor escrever em torno dos dados e começar assim.

E sobre a última letra da última linha?

    // 'len' = tamanho da ultima linha
    size_t len    = strlen(exemplo.L[exemplo.N - 1]);
    char   ultima = exemplo.L[exemplo.N - 1][len - 1];
    printf(
        "\n\n\tUltima letra da ultima linha: '%c'\n",
        ultima);

E colocando isso no programa

#include <stdio.h>
#include <stdlib.h>
typedef struct
{
    size_t N;  // quantas linhas no arquivo?
    char** L;  // o vetor de linhas
} Array;

int ch_mostra(
    Array*, const char*);  // mostra as linhas na tela

int main(int argc, char** argv)
{
    char       nome_arquivo[250];
    const char arquivo_padrao[] = "entrada.txt";

    char* uma   = "uma linha";
    char* outra = "outra linha";

    Array exemplo = {.L = NULL, .N = 0};

    ch_mostra(&exemplo, "[array vazio]\n\n");

    exemplo.L    = (char**)malloc(2 * sizeof(char*));
    exemplo.L[1] = uma;
    exemplo.L[0] = outra;
    exemplo.N    = 2;

    ch_mostra(&exemplo, "[array deve ter duas linhas]\n\n");
    // 'len' = tamanho da ultima linha
    size_t len    = strlen(exemplo.L[exemplo.N - 1]);
    char   ultima = exemplo.L[exemplo.N - 1][len - 1];
    printf(
        "\n\n\tUltima letra da ultima linha: '%c'\n",
        ultima);

    free(exemplo.L);

    return 0;
}

int ch_mostra(Array* arr, const char* msg)
{
    if (arr == NULL) return -1;  // sem linhas
    if (msg != NULL) printf("%s", msg);
    printf("    Vetor tem %llu linhas\n", arr->N);
    for (size_t i = 0; i < arr->N; i += 1)
        printf("#%llu\t\"%s\"\n", i, arr->L[i]);
    printf("\n******\n\n");
    return 0;
}

Que mostra

[array vazio]

    Vetor tem 0 linhas

******

[array deve ter duas linhas]

    Vetor tem 2 linhas
#0      "outra linha"
#1      "uma linha"

******



        Ultima letra da ultima linha: 'a'

Para que isso?

Só para mostrar como acessar as letras dentro da estrutura.

IzeraXD · 14 de dezembro de 2023

juntar bash shell script com c é um poder gigantesco de mudar basicamente qualquer codigo " renomeando para txt e voltando para "html" ou sla " essa parte do codigo só aloca num array mas pode ser complementado com outras funções ....
se eu não poder fazer comparações e mudanças a posteriore com é inutul consegue fazer mudanças automatizadas em qualquer codigo comun.... que seja editavel por editor de txt vs code

<> read a txt file and transform it into an matrix. </>

example

[] [0] [1] [2] [3] [4] [5] [6]

[0] [p] [o] [k] [e] [m] [o] [n]

[1] [M] [e] [g] [a] [m] [a] [n]

why :

# you, together with bash, can transform or rename to .txt and can edit them { == | = .... }

. and transform it into "html" again

# the original idea for working with subtitles however...

</>

2 horas atrás, arfneto disse:
Kaku

14 horas atrás, IzeraXD disse:
printf(" kaku %s \n",&Text_Read[0][0] );

# é uma marcação da repetição do print na segunda vez , ma primeira vez é into e ta de boa

mas o que funciona na vdd é esse aqui

2 horas atrás, arfneto disse:

Quase todo o código está comentado. Qual o propósito?

# por que testei varias formas e misturando as
# o primeiro stcpy que substitui por texto [][] = text_in_array é o que eu quero no codigo no final, mesmo mas ta dando erro ate na forma que você mandou por isso estou mandando para uma variavel goblal
mas deixei esse probema para depos e resolver o probema maior de sujeira

# inclusive algumas que você citou mas n deu certo estou puxando no começo texto [][] = text_in_array só pra chamar a função

# , não só de ler................. de se manter sem sujeira....................... eu fui testando varias formas

sobre seu codigo eu quero letra e letra num array bidimencional por isso esse teste :

printf(" ---- kaku ---- \n" );

printf(" kaku %s \n",&Text_Read[0][0] ); //p

printf(" kaku %s \n",&Text_Read[0][1] ); //o

printf(" kaku %s \n",&Text_Read[0][2] ); //k

printf(" kaku %s \n",&Text_Read[0][3] ); //e
printf(" kaku %s \n",&Text_Read[0][4] ); //m

2 horas atrás, arfneto disse:

 strncpy(
                &Text_Read[i][p],
                (char*)fgets(
                    ((char*)getchar()), 1 * sizeof(char),
                    ((FILE*)printf("%c", *(&One_Letra2)))),
                1 * sizeof(char));

isso daqui é basicamente o seguinte o
strncpy coloco só pra pegar 1 characater
fgest coloco só pra pegar 1 characater
o getchar coloco só pra pegar 1 characater
o print ("%c") é pra mandar só um caractere para a variavel
e tudo com mesmo proposito

ṕorem rodei uma vez assim só pega uma vez o p e n continua

arfneto · 14 de dezembro de 2023

37 minutos atrás, IzeraXD disse:

untar bash shell script com c é um poder gigantesco de mudar basicamente qualquer codigo " renomeando para txt e voltando para "html" ou sla " essa parte do codigo só aloca num array mas pode ser complementado com outras funções ...

Entenda que o próprio shell foi escrito em C. Pode fazer qualquer coisa em C e muitas vezes usar um bat no Windows ou um script no Linux só vai atrasar as coisas. E mesmo assim há opções ais interessantes para transformar texto, como o clássico awk.

37 minutos atrás, IzeraXD disse:

se eu não poder fazer comparações e mudanças a posteriore com é inutul consegue fazer mudanças automatizadas em qualquer codigo comun.... que seja editavel por editor de txt vs code

Não entendi o que quer dizer. Onde não pode fazer comparações? O que quer automatizar que não pode fazer em C? O sistema foi escrito em C.

37 minutos atrás, IzeraXD disse:

example

[] [0] [1] [2] [3] [4] [5] [6]

[0] [p] [o] [k] [e] [m] [o] [n]

[1] [M] [e] [g] [a] [m] [a] [n]

why :

# you, together with bash, can transform or rename to .txt and can edit them { == | = .... }

. and transform it into "html" again

# the original idea for working with subtitles however...

O programa que eu te mostrei faz tudo o que precisa fazer. E até te mostrei como acessar as letras uma a uma em cada linha.

37 minutos atrás, IzeraXD disse:

sobre seu codigo eu quero letra e letra num array bidimencional por isso esse teste :

printf(" ---- kaku ---- \n" );

printf(" kaku %s \n",&Text_Read[0][0] ); //p

printf(" kaku %s \n",&Text_Read[0][1] ); //o

printf(" kaku %s \n",&Text_Read[0][2] ); //k

printf(" kaku %s \n",&Text_Read[0][3] ); //e
printf(" kaku %s \n",&Text_Read[0][4] ); //m

? Leu a parte em que falei sobre escrever uma série de printf de uma linha? Não deve escrever desse modo. E entenda que isso que escreveu é um loop: escreva como tal.

37 minutos atrás, IzeraXD disse:

o primeiro stcpy que substitui por texto [][] = text_in_array é o que eu quero no codigo no final, mesmo mas ta dando erro ate na forma que você mandou por isso estou mandando para uma variavel goblal

Não há nada errado no que te mostrei. Mas seu programa tinha muitos problemas. Se resolveu algum devia ir postando as versões novas ou vai ser difícil te ajudar.

Sobre uma pergunta que fiz: você tem um livro ou mais? Tem alguma referência de C?

O que escreveu com relação a FILE e algumas conversões que usou não fazem sentido.

Rodou o programa que te mostrei? Entendeu?

Entendeu o que seria "escrever em torno dos dados, o que eu tentei mostrar nos 4 programas?

arfneto · 14 de dezembro de 2023

Como parece ter resolvido seu problema, vou mostrar como continuar o programa que mostrei 4X e ter algo que vai do arquivo até o propósito de criar um vetor na memória com uma linha para cada linha do arquivo.

Acho que é legal ter algo assim no forum, que funcione para qualquer propósito, com fonte e exemplo e saída.

Escrevendo em torno dos dados:

Eis a saída que vai ser usada aqui no exemplo

typedef struct
{
    size_t incr;   // tamanho do incremento
    size_t limit;  // tamanho disponivel para uso
    size_t size;   // tamanho em uso agora
    char** line;   // as linhas

} Array2D;

Nada mais. É como em todo programa C, como expliquei antes:

	int main(int argc, char** argv);

Todo programa C recebe uma lista de argumentos, e cada linha do arquivo de entrada pode ser vista assim.

E os outros parâmetros?

Simples. Não faz muito sentido ficar alocando memória a cada linha que o programa lê. E também não dá pra imaginar um tamanho máximo e alocar como 500 linhas com 80 colunas sempre, até uma linha ter mais de 80 colunas ou um arquivo ter mais que 500 linhas.

Então tem os valores para o tamanho inicial, para cada incremento e para o tamanho total. E na criação o usuário pode escolher os valores que achar melhor.

Encapsulamento e o princípio de única responsabilidade

Esses são nomes chiques para uma coisa simples: todas as operações feitas com esse tal Array2D são feitas através de um ponteiro para a estrutura toda (encapsulamento) e dentro dela tem tudo o que importa. E cada função que opera com o Array como um todo faz uma e uma só coisa. Esse é o princípio de única responsabilidade, SRP.

As funções em um exemplo mínimo

	Array2D* create_blk(size_t size, size_t incremento);
	Array2D* delete_blk(Array2D* block);
	int      resize_blk(Array2D* block);
	int      show_blk(Array2D* block, const char* msg);

	Array2D* load_file(const char* arquivo);

O mínimo, mesmo:

cria um bloco e retorna o endereço dele.
apaga um bloco e retorna NULL
aumenta o tamanho do bloco e retorna 0 se ok
mostra o conteúdo de um bloco na tela e retorna 0 se ok
load_file recebe o nome de um arquivo e carrega em um bloco, e retorna NULL se der erro ou o óbvio endereço do bloco criado.

Claro que não vou tratar muitas condições de erro ou criar muitas operações aqui: trata-se apenas de um exemplo

EXEMPLO:

Usando isso com o arquivo "entrada.txt"

Pokemon
Megaman
Megamente
Kyrbi
Kaku

Eis como fica um programa que usa essas funções para

carregar esse arquivo na memória e mostrar as linhas na tela.
classifica em ordem alfabética e mostra de novo na tela
apaga tudo

#include "coisas.h"
int main(int argc, char** argv)
{
    char msg[80] = {0};
    if (argc < 2) usage();
    Array2D* test = load_file(argv[1]);
    if (test == NULL) return -1;
    sprintf(
        msg, "\n\n==> Carregando \"%s\" na memória", argv[1]);
    show_blk(test, msg);
    qsort(test->line, test->size, sizeof(void*), cmp_line);
    sprintf(
        msg, "\n\n==> \"%s\" depois do sort() na memória",
        argv[1]);
    show_blk(test, msg);
    test = delete_blk(test);
    return 0;
};

Eis o que o programa mostra na tela

Carregando "entrada.txt" na memória
Criando bloco para 8 linhas, incremento = 16 linhas


==> Carregando "entrada.txt" na memória
    Bloco: 5 def 8 linhas. [Incremento = 16]:
   1    Pokemon
   2    Megaman
   3    Megamente
   4    Kyrbi
   5    Kaku

==> "entrada.txt" depois do sort() na memória
    Bloco: 5 de 8 linhas. [Incremento = 16]:
   1    Kaku
   2    Kyrbi
   3    Megaman
   4    Megamente
   5    Pokemon


***** Apagando bloco *****

Carregar o arquivo é essa operação:

	Array2D bloco = load_file("entrada.txt");

Nada mais. Entra o nome, se o arquivo existe sai o endereço do bloco.

Eis um exemplo na tela do terminal para o programa chamado p...

Forum > p
Use: programa nome_do_arquivo

Forum > cat entrada.txt
Pokemon
Megaman
Megamente
Kyrbi
Kaku

Forum > p entrada.txt
Carregando "entrada.txt" na memória
Criando bloco para 8 linhas, incremento = 16 linhas


==> Carregando "entrada.txt" na memória
    Bloco: 5 de 8 linhas. [Incremento = 16]:
   1    Pokemon
   2    Megaman
   3    Megamente
   4    Kyrbi
   5    Kaku


==> "entrada.txt" depois do sort() na memória
    Bloco: 5 de 8 linhas. [Incremento = 16]:
   1    Kaku
   2    Kyrbi
   3    Megaman
   4    Megamente
   5    Pokemon


***** Apagando bloco *****


Forum >

Claro, em coisas.h tem as declarações

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct
{
    size_t incr;   // tamanho do incremento
    size_t limit;  // tamanho disponivel para uso
    size_t size;   // tamanho em uso agora
    char** line;   // as linhas

} Array2D;

Array2D* create_blk(size_t size, size_t incremento);
Array2D* delete_blk(Array2D* block);
int      resize_blk(Array2D* block);
int      show_blk(Array2D* block, const char* msg);

Array2D* load_file(const char* arquivo);
int      cmp_line(const void*, const void*);
void     usage();

Claro que para usar qsort precisa de uma função de comparação e ela está aí.

usage() é clássica em C e é mostrada se o cara esquece de dar o nome do arquivo na hora de rodar o programa.

O código para as outras funções

#include "coisas.h"

int cmp_line(const void* one, const void* other)
{
    return strcmp(
        *((const char**)one), *((const char**)other));
}

Array2D* create_blk(size_t size, size_t increment)
{
    Array2D* nb = (Array2D*)malloc(sizeof(Array2D));
    if (nb == NULL) return NULL;
    char msg[80] = {0};
    fprintf(
        stderr,
        "Criando bloco para %llu linhas, incremento = %llu "
        "linhas\n",
        size, increment);
    nb->incr  = increment;
    nb->limit = size;
    nb->size  = 0;
    nb->line  = (char**)malloc(sizeof(char*) * size);
    return nb;
}

Array2D* delete_blk(Array2D* blk)
{
    if (blk == NULL) return NULL;
    fprintf(stderr, "\n\n***** Apagando bloco *****\n\n");
    for (size_t i = 0; i < blk->size; i += 1)
        free(blk->line[i]);  // free lines
    free(blk->line);         // free block
    free(blk);               // free struct
    return NULL;
}

int resize_blk(Array2D* nb)
{
    const size_t new_sz = nb->limit + nb->incr;
    char*        new_block =
        realloc(nb->line, (new_sz * sizeof(char*)));
    if (new_block == NULL)
    {
        fprintf(
            stderr,
            "\tErro ao tentar aumentar bloco para %llu "
            "lines\n",
            new_sz);
        return -1;
    }
    nb->limit = new_sz;
    nb->line  = (char**)new_block;
    return 0;
}  // resize_blk()

int show_blk(Array2D* bl, const char* msg)
{
    if (msg != NULL) printf("%s\n", msg);
    if (bl == NULL)
    {
        printf("show(): bloco não alocado\n");
        return -1;
    }
    printf(
        "    Bloco: %llu de %llu linhas. [Incremento = "
        "%llu]:\n",
        bl->size, bl->limit, bl->incr);
    for (size_t i = 0; i < bl->size; i += 1)
        printf("%4llu\t%s\n", 1 + i, bl->line[i]);
    return 0;
}

Array2D* load_file(const char* f_name)
{
    // carrega o arquivo para dentro do Array_2D
    if (f_name == NULL) return NULL;
    fprintf(
        stderr, "Carregando \"%s\" na memória\n", f_name);
    FILE* F = fopen(f_name, "r");
    if (F == NULL) return NULL;
    // arquivo aberto
    // cria o bloco: comeca com 8, incremento = 16
    Array2D* nb = create_blk(8, 16);
    char     line[250];
    char*    p = &line[0];
    p          = fgets(p, sizeof(line), F);
    while (p != NULL)
    {
        // ainda cabe?
        if (nb->size >= nb->limit)
        {
            resize_blk(nb);
            printf(
                "Bloco estendido para um total de %llu "
                "linhas\n",
                nb->limit);
        }
        // copia a linha
        // se a string termina em `\n` apaga
        size_t fim         = strlen(p) - 1;
        if (p[fim] == '\n') p[fim] = 0;
        nb->line[nb->size] = (char*)malloc(1 + strlen(p));
        strcpy(nb->line[nb->size], p);
        nb->size += 1;
        // le a proxima
        p = fgets(p, sizeof(line), F);
    };  // while()
    fclose(F);
    return nb;
}

void usage()
{
    fprintf(stderr, "Use: programa nome_do_arquivo\n");
    exit(EXIT_FAILURE);
}

É isso.

Funciona para qualquer coisa. Eis um exemplo usando o próprio arquivo coisas.h

==> Carregando "coisas.h" na memória
    Bloco: 22 de 24 linhas. [Incremento = 16]:
   1    #pragma once
   2    #include <stdio.h>
   3    #include <stdlib.h>
   4    #include <string.h>
   5
   6    typedef struct
   7    {
   8        size_t incr;   // tamanho do incremento
   9        size_t limit;  // tamanho disponivel para uso
  10        size_t size;   // tamanho em uso agora
  11        char** line;   // as linhas
  12
  13    } Array2D;
  14
  15    Array2D* create_blk(size_t size, size_t incremento);
  16    Array2D* delete_blk(Array2D* block);
  17    int      resize_blk(Array2D* block);
  18    int      show_blk(Array2D* block, const char* msg);
  19
  20    Array2D* load_file(const char* arquivo);
  21    int      cmp_line(const void*, const void*);
  22    void     usage();


==> "coisas.h" depois do sort() na memória
    Bloco: 22 de 24 linhas. [Incremento = 16]:
   1
   2
   3
   4
   5        char** line;   // as linhas
   6        size_t incr;   // tamanho do incremento
   7        size_t limit;  // tamanho disponivel para uso
   8        size_t size;   // tamanho em uso agora
   9    #include <stdio.h>
  10    #include <stdlib.h>
  11    #include <string.h>
  12    #pragma once
  13    Array2D* create_blk(size_t size, size_t incremento);
  14    Array2D* delete_blk(Array2D* block);
  15    Array2D* load_file(const char* arquivo);
  16    int      cmp_line(const void*, const void*);
  17    int      resize_blk(Array2D* block);
  18    int      show_blk(Array2D* block, const char* msg);
  19    typedef struct
  20    void     usage();
  21    {
  22    } Array2D;


***** Apagando bloco *****


Forum >

Sugiro testar em sua máquina e escrever de volta se não entender a ideia.