[C++] Sizeof template arrays

[curry684]

De volgende code retourneert onder VC6 netjes 256, maar onder VAX/VMS krijg ik het niet gecompileerd. Is de constructie eigenlijk legaal? Is er andere manier om hetzelfde resultaat te krijgen?

C++:

template <class Piet> int Test(Piet &p_Data)
{
    return sizeof(Piet);
}

int main()
{
    char Fiets[256];
    return Test(Fiets);
}

[ Voor 31% gewijzigd door .oisyn op 28-04-2003 16:45 ]

[Verwijderd]

offtopic:
misschien zou het in elk geval een post schelen als je singature niet zo groot was, misschien wordt het daarom geblocked

Maar wat voor een meldingen krijg je precies tijdens het compileren onder VAX/VMS? En werkt "gewoon" sizeof wel?

Enneh, d'r zijn natuurlijke ook nettere STL manieren om een array met sizeinfo te maken, maar dat hoef ik jou niet te vertellen...

[.oisyn]

Dat is correcte syntax. En als je gewoon de sizeof (p_Data) retourneert, pakt ie dat wel?

curry684 schreef op 28 April 2003 @ 16:22:
_{Excuses voor 3 openingsposts maar ik zit hier achter een @#&*(&*(-proxy die crasht op te lange posts....}

fixed

[Soultaker]

Puur praktisch gezien maakt het niet uit of het legaal is, als het simpelweg niet werkt op je doelplatform. Je kunt er natuurlijk wel omheen werken:

C++:

template <class T> int my_sizeof(const T &t)
{
    return (reinterpret_cast<const char *>(&(&t)[1]) -
        reinterpret_cast<const char*>(&(&t)[0]));
}

Aangezien hier alleen gebruik gemaakt wordt informatie die at compile time bekent is, zou dit net zo efficient moeten zijn als het gebruik van sizeof. GCC (3.2.1) compileert het bijvoorbeeld al zonder enige optimalisaties naar een constant getal (afhankelijk van het type waarmee de functie geinstantieerd werd).

Natuurlijk bestaat er een kans dat deze constructie ook niet compileert (want dit lijkt me nou niet echt makkelijker voor een compiler dan simpelweg sizeof).

[ Voor 14% gewijzigd door Soultaker op 28-04-2003 16:55 ]

[curry684]

Met dank aan half uur graven in Microsoft 'Deep C++' artikelen gevonden

Zo dus:

C++:

template<typename T, size_t N>
void tag(T (&x)[N])
   {
   printf("array object of size %d\n", sizeof(x));
   printf(" and length %d\n", N);
   }

int main()
{
char    l_Test[256];

tag(l_Test);
return 0;
}

[curry684]

Zie hier voor het erg interessante artikel dat ook uitlegt waarom mijn originele aanpak dodgy was.

En DaZaffiro: m'n signature gaat echt niet mee in de HTTP POST-request hoor, dus dat maakt niet uit nee

[Verwijderd]

Maar nuttige oplossing, die moet ik onthouden... Zelf voor jouw eigen topics ben jij degene die het snelst met een complete oplossing komt...

curry684 schreef op 28 April 2003 @ 16:52:
En DaZaffiro: m'n signature gaat echt niet mee in de HTTP POST-request hoor, dus dat maakt niet uit nee

offtopic:
Maar je kunt 'em niet meer veranderen denk ik

Ik heb heel kort een proxy-tje gedraait die andersom problemen gaf: bij regels langer dan 1024 bytes plaatste die een newline. Dus de HTTP GET werd opgedeeld, regelmatig midden in een woord van HTML tag of een javascript reg
el (<= zo dus), vandaar.

Misschien dus dat het helpt om wat vaker een newline plaatsen i.p.v. lange opeenvolgende regels text Als jij geen regels code meer kunt posten op GoT...

[ Voor 42% gewijzigd door Verwijderd op 28-04-2003 17:24 ]

[curry684]

Verwijderd schreef op 28 April 2003 @ 17:12:
Maar nuttige oplossing, die moet ik onthouden... Zelf voor jouw eigen topics ben jij degene die het snelst met een complete oplossing komt...

Ik was al een uur aan het panieken voordat ik besloot ondanks de proxy hier op GoT een poging te wagen Ik had dus nogal een headstart bij het zoeken naar oplossingen...

En don't worry, kzit hier op een inhuurklus maar 's avonds kan ik nog steeds lappen code posten

[curry684]

Soultaker schreef op 28 April 2003 @ 16:50:
Natuurlijk bestaat er een kans dat deze constructie ook niet compileert (want dit lijkt me nou niet echt makkelijker voor een compiler dan simpelweg sizeof).

Op zich is de compiler niet slecht maar op de eerste poging gaf ie wel een vreemde knaller op de eerste notatie (nl. dat de reference const moest zijn). En const-reference ging nu net aan m'n doel voorbij... want het gaat om een buffer die ik moet vullen

Ik zit hier tussen de kilometers C-code te werken en moet dus hier en daar integreren met allerhande classic structs. In 1 van die structs zitten enkele tientallen C-style strings (FileName[256], dat type dus) en die moet ik vullen uit XML van een clientbak. Die moet ik ook errorchecken, en om stapels dubbele code te voorkomen heb ik dus 1 enkele template call die alle data kan extracten, en automatisch sizechecking doet (knaller op te lange input).

Ik had ook al een constructie met macro's bedacht overigens, als volgt:

C++:

bool FunctionCallEx(int P1, int P2, char* P3, int SizeOfP3);
#define FunctionCall(P1, P2, P3) FunctionCallEx(P1, P2, P3, sizeof(P3) / sizeof(char))

Dit zou an sich perfect werken (en zelfs 100% typesafe zijn) ware het niet dat ik 5 parameters heb waarvan 2 optioneel. En dakannie met een macro

Overigens heeft de uiteindelijke oplossing ook nog een zwakte omdat ik er geen single chars in kan frotten (de oude implementatie in VC herkende deze als een chararray van size 1 waardoor nog steeds lengthchecking). Ik heb nu dus een overload gemaakt voor single byref-chars. Helaas maja tis niet alsof VAX nog ondersteund wordt door DEC/Digital ik bedoel Compaq ik bedoel HP, dus ik zal het met deze compiler moeten klaren

offtopic:
Ja ik zit weer thuis vandaar de lap tekst

[ Voor 3% gewijzigd door curry684 op 28-04-2003 21:29 . Reden: typo en verduidelijking ]

[Verwijderd]

curry684 schreef op 28 April 2003 @ 21:28:
Ik had ook al een constructie met macro's bedacht overigens, als volgt:

C++:

bool FunctionCallEx(int P1, int P2, char* P3, int SizeOfP3);
#define FunctionCall(P1, P2, P3) FunctionCallEx(P1, P2, P3, sizeof(P3) / sizeof(char))

Dit zou an sich perfect werken (en zelfs 100% typesafe zijn) ware het niet dat ik 5 parameters heb waarvan 2 optioneel. En dakannie met een macro

In gcc in elk geval wel:

C++:

#define bla(a,b,c,d...) (a + b + c)

int main(void)
{
int r =  bla(1,2,3);
    r += bla(1,2,3,4);
    r += bla(1,2,3,4,5);

  return (r == 18) ? 0 : -1;
}

[.oisyn]

DaZaffiro: da's een gcc extensie

[Verwijderd]

.oisyn schreef op 29 April 2003 @ 10:32:
DaZaffiro: da's een gcc extensie

Ik was er inmiddels al achter...

Maar C99 heef net zoiets (en dus misschien de C compiler en daarmee mogelijk ook de C++ compiler), alleen dat zal wel niet gesupport worden door DEC/Digital ik bedoel Compaq ik bedoel HP

Daarin is de syntax geloof ik gedefineerd als "#define (a,b,c, ...) ", maar hier op GoT bevindt zich nog wel ergens een aantal levende C99 reference manuals die het veel preciezer kunnen uitleggen hoe en wat en alles wat erop of aan zit (heb hier zelf geen naslag bij de hand)...

[ Voor 19% gewijzigd door Verwijderd op 29-04-2003 13:56 . Reden: aanvulling ]

[.oisyn]

Dat klopt idd (C99 draft, 6.10.3, pagina 150), maar het is geen C maar C++