Hoi,
Zie deze:
Als ik een verklaring afleggen:

char * I, J [15], * k;
en dan doen
sprintf (k, "print.sh% s", i);

het programma werkt prima.

Maar toen ik de aangifte naar:
char * i * k;
en dan doen
sprintf (k, "print.sh% s", i);
Ik krijg een segmentatiefout bij het 'sprintf' verklaring.

Het programma werkt alleen wanneer j is een array van 15. Niets minder / meer

Let op: variabele j is gewoon een pop. Ik heb helemaal niets mee.
Ook, ik weet het gebruik sprintf de manier waarop ik heb gedaan is illegaal. De aanwijzer wordt niet toegewezen aan iets, voorafgaand aan een dergelijke verklaring.

Het kan zo gek maar kan iemand alsjeblieft uitleggen waarom dit gebeurt? Denk iets te maken met de manier waarop geheugen wordt toegewezen.

Thanks in advance!

U probeert te schrijven naar willekeurige geheugen als "k" niet is gewezen op alles. De kernel kan u drie antwoorden ...

(a) laat je het

(b) de val omdat u schrijven naar alleen-lezen geheugen, bijvoorbeeld het programma afbeelding

(c) val omdat u schrijven naar geheugen dat niet is toegewezen aan je

Nou, op de bovenstaande regels, kon ik verder afleiden:

1. in een geval, k werd gewezen op stdout (dont know how!), coz zijn geheugen inhoud die van mijn printf verklaring voorafgaand aan de sprintf. (Verrassend!)

2. In een geval, k werd gewezen op de string van mijn sprintf verklaring. Vandaar nogmaals, het is niet illegaal, en het programma zou werken. (Lijkt mogelijk).

Echter, dit soort geldig maar vuilnis initialiseert lijken alleen gebeuren wanneer variabele j wordt aangegeven. Anders, het programma stopt door SEGV.

Maar ik geloof nog steeds dat dit een bijzondere en eenmalige zaak. Guess dezelfde code niet zou werken op een andere machine. (Mine is Solaris).

Eventuele opmerkingen / input / verder inzicht anyone?

De stack belangrijkste is dat het gebruik zal niet onaangeroerd maagd geheugen, zal zijn gebruikt voor subroutine oproepen door het programma van de proloog, dwz crt0.o (of wat dan ook) voordat de main () wordt aangeroepen.

Het geheugen is echt in een onbekende toestand, maar ik neem uw opmerking over de inhoud wordt herhaald onder bepaalde voorwaarden. Ik noem het een zaak van dejà vu.

mee eens . Maar in herhaalde loopt, wordt het programma variabelen zijn toegewezen dezelfde geheugenlocatie.
Zelfs op het lezen in een zeer groot string (20 tekens) en sturen het naar sprintf, is het verrassend hoe er geen segmentatiefout.

Op een bepaald punt, tenzij 'k' wijst naar stdout, de lengte van het geheugen moet veroorzaken overtreding, en programma moeten krijgen SEGV recht?

Ook, indien op alle 'k' naar stdout, wel door een flush onmiddellijk zou ik zie de inhoud van 'k' recht? coz kon overschrijven vorige inhoud van stdout.

Proberen en te zien ...?

Bent u draaien onder gdb en zien waar dingen zijn eigenlijk heen?

U heeft een probleem in beide gevallen. Een wordt gevangen, de andere niet.
"char * I, J [15], * k", zegt het volgende:
Punt naar het geheugen en de oproep die pointer i;
Maak ruimte in het geheugen tot 15 tekens en bel die ruimte j;
en wijzen op het geheugen en noem dat aanwijzer k;

Wanneer u probeert te doen "sprintf (k," print.sh% s ", i);" u vraagt de computer naar de stick de string "print.sh?" in het geheugen locatie u erop met de pointer variabele k. Uw probleem is dat u niet alle toegewezen ruimte om de string op de aanwijzer locatie van K, K is momenteel alleen te wijzen op enkele willekeurige geheugenlocatie en er geen ruimte is toegewezen om iets op de geheugenlocatie wees op door K.

Dat is de reden dat het sterft. De reden dat doensn't die (nog) niet in het voorbeeld waar j wordt toegewezen ruimte, is dat er ten minste een aantal toegewezen ruimte op de stack, en k is waarschijnlijk per ongeluk wijst er, en daarvoor beschadiging j, maar niet leidt tot een segv (nog) niet.

Ik stel voor dat je gaat studeren op de verschillen op * K, K [10], k [10,10] en ** k. Als je begrijpt wat deze verschillende vormen bedoel, je bent systeembeheerder hebben een veel betere dag.