Newsgroup: it.comp.lang.c++
Titolo: Re: Problema con i puntatori

 stringa1 ="il contenuto della stringa";
Credo tu stia facendo confusione tra puntatori e array. L'ultima istruzione 
assegna l'indirizzo del letterale stringa (che č un array di char) alla 
variabile 'stringa1', che č un puntatore. Stai quindi compiendo due errori:
 1. stai perdendo l'indirizzo dell'array prececentemente allocato con 
'new', che non potrŕ perciň piů essere deallocato
 2. come detto sopra, stai usando un 'char*' (non const) per memorizzare 
l'indirizzo di un letterale stringa (e ciň č male)
Se il tuo programma deve manipolare stringhe di lunghezza arbitraria, č 
bene che tu faccia uso di 'std::string'. (Consulta il tuo manuale di C++ 
per ulteriori informazioni.)
Max

 }
Il codice compila perchč formalmente corretto.
Il problema č che stai cercando di modificare il valore di un elemento di
una stringa costante. In pratica, in Ptr c'č solo l'indirizzo di una memoria
di sola lettura che contiene "Una stringa".
Se vuoi fare una cosa simile, puoi alternativamente usare un array statico
(char Ptr[] = "Una stringa") oppure allocare dinamicamente e copiare la
stringa costante con strcpy().
'sera lietissima, Marco

 per il controllo degli errori?
Il controllo di quel genere di errori non e' nel programma, ma da parte 
dell'SO ('protezione della memoria').
Probabilmente, upx cambia qualche sezione dell'eseguibile, segnando come 
scrivibile quello che prima non era, o manini del genere. Non so come 
funzioni, io credevo fosse poco piu' di quello che fa una 'bzImage' nei 
confronti di un 'linux'.
-- 
Mat/tia Belletti - Undergraduate student @ 
cs.unibo.it
ICQ: 33292311    - email: 
mbel...@cs.unibo.it
IRC: RedGlow     - site(s): 
http://mbellett.web.cs.unibo.it/
Jabber: RedGlow  - Linux registered user 299762 @ machine 213003

 char * stringa2 = new char [len];
NO!!! 
Queste non sono stringhe, hanno lunghezza nota a priori, e sono un
ottimo modo per farsi del male.
1. Brucia qualsiasi libro, tutorial, ... che ti dice di fare usa
   schifezza del genere.
2. Dimentica per il momento i puntatori e gli array.
3. Usa std::string (disponidile con #include <string>):
    string s1 = "Una stringa";
    string s2 = "Pippo";
    string s3 = s1 + s2;
    s2 = s2 + s3;
    s3 = s2;
    s1 = "Una stringa mooooooooooooolto luuuuuuuuunga ..............";
        Mauro


 
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 FabioMDF
dovevo dire 'vmlinux' al posto di linux, pardon: ricordavo male il nome 
del file.
vmlinux = un file ELF con il codice di linux - e' il vero prodotto della 
compilazione di un 'make' nei sorgenti di linux.
bzImage = un piccolo decompressore + il suddetto file 'linux' compresso.
Cmq, era solo un esempio :)
PS: non usare caratteri estesi, che poi alcuni (ad es: me) potrebbero 
non leggere bene il testo.


 per il controllo degli errori?
La cosa potrebbe avere senso: upx decomprime dati compressi (anche il codice
del programma sono comunque dati) situate in una o più aree di memoria in
altre aree di memoria.
Evidentemente le nuove aree di memoria vengono rilasciate dal S.O. come "non
const", dato che upx si appresta a scrivere il codice con l'applicazione ed
i suoi dati e in questo modo il sistema operativo risulterebbe poi
"ingannato", se la modalità di accesso alla memoria non viene ridefinita.
(non è una bella cosa che possa avvenire questo! La cosa più corretta
sarebbe la segnalazione dell'errore.).
ciao.

---------------------------------------------------
char * stringa1 = new char [len];
char * stringa2 = new char [len];
assegnare un valore alla stringa1
stringa1 ="il contenuto della stringa";
---------------------------------------------------
Ma che razza di C++ č questo !?
Mandi il puntatore stringa1 allocato con in new a spasso con l'ultima riga!
Secondo me vi serve a tutti e due un corso fatto bene sul quale studiare.
In C++ le stringhe sono std::string (std::string p="Una stringa";).
I vostri sono tentativi piů o meno maldestri o peggio, infondati, di creare
array di caratteri.
Il C++ č molto piů semplice della confusione che avete in testa.
#include <iostream>
#include <string>
using namespace std;
int main()
{
        string p="Una stringa"; // e me ne frego di memoria, puntatori ed
altro!!!
        p[3]='b';
        cout << p << endl;
        return 0;
}

 per il controllo degli errori?
upx comprime l'eseguibile originale e modifica l'intestazione del file
originale in modo che la prima istruzione da eseguire sia il codice di
decompressione aggiunto da upx.
Una volta lanciato l'eseguibile compresso, il codice di decompressione
per prima cosa alloca con VirtualAlloc una zona di memoria sufficiente
a contenere il vecchio eseguibile, successivamente lo decomprime e
infine gli passa il controllo.
La memoria allocata con VirtualAlloc e' (ovviamente) scrivibile:
questo spiega perche' una stringa costante che prima non era
scrivibile lo diventa a seguito della compressione.
HTH
C:\>iao Angelo
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG