Newsgroup: it.comp.lang.c
Titolo: Funzione riguardo il codice ASCII

Mi servirebbe sapere se esiste una funzione standard di libreria che
converta in automatico tutti i caratteri del codice ASCII nel loro
corrispettivo valore numerico (0 - 255).
In particolar modo (specialmente nel caso questa funzione non
esistesse) avrei bisogno di sapere se c'è uno stratagemma o altro per
far compiere in automatico questa cosa ad esempio (ed è quello che mi
serve) passando tutta una stringa di caratteri di ogni tipo presa in
input nel main, immagazzinata in un vettore, e data in pasto alla
funzione per la conversione automatica.
Perchè per quanto riguarda i caratteri alfanumerici, questi non sono
un problema nel doverli ricordare a mente (basta sapere i valori di
'a', 'A' e 0 e poi avanzare con la conta). Rappresentano invece un
problema i restanti simboli che non si possono imparare a memoria
(cioè nel senso che al momento di scrivere il codice per la funzione
non ricordo il loro rispettivo valore numerico da inserire nelle
istruzioni di assegnazione).
Vi chiedo questo perchè mi sembra strano che in un linguaggio come il
C non ci sia nulla del genere.

 C non ci sia nulla del genere.
char c = 'A';
printf("%u", c);
-- 
bunker
+++++++++++[>++++++>+++++++++++++++++++++++++++++++++>++++
++++++<<<-]>.>++++++++++.>.<----------.>---------.<+++++++.


No perché non ce n'è bisogno. Mentre altri linguaggi di programmazione ti 
mettono a disposizione delle funzioni per la conversione fra i caratteri ed 
il loro valore, inducendo i programmatori a credere che siano cose diverse, 
in C questo non è necessario perché il contenuto di un byte è e rimarrà un 
semplice valore ed il fatto che lo si veda come carattere ASCII o come 
valore decimale piuttosto che ottale o esadecimale dipende solo da come lo 
si vuole rappresentare il valore del byte comunque non cambia. Questo è 
comunque lo scoglio più comune che un programmatore incontra quando si 
avvicina al C (a meno che non arrivi dall'assembler o simili). Per 
chiarificarti ulteriormente questo concetto ti ho scritto un esempio che 
stampa una tabella ASCII sulla console DOS. Spero ti possa esser utile il 
suo studio.
#include <stdio.h>
#include <conio.h>
int main(void);
int main(void)
{
 unsigned int c;
 printf("      0   1   2   3   4   5   6   7   8   9");
 for(c = 0; c <= 0xFF; c++)
 {
      if(!(c % 10))
           printf("\n%03u", c);
      switch(c)
      {
      case 7:         /* beep */
           printf("  BL");
           break;
      case '\n':       /* new line */
           printf("  NL");
           break;
      case '\r':       /* return */
           printf("  CR");
           break;
      case '\b':      /* backspace */
           printf("  BS");
           break;
      default:
           printf("   %c", c);
           break;
      }
 }
 printf("\nPremi un tasto...");
 getch();
 return 0;
}
Dovrebbe esser compilabile.
Un saluto.
Maxime

Ti ringrazio Maxime per questa analisi ma il problema è che ancora non
riesco a formulare un codice valido per far in modo di crittografare al
volo (e di conseguenza immagazzinare in un nuovo vettore/stringa di
testo) i caratteri man mano che questi vengono letti. Un programmatore
potrebbe fare tutto ciò avendo sotto mano un libro con la tabella
relativa a tutti i valori dei caratteri ascii eccetera e scrivere una
serie di strutture con istruzioni relative che assegnerebbero ad ogni
carattere il rispettivo crittografato. Invece io sono sicuro che esiste
un modo assai meno complesso per eseguire un programma di crittografia
standard. Ci sono i simboli speciali (per la maggior parte inutili) che
creano non pochi problemi a ricordare a mente tutti i valori dei
caratteri alfanumerici. Conoscendo ad esempio che il valore massimo
raggiungibile per i caratteri ascii è 255 (0xFF), qualcuno saprebbe
darmi la struttura meno articolata che svolga questo compito? ad
esempio, ho il main e una funzione che svolge questo compito. Alla
funzione vengono passate tre stringhe (una completamente vuota da
riempire con il testo crittografato, una con il testo che si vuole
crittografare, ed una che contiene caratteri per crittografare). La
funzione ritorna la nuova stringa di testo crittografata. Qualcuno
saprebbe aiutarmi?

s-mik ha scritto:

Se spiegavi meglio all'inizio qual'era il tuo scopo forse era meglio
:-)
ti metto qui il codice necessario a crittare una qualsiasi stringa.
Ora ho caldo e non mi va di espletarne il funzionamento :-)
comunque non dovrebbe essere difficile osservandone i parametri con cui
richiamarla.
L'algoritmo e' reversibile, significa che puoi passare la stringa
crittata e avere l'originale in risposta (passando ovviamente gli
stessi parametri).
Il nocciolo di crittaggio è semplice e personalizzabile (nelle mie
routine eseguo qualche calcolo in piu' :-)).
Ciao
<code>
// queste solo nell'improbabile caso non siano gia' definite
typedef unsigned char BYTE;
typedef BYTE* LPBYTE;
typedef const BYTE* LPCBYTE;
typedef unsigned short WORD;
typedef unsigned long DWORD;
//----------------------------------------------------------------------------
// nocciolo
WORD crypt(LPBYTE t, LPCBYTE s, int k, int l)
{
  WORD i = 0;
  WORD j = 0;
  WORD w = 0;
  for(;i < l; ++i) {
    j += s[i];
    d[i] = s[i] ^ (k+i);
    w += d[i];
    }
 return j ^ w;
}
//----------------------------------------------------------------------------
WORD cryptBuffer(LPBYTE target, LPCBYTE source, DWORD dimSource,
LPCBYTE key, int dimKey, uint step)
{
  int currKey = 0;
  int repeat = dimSource / step;
  int remain = dimSource % step;
  WORD crc = 0;
  int i;
  target[dimSource] = 0;
  for(i = 0; i < repeat; ++i) {
    crc += crypt(target, source, key[currKey], step);
    ++currKey;
    currKey %= dimKey;
    buff += step;
    }
  if(remain)
    crc += crypt(target, source, key[currKey], remain);
    }
  return crc;
}
//----------------------------------------------------------------------------
// esempio di utilizzo
/*
  BYTE key[] = "pippo";
  char source[] = "testo di prova di qualsiasi lunghezza desiderata";
  char target[sizeof(source)];
  WORD crc = cryptBuffer((LPBYTE)target, (LPBYTE)source, sizeof(source)
- 1, key, sizeof(key) - 1, 8);
  printf(target);
  printf("\r\n");
  crc = cryptBuffer((LPBYTE)target, (LPBYTE)target, sizeof(source) - 1,
key, sizeof(key) - 1, 8);
  printf(target);
  printf("\r\n");
*/
</code>

 }
ops. naturalmente 'd' va sostituito con 't' o viceversa
(copy&paste e rimozioni parti custom frettoloso)

     buff += step;
------ correzione -------
       target += step;
       source += step;
---------------------------
