array of pointers afdrukken

Hallo iedereen,

Ik probeer al enige tijd een woord in een array van pointers te krijgen maar het lukt me maar niet. Ik heb het nog gedaan maar om één of andere wil het maar niet afdrukken. Het is voor op een microcontroller maar ik simuleer het even.

Ik denk dat ik het wel in de pointer zet maar er een fout zit in het afdrukken. Er zou "bbbbbbbbbbbbbbbbb" op de console moeten verschijnen. Ziet iemand misschien wat ik verkeerd doe?


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


void writeString(char *string)
{
	while(*string)
	{
		printf("%c",*string);
		string++;
	}
}
int main(void)
{
	
int i;
char *buffer;
char buffering=0;
buffer = (char*) malloc (50);
for(i=0;i<17;i++)
{
	buffering = 'b';
	*buffer = buffering;
	buffer++;
}
	*buffer='\0';
	writeString(buffer);
	
	return 0;
}

buffer++ mag in dit geval niet want je bent zo je originele pointer waarde kwijt.

Dus een werk copie van buffer maken bijvoorbeeld.


char *tmp;
....

tmp = buffer;
for(i=0;i<17;i++)
{
	buffering = 'b';
	*tmp = buffering;
	tmp++;
}
*tmp = '\0';

writeString(buffer); blijft natuurlijk zo staan met de originele pointer.

Laten we beginnen met dat je niet van plan bent wat in die pointer te zetten, maar in het blok memory waar die pointer naar point! (althans... dat doet je code vermoeden)

Verder precies wat Henri zegt. Je helpt met buffer++ je pointer om zeep. Da's op zich niet erg (als je het bewust doet), maar gezien het feit dat je die om zeep geholpen pointer vervolgens als argument aan een function mee geeft, doet vermoeden dat je dit niet bewust doet...

Andere oplossing dan henri aangeeft is in deze context een memset(buffer, 'b', 17) (en dan op het handje de 0 erachter plakken).

Tip: verdiep je eens in pointers. Essentiële C basis kennis als je meer wilt dan een μC (bij gebrek aan memory en dus dynamic allocation zijn ze daar niet zo spannend). Zeker als je pointer-naar-pointers gaat krijgen of function pointers, kun je je lol op als je het niet tot in de puntjes beheerst. Ook altijd goed om te weten wie 'owner' van een memory block is om 'misverstanden' te voorkomen...

Bedankt voor de tips. Het is me nu gelukt om de pointer af te drukken. Ik heb het nodig voor mijn lcd scherm. Elke second moet deze op een bepaalde plaats in het geheugen een waarde gaan aflezen en op een andere plaats op het scherm afdrukken. Nu lukt dit. Het probleem is dat dit maar een 20-tal keer perfect lukt. Dan slaagt mijn lcd scherm tilt en komen er rare tekens op. Ik ben er vrij zeker van dat dit iets met mijn pointer te maken heeft.

Ik heb de pointer globaal geïnitialiseerd en ik alloceer ze in mijn main functie, zodat ze maar één keer gealloceerd worden. Als ik deze elke keer alloceer in de functie dat ik oproep dan slaat mijn scherm direct tilt. Iemand een idee aan wat dit zou kunnen liggen want ik zou het echt niet weten. Er is geheugen vrij gemaakt, de pointer begint bij elke functie terug vooraan en hij wordt nooit grooter dan 14 bytes.


globaal:

char *buffer;
char *tmp;
char buffering=0;

int main()
{
buffer = (char*) malloc (20);     // gealloceerd in de main
tmp = (char*) malloc (20);
}

void readrooster(unsigned int plaats)
{

int i;
tmp = buffer;
setAddressPointer(plaats);


while(!(checkStatus()& 0x03 )==3);
writeCommand(0xB1);
while(!(checkStatus()& 0x04 )==4);
for(i=0;i<14;i++)                        
{
	
	while(!(checkStatus()& 0x20 )==0x20);
	buffering = readData();
	*tmp = buffering;
	tmp++;
	while(!(checkStatus()& 0x04 )==4);
}
writeCommand(0xB2);
*tmp ='\0';
setAddressPointer(HOUR_TEXT_HOME_ADDRESS + (13*20)+5);
transmit_str_USART0("vier");
while(*buffer)
	{
		writeData(*buffer);
		buffer++;
		while(!(checkStatus()& 0x03 )==3);
		writeCommand(0xC0);
	}
	
//transmit_str_USART0(buffer);
}

Op 15 mei 2011 14:41:14 schreef kevindeb:
Bedankt voor de tips. Het is me nu gelukt om de pointer af te drukken.

Nog een keer: verdiep je eens in pointers. Je drukt geen pointer af, maar de data waar die pointer naar point. Punt. Meer is het niet.

Ik heb het nodig voor mijn lcd scherm. Elke second moet deze op een bepaalde plaats in het geheugen een waarde gaan aflezen en op een andere plaats op het scherm afdrukken. Nu lukt dit. Het probleem is dat dit maar een 20-tal keer perfect lukt. Dan slaagt mijn lcd scherm tilt en komen er rare tekens op. Ik ben er vrij zeker van dat dit iets met mijn pointer te maken heeft.

Ik ook. 3de keer: verdiep je eens in pointers...

Ik heb de pointer globaal geïnitialiseerd en ik alloceer ze in mijn main functie, zodat ze maar één keer gealloceerd worden.

Waarom dan niet gewoon op de stack / statisch??? Scheelt een hoop gedoe en runtime lib (heel memory manegement kan de vuilbak in!)

Als ik deze elke keer alloceer in de functie dat ik oproep dan slaat mijn scherm direct tilt. Iemand een idee aan wat dit zou kunnen liggen want ik zou het echt niet weten. Er is geheugen vrij gemaakt, de pointer begint bij elke functie terug vooraan en hij wordt nooit grooter dan 14 bytes.

Waarom malloc je die tmp als je die in readrooster (waar wordt die aangeroepen?) gelijk stelt aan buffer? Verder zie ik weer een buffer++ staan in je readrooster. Is de boodschap over wat dat doet niet aangekomen?

Nog een keer: verdiep je eens in wat een pointer is...

Ofwel: wat probeer je nou eigenlijk te doen??

De malloc van tmp is zinloos in de main.

In readrooster() zet je de declaratie van de pointer:

char *tmp;

Dit is goed:
tmp = buffer;
Dit is nu een tmp-pointer naar buffer.

Verder werk je nu alleen met 'tmp'.

Kortom, die:
while(*buffer)

moet dan worden:
tmp = buffer;
while(*tmp)

Worden, en in die loop tmp gebruiken.

P.S.: Waar zit de aanroep van readrooster() ???