[C++] Pointer initialisatie met array(unsigned char* = )

[Olaf van der Spek]

Is het mogelijk een pointer (a) zo te initialiseren (vergelijkbaar met b)?
Op deze manier werkt het niet, maar hoe moet het wel?
Uiteidenlijk wil ik een pointer in een struct op deze manier initialiseren of moet ik er dan toch een array van maken?

code:

#include "stdafx.h"

int main()
{
    char* b = "Tweakers";
    unsigned char* a = {0, 1, 2, 3};
    return 0;
}

[whoami]

Wat bedoel je precies?

code:

char* b = "Bdkdkd";

is geen probleem,

die andere pointer (a), daar moet je

code:

unsigned char* a = {'0', '1', '2'};

van maken.

[Olaf van der Spek]

Dat levert op:

code:

error C2440: 'initializing' : cannot convert from 'const char' to 'unsigned char *'
        Conversion from integral type to pointer type requires reinterpret_cast, C-style cast or function-style cast

[farlane]

C:

const char * p [] = { "Ik", "Ben","Lief" };

[whoami]

farlane schreef op 25 september 2002 @ 14:59:

C:

const char * p [] = { "Ik", "Ben","Lief" };

Dat zijn geen characters maar strings.

[farlane]

whoami schreef op 25 september 2002 @ 15:07:
Dat zijn geen characters maar strings.

Hmmm... ik meende dat dat ook was wat Dhr vdSpek wilde bereiken.
( Of ik snap de vraagstelling niet. )

[whoami]

farlane schreef op 25 september 2002 @ 15:13:
[...]


Hmmm... ik meende dat dat ook was wat Dhr vdSpek wilde bereiken.
( Of ik snap de vraagstelling niet. )

Als het zo is, dan is het natuurlijk mogelijk zoals jij het zegt.

Of het kan ook zo:

code:

char** blaat = { "ik", "ben", "niet", "lief"};

Dacht ik zo....

[farlane]

Of zo, maar dan is het geen pointer, wat naar mijn idee niet veel uitmaakt in dat geval:

C:

const char a [] = { '1','2','3' };

[Verwijderd]

Ik heb het vermoeden dat hij dit bedoelt

C++:

const unsigned char a [] = { 
(unsigned char) 1 , 
(unsigned char) 2 , 
(unsigned char) 3 , 
(unsigned char) 4 
};

[Olaf van der Spek]

Wat ik wil is de volgende variable direct initialiseren:

code:

unsigned char* a = ...;

Dit is dus een pointer en geen array. Het moet een pointer zijn omdat de lengte variabel moet zijn.

[.oisyn]

een pointer heeft geen variabele lengte, en als je de array langer wilt maken zul je een nieuwe moeten alloceren, de data moeten kopieren en dan de oude array evt. verwijderen.

Oftewel, als je een dynamische array wilt initializeren zul je een nieuwe moeten alloceren en dan de data moeten kopieren

en je kunt natuurlijk ook gewoon een array aan een pointer assignen

C++:

int bla[] = { 1, 2, 3, 4};
int * bla2 = bla;

[Olaf van der Spek]

Maar waarom kun je niet gewoon unsigned char* = {} gebruiken net als char* = "TN"?

[farlane]

OlafvdSpek schreef op 25 september 2002 @ 16:13:
Maar waarom kun je niet gewoon unsigned char* = {} gebruiken net als char* = "TN"?

Omdat een unsigned char * geen array is. Je gebruikt een array init. notatie voor een pointer.

[edit]

Zoiets kan natuurlijk wel:

C++:

const char bla [] = { 'a','b','c' };

struct blabla
{
    blabla( const char * p_bla );

    const char * p_bla;
};

blabla::blabla( const char * p_bla )
{
    this->p_bla = p_bla;
}

void main()
{
    blabla c( bla );


    std::cout<<c.p_bla[0]<<std::endl;
    std::cout<<c.p_bla[1]<<std::endl;
    std::cout<<c.p_bla[2]<<std::endl;
    std::cin.get();
}      

[Olaf van der Spek]

Maar is er dan geen manier om een pointer init constructie te gebruiken?

[farlane]

OlafvdSpek schreef op 25 september 2002 @ 16:28:
Maar is er dan geen manier om een pointer init constructie te gebruiken?

Zie boven ...

[Olaf van der Spek]

Maar dan dus niet met een andere variabele, maar met de echte waardes.

[farlane]

OlafvdSpek schreef op 25 september 2002 @ 16:51:
Maar dan dus niet met een andere variabele, maar met de echte waardes.

Die andere variabele heeft toch waarden aan boord?

[.oisyn]

dit:

C++:

const char * bla = "abcd";

is hetzelfde als:

C++:

const char __constante_string[] = { 'a', 'b', 'c', 'd', 0 };
const char * bla = __constante_string;

behalve dan dat deze manier een extra naam introduceert. Dit is alleen een syntactisch iets; in je programma zal daar niets van terug te vinden zijn

Helaas kun je array inits niet gebruiken zoals je string literals kunt gebruiken. De waarde "abcd" kun je immers gewoon als parameter aan een functie meegeven. { 1, 2, 3, 4 } echter niet (jammer genoeg).

(daar is natuurlijk ook wel weer wat voor te zeggen: een string tussen quotes zal over het algemeen const char[] zijn (of wchar_t, maar iig 1 vast type), maar gewoon een setje waardes tussen accolades kan in principe alles zijn)

[Olaf van der Spek]

Ik wilde iets doen als (om een deel van een patch):

C++:

struct patch_t
{
  int offset;
  int size;
  unsigned char* s;
  unsigned char* d;
};

Maar dat kun je dus niet simpel initialiseren.

[.oisyn]

tja, je zou natuurlijk een utility functie kunnen maken:

C++:

unsigned char * makeUCharArray (int num, ...)
{
    unsigned char * buf = new unsigned char [num];

    va_list l;
    va_start (l, num);
    for (int i = 0; i < num; i++)
        buf[i] = va_arg (l, unsigned char);

    return buf;
}

void jeFunctie ()
{
    patch_t patch =
    {
        12,
        253,
        makeUCharArray (3, 1, 2, 3),
        makeUCharArray (5, 1, 2, 3, 4, 5)
    };
    ...
}

(nog mooier zou zijn om een template functie te maken zodat je elk type array zo kunt maken, maar erg type-safe is het niet (die functie parameters kunnen namelijk alles zijn))

[Verwijderd]

Lol, dit topic gemist; casten is toch moeilijk

const unsigned char *p= (const unsigned char[]){ 65, 66, 67, 0 };

Werkt gewoon

[.oisyn]

mietje: uhm, bij mij toch echt niet hoor (MSVC 7)
gcc extension misschien?

[Verwijderd]

.oisyn>> Problematisch Dit soort constructies mochten vroeger in C (voordat ISO/ANSI lastig ging doen) en zowat iedere compiler vreet dit dan ook in C-mode (met hooguit een warning). In C++ is het verboden en zul je die array een naampje moeten geven.

edit:
In C99 mag het wel weer

[.oisyn]

* wijst naar topictitel *

MSVC 7 in C mode accepteert het overigens ook niet, en aangezien het niet de standaard is zou ik het ook niet gebruiken

[Verwijderd]

/me wijst naar de extern "C" declaratie

edit:
Het ligt er dus maar aan welke standaard, het mag niet volgens C89 maar wel volgens C99

[.oisyn]

dan mag jij verklaren waarom het volgende compilet:

C++:

extern "C"
{
    int * blaat ()
    {
        return new int[4];
    }
}

(extern "C" is niet iets om je compiler om te schakelen naar C-mode ofzo, het geeft alleen maar aan wat voor linkage er gebruikt moet worden. Zie punt 7.5 van de Ansi C++ standaard)

[Diadem]

Wat is nu eigenlijk de meest gebruikelijke manier van schrijven?

int* blaat;
int *blaat;
int * blaat;

Ze zijn alledrie toegestaan natuurlijk, maar wat is standaard?

* Diadem vind de tweede manier het mooiste staan. Eerste is wel het meest logische echter.

[.oisyn]

standaard

het is puur een persoonlijke voorkeur, nix standaards aan

ik doe meestal 1 spatie tussen het type en de ster(retjes), en dan indenteer ik de variabele nogmaals:

C++:

int          i;
Window *     window;
Blaat **     b;

alleen dat is wat lastig als je een pointer naar een functie declareert, want dat gaat niet op die manier

Als parameters voor functies gebruik ik gewoon dubbele spaties:

C++:

void func (int * a, int * b, const Vector & v)
{
    ...
}

[curry684]

My humble opinion: je declareert een variabele van het type 'pointer naar object x' en om die reden hoort het sterretje bij het type. Sowieso staat het netjes om zoals Oisyn doet de namen gelijk te indenteren, bijv.:

C++:

int          l_Integer;
Window*      l_Window;
Blaat**      l_Blaat;

Een echte bikkel gebruikt trouwens geen pointers in declaraties, daar heb je smart pointers voor en dan hoef je geen sterretjes meer te zien

[Verwijderd]

curry684 schreef op 26 september 2002 @ 20:47:
My humble opinion: je declareert een variabele van het type 'pointer naar object x' en om die reden hoort het sterretje bij het type.

De volgende declaratielijst demonstreert dat het sterretje bij de identifier hoort:

code:

int * a, b; // b is een int, geen int*

Bij het declareren van meerdere pointers zal het sterretje (en eventuele cv-qualifiers) dus voor iedere variabele herhaald moeten worden (erg stom imho).

[Olaf van der Spek]

Ik heb maar gekozen voor een int[], dan maar geen RLE. Het gaat toch om relatief weinig bytes die gepatched worden en zo is het automatisch vullen van de array ook iets makkelijker.

[curry684]

Verwijderd schreef op 26 september 2002 @ 22:58:
[...]
De volgende declaratielijst demonstreert dat het sterretje bij de identifier hoort:

code:

int * a, b; // b is een int, geen int*

Bij het declareren van meerdere pointers zal het sterretje (en eventuele cv-qualifiers) dus voor iedere variabele herhaald moeten worden (erg stom imho).

En daarom houdt iedere nette programmeur zich aan de regel 'Een declaratie per coderegel', want voorkomen is beter dan debuggen

[Verwijderd]

curry684 schreef op 27 september 2002 @ 14:51:
[...]

En daarom houdt iedere nette programmeur zich aan de regel 'Een declaratie per coderegel', want voorkomen is beter dan debuggen

Voor programmeurs die niet begrijpen hoe declaratielijsten werken is die regel uiteraard van toepassing. Voor programmeurs die deze feature echter wèl begrijpen niet. Als je namelijk begrijpt hoe ze werken, leidt het gebruik ervan niet tot bugs.

[Olaf van der Spek]

Ook dan heb je meer kans op bugs hoor. Of in ieder geval moet je meer editen als je van een var het type wilt veranderen.