---

Hejsa,

Jeg har lavet en klasse i hvilken jeg har defineret et array på følgende
vis:

int vector[15];

Når jeg så prøver at initialisere denne vektor i en "memberfunction" med:

vector = {0,0,0,0,0,0,0,0,0,0,0,0,0,0};

eller

vector[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

Brokker kompileren sig over '{'

Jeg bruger Visual Studio 7!

Nogen foreslag?

\Thomas

---

Heureka wrote:

> vector[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

Man kan ikke initialisere et array på den måde i en member funktion.
Du bliver nødt til at loop gennem arrayet:

for(size_t i = 0; i < sizeof(vector)/sizeof(vector[0]); i++)
vector[i] = 0;

Eller bruge memset (bør virke med 0, men ikke nødvendigvis med andre
værdier):

memset(vector, 0, sizeof(vector));

--
"We learned more from a three minute record, baby
than we ever learned in school"
- Bruce Springsteen

---

"Heureka" <stoltzo@hotmail.com> wrote in message
news:41f00749$1@news.wineasy.se...
> Hejsa,
>
> Jeg har lavet en klasse i hvilken jeg har defineret et array på følgende
> vis:
>
> int vector[15];

Brug C++ Standard Library funktionen "std::fill":
fill(&vector[0], &vector[15], 0);

Det er ikke nogen god ide at kalde arrayet vector - der er en klasse i C++
Standard Library som hedder det.
Giv den hellere et navn, der siger noget om hvad den bliver brugt til:
int person_height[15];

Overvej iøvrigt at benytte klassen "std::vector<int>" i stedet - det er ofte
et bedre valg, hvis der ikke _altid_ er brug for _netop_ 15 elementer.
Hvis du har brug for _netop_ 15 elementer med værdien 0 som medlem i en
klasse skriver du:

class foo
{
public:
foo();

private:
vector<int> bar;
};

foo::foo() :
bar(15, 0)
{
}

Hvis værdien 0 i virkeligheden indikerer at elementet ikke er brugt skal du
slet ikke skrive noget, men indsætte værdier efterhånden som du får brug for
dem med
bar.push_back(new_bar_element);

Hvis index i arrayet har en særlig betydning, men ikke alle pladser er fyldt
med noget meningsfyldt (sparse array), kan man bruge klassen "std::map":

class foo
{
public:
// ...
private:
map<int, int> bar;
};

bar[3] = 7;

Kort sagt: kig på C++ Standard Library klasserne "std::vector" og
"std::map" - de er ofte nyttige.

Venlig hilsen

Mogens Hansen

---

"Mogens Hansen" <mogens_h@dk-online.dk> wrote in message
news:csp6p3$14pm$1@news.cybercity.dk...
|
| "Heureka" <stoltzo@hotmail.com> wrote in message
| news:41f00749$1@news.wineasy.se...
| > Hejsa,
| >
| > Jeg har lavet en klasse i hvilken jeg har defineret et array på følgende
| > vis:
| >
| > int vector[15];

| Kort sagt: kig på C++ Standard Library klasserne "std::vector" og
| "std::map" - de er ofte nyttige.

Jeg kan kun sige at Mogens har fuldstøndig ret. Man bør *aldrig*
bruge indbyggede arrays in C++. Det lyder mærkeligt, men
de er så nemme at lave fejl med at de ikke er værd at bruge og
alternativerne er lige så effective.

Brug først std::vector<T>.

Du kan måske overveje boost::array<T,int>. Se

http://www.boost.org/doc/html/array.html

Hvis du skal initialise disse på en smart måde, så kan du overveje at
bruge Boost.assign:

std::vector<int> v ( boost::assign::list_of(1)(2)(3)(5)(7) );

virker på samme måde for array<int, 10>. Du kan også
sige

boost::array<int,10> a( boost::assign::list_of(0) );

for at sætte alle til 0.

Se http://www.boost.org/libs/assign/doc/index.html

mvh

Thorsten

---

Thorsten Ottosen wrote:

> Jeg kan kun sige at Mogens har fuldstøndig ret. Man bør *aldrig*
> bruge indbyggede arrays in C++.

Hvis man er ny inden for C++ og måske programmering, har arrays den
store fordel at de er nemme at bruge. Derfor (og af en mængde andre
grunde) er din påstand en fejltagelse.

> Du kan måske overveje boost::array<T,int>. Se

Man kunne også vælge at gøre det simpelt -> ingen boost.

--
"We learned more from a three minute record, baby
than we ever learned in school"
- Bruce Springsteen

---

"Bertel Brander" <bertel@post4.tele.dk> wrote in message
news:41f0395f$0$51616$edfadb0f@dread14.news.tele.dk...
| Thorsten Ottosen wrote:
|
| > Jeg kan kun sige at Mogens har fuldstøndig ret. Man bør *aldrig*
| > bruge indbyggede arrays in C++.
|
| Hvis man er ny inden for C++ og måske programmering, har arrays den
| store fordel at de er nemme at bruge.

what? der er minimal forskel på et array af T og boost::array<T,int>.
Hvad er det for en stor forskel?

Arrays er specielt unødvendige for nybegyndere;
50 af deres fejl går med at debugge array kode; de burde bruge tiden
på at lære at programmere.

| Derfor (og af en mængde andre
| grunde) er din påstand en fejltagelse.

hvilke andre grunde?

| > Du kan måske overveje boost::array<T,int>. Se
|
| Man kunne også vælge at gøre det simpelt -> ingen boost.

ja, og man kunne også vælge at bruge copy-paste i stedet
for at lave en ny function---det er trods alt simplere.

-Thorsten

---

> | Thorsten Ottosen wrote:
> |
> | > Jeg kan kun sige at Mogens har fuldstøndig ret. Man bør *aldrig*
> | > bruge indbyggede arrays in C++.
> |
> | Hvis man er ny inden for C++ og måske programmering, har arrays den
> | store fordel at de er nemme at bruge.
>
> what? der er minimal forskel på et array af T og boost::array<T,int>.
> Hvad er det for en stor forskel?

Hvad er den store fordel ved std::vector? For mig at ser er der
meget små fordele i starten, en af de store ulemper er at der
er en del ekstra man skal sætte sig ind i.

> Arrays er specielt unødvendige for nybegyndere;

Arrays er aldrig unødvendige.

> 50 af deres fejl går med at debugge array kode; de burde bruge tiden
> på at lære at programmere.

Jeg vil så påstå at nybegynderen (og de lidt øvede) laver mindst lige
så mange fejl ved at bruge std::vector.

>
> | Derfor (og af en mængde andre
> | grunde) er din påstand en fejltagelse.
>
> hvilke andre grunde?

F.ex. at der er et vist overhead i at bruge en vector, det er ikke
alle der kan ignorere dette overhead.

--
"We learned more from a three minute record, baby
than we ever learned in school"
- Bruce Springsteen

---

"Bertel Brander" <bertel@post4.tele.dk> wrote in message
news:41f04ff3$0$164$edfadb0f@dread11.news.tele.dk...
|> | Thorsten Ottosen wrote:
| > |
| > | > Jeg kan kun sige at Mogens har fuldstøndig ret. Man bør *aldrig*
| > | > bruge indbyggede arrays in C++.
| > |
| > | Hvis man er ny inden for C++ og måske programmering, har arrays den
| > | store fordel at de er nemme at bruge.
| >
| > what? der er minimal forskel på et array af T og boost::array<T,int>.
| > Hvad er det for en stor forskel?
|
| Hvad er den store fordel ved std::vector?

- der er ingen initiliserings problemer.
- der er som regelt bounds-checking i debug
- der er size(), begin(), end()
- den gror automatisk
.....

|For mig at ser er der
| meget små fordele i starten, en af de store ulemper er at der
| er en del ekstra man skal sætte sig ind i.

det er noget vrøvl.

| > Arrays er specielt unødvendige for nybegyndere;
|
| Arrays er aldrig unødvendige.

jo.

| > 50 af deres fejl går med at debugge array kode; de burde bruge tiden
| > på at lære at programmere.
|
| Jeg vil så påstå at nybegynderen (og de lidt øvede) laver mindst lige
| så mange fejl ved at bruge std::vector.

hvilke fejl?

| >
| > | Derfor (og af en mængde andre
| > | grunde) er din påstand en fejltagelse.
| >
| > hvilke andre grunde?
|
| F.ex. at der er et vist overhead i at bruge en vector, det er ikke
| alle der kan ignorere dette overhead.

nybegyndere kan i hvert fald.

og ellers så brug boost::array<T,int>.

-Thorsten

---

Thorsten Ottosen wrote:
> |
> | Hvad er den store fordel ved std::vector?
>
> - der er ingen initiliserings problemer.
> - der er som regelt bounds-checking i debug
> - der er size(), begin(), end()
> - den gror automatisk

Hvilket følgende lille begynder program på glimrende vis beviser:

#include <vector>
#include <iostream>

int main()
{
std::vector<int >MyVector;
MyVector[12] = 13;
std::cout << MyVector[12] << std::endl;
}


--
"We learned more from a three minute record, baby
than we ever learned in school"
- Bruce Springsteen

---

"Bertel Brander" <bertel@post4.tele.dk> wrote in message
news:41f05841$0$178$edfadb0f@dread11.news.tele.dk...

[8<8<8<]
> std::vector<int >MyVector;
> MyVector[12] = 13;
> std::cout << MyVector[12] << std::endl;

Det er ikke væsentligt forskelligt fra

int my_array[10];
my_array[12] = 13;
cout << my_array[12] << endl;

Med (altid anbefalelsesvædige) debug værktøjer som f.eks. Borland CodeGuard,
Compuware BoundsChecker (tidligere NuMega) eller Rational Purify vil sådanne
fejl blive afsløret.
Desuden kan Standard Library implementeringen have indbygget debug-kode der
vil afsløre fejl i forbindelse med anvendelsen af f.eks. "std::vector".
Det er gammel kendt teknologi, se f.eks.SafeSTL af Cay Horstmann
(http://www.horstmann.com/safestl.html) fra 1995.

Generelt gælder det at C++ ikke er et programmeringssprog med indbygget
barnepige.
Der er dog god grund til at anvende en klar programmeringsstil, så
programmet er nemmere at skrive og vedligeholde korrekt.

Her har std::vector de klare fordele frem for simple arrays at:
* elementerne er altid initialiseret
* den indeholder direkte information om hvormange elementer der er
* intet behov for "magiske" værdier som indikerer elementet ikke er
brugbart
* intet behov for et lille bogholderi ved siden af
* størrelsen vokser dynamisk med behovet

Jeg anerkender ikke at array er simplere i brug en std::vector.
Der er mindre syntaks knyttet til indbyggede array - tilgengæld er der mere
konvention der skal huskes og overholdes.
F.eks. går information om arrayets kapacitet nemt tabt ved funktionskald
(f.eks. strcpy) - hvilket er en væsentlig grund til mange, alvorlige
programfejl.


Venlig hilsen

Mogens Hansen

---

"Bertel Brander" <bertel@post4.tele.dk> wrote in message
news:41f05841$0$178$edfadb0f@dread11.news.tele.dk...
| Thorsten Ottosen wrote:
| > |
| > | Hvad er den store fordel ved std::vector?
| >
| > - der er ingen initiliserings problemer.
| > - der er som regelt bounds-checking i debug
| > - der er size(), begin(), end()
| > - den gror automatisk
|
| Hvilket følgende lille begynder program på glimrende vis beviser:
|
| #include <vector>
| #include <iostream>
|
| int main()
| {
| std::vector<int >MyVector;
| MyVector[12] = 13;
| std::cout << MyVector[12] << std::endl;
| }

Du for jo samme fejl med arrays.

Og hvis du bruger et pasende standard bibliotek, så får du jo at vide hvad
fejlen er.

Så prøv igen.

-Thorsten

---

Thorsten Ottosen wrote:
> "Bertel Brander" <bertel@post4.tele.dk> wrote in message
> news:41f05841$0$178$edfadb0f@dread11.news.tele.dk...
> | Thorsten Ottosen wrote:
> | > |
> | > | Hvad er den store fordel ved std::vector?
> | >
> | > - der er ingen initiliserings problemer.
> | > - der er som regelt bounds-checking i debug
> | > - der er size(), begin(), end()
> | > - den gror automatisk
> |
> | Hvilket følgende lille begynder program på glimrende vis beviser:
> |
> | #include <vector>
> | #include <iostream>
> |
> | int main()
> | {
> | std::vector<int >MyVector;
> | MyVector[12] = 13;
> | std::cout << MyVector[12] << std::endl;
> | }
>
> Du for jo samme fejl med arrays.
>
> Og hvis du bruger et pasende standard bibliotek, så får du jo at vide hvad
> fejlen er.

Mit lille eksempel var et forsøg på at demonstrere at:
1: En vector IKKE gror automatisk.
2: At der er de samme initialiserings problemer med vector
som med array.
3: Der er ingen af mine kompilere der giver mig nogen besked,
jeg får en box hvor der står om jeg vil sende en besked til
Microsoft om at programmet har udført en ulovlig handling.

Et andet lille eksempel, der kunne demonstrere hvorfor nogen kunne
synes at det er lettere at bruge arrays:

#include <vector>
#include <iostream>

int main()
{
std::vector<std::vector<std::vector<int> > >MyVector(10,
std::vector<std::vector<int> >(20, std::vector<int>(30)));
MyVector[9][19][29] = 123;
std::cout << MyVector[9][19][29] << std::endl;
}

Det er efter min mening lettere at skrive:
int Array[10][20][30];

--
"We learned more from a three minute record, baby
than we ever learned in school"
- Bruce Springsteen

---

"Bertel Brander" <bertel@post4.tele.dk> wrote in message
news:41f15067$0$33621$edfadb0f@dread16.news.tele.dk...

[8<8<8<]
> Mit lille eksempel var et forsøg på at demonstrere at:
> 1: En vector IKKE gror automatisk.

vector gror automatisk når man kalder push_back.
Men der er oplagt mulighed for at bruge den forkert.
Hvis man vil have sikkerhed for ikke at adressere ud over vector, så brug
"at" i stedet for "operator[]".

Generelt bryder jeg med dog ikke om at bruge "vector::at" bare for en
sikkerheds skyld.
Hvis det er en del af den almindelig program eksekvering, er det ikke en
undtagelse der retfærdiggør brugen af exception.
Hvis det er for en "sikkerheds skyld", uden

> 2: At der er de samme initialiserings problemer med vector
> som med array.

Ikke helt.

int a[10];
efterlader en med 10 integerer med udefineret værdi.

vector<int> a(10)
efterlader en med 10 integerer, der hver har værdien 0.

Det er simpelt at sikre at vector kun indeholder faktis anvendte værdier,
hvorimod størrelsen på arrayet angivet dets kapacitet.
char name[1024];
strcpy(name, "Hello World");

> 3: Der er ingen af mine kompilere der giver mig nogen besked,

Hvis du bruger Microsoft Visual C++ er det måske værd at supplere den med
Compuware BoundsChecker eller Rational Purify.
Hvis du bruger Borland C++Builder kan du aktivere CodeGuard.
Hvis du bruger Linux er Valgrind måske værd at kigge på.

De råd gælder uanset om man bruger vector eller build-in array.

Venlig hilsen

Mogens Hansen

---

Mange tak for jeres gode forslag!

Jeg vil tage et kig på std::vector klassen

Igen Tak
Thomas

"Mogens Hansen" <mogens_h@dk-online.dk> wrote in message
news:csp6p3$14pm$1@news.cybercity.dk...
>
> "Heureka" <stoltzo@hotmail.com> wrote in message
> news:41f00749$1@news.wineasy.se...
>> Hejsa,
>>
>> Jeg har lavet en klasse i hvilken jeg har defineret et array på følgende
>> vis:
>>
>> int vector[15];
>
> Brug C++ Standard Library funktionen "std::fill":
> fill(&vector[0], &vector[15], 0);
>
> Det er ikke nogen god ide at kalde arrayet vector - der er en klasse i C++
> Standard Library som hedder det.
> Giv den hellere et navn, der siger noget om hvad den bliver brugt til:
> int person_height[15];
>
> Overvej iøvrigt at benytte klassen "std::vector<int>" i stedet - det er
> ofte et bedre valg, hvis der ikke _altid_ er brug for _netop_ 15
> elementer.
> Hvis du har brug for _netop_ 15 elementer med værdien 0 som medlem i en
> klasse skriver du:
>
> class foo
> {
> public:
> foo();
>
> private:
> vector<int> bar;
> };
>
> foo::foo() :
> bar(15, 0)
> {
> }
>
> Hvis værdien 0 i virkeligheden indikerer at elementet ikke er brugt skal
> du slet ikke skrive noget, men indsætte værdier efterhånden som du får
> brug for dem med
> bar.push_back(new_bar_element);
>
> Hvis index i arrayet har en særlig betydning, men ikke alle pladser er
> fyldt med noget meningsfyldt (sparse array), kan man bruge klassen
> "std::map":
>
> class foo
> {
> public:
> // ...
> private:
> map<int, int> bar;
> };
>
> bar[3] = 7;
>
> Kort sagt: kig på C++ Standard Library klasserne "std::vector" og
> "std::map" - de er ofte nyttige.
>
> Venlig hilsen
>
> Mogens Hansen
>

---

Bertel Brander <bertel@post4.tele.dk> writes:

> Thorsten Ottosen wrote:
>
>> Jeg kan kun sige at Mogens har fuldstøndig ret. Man bør *aldrig*
>> bruge indbyggede arrays in C++.

Man skal aldrig sige aldrig.

C arrays kan blive tvunget til at bruge når man skal kommunikere med
gammel software. De kan måske også bruges med fordel for meget
avancerede brugere i helt specielle situationer, som når de skal
implementere nye container-klasser.

> Hvis man er ny inden for C++ og måske programmering, har arrays den
> store fordel at de er nemme at bruge.

Nej, arrays er meget vanskelige ar bruge og forstå. vector er meget
simplere, specielt for begyndere. For eksempel bliver en vector ikke
på mystisk vis forvandlet til en pointer når man kigger skævt på den.
Den har almindelig value semantik som alt andet i sproget (undtagen
altså C vektorer).

---

"Per Abrahamsen" <abraham@dina.kvl.dk> wrote in message
news:rjwtu75gxt.fsf@sheridan.dina.kvl.dk...
> Bertel Brander <bertel@post4.tele.dk> writes:

[8<8<8<]
> Man skal aldrig sige aldrig.

Enig.
Man skal blot have det simpleste og sikreste som default valg.

>
> C arrays kan blive tvunget til at bruge når man skal kommunikere med
> gammel software.

Nej - ikke tvunget.
"std::vector" er specificeret (i TC1 - alle kendte implementeringer inden
fungerede også som forventet) til at kunne bruges i den forbindelse med
ældre API'er.
F.eks.
vector<char> text(12);
strcpy(&text[0], "Hello World");

(ikke at jeg anbefaler vector<char> eller strcpy til tekst-håndtering - brug
std::string)

Det åbner for samme muligheder for buffer-overrun som man altid har haft.
Det er en egenskab til strcpy og ikke ved vector.

Venlig hilsen

Mogens Hansen

---

"Per Abrahamsen" <abraham@dina.kvl.dk> wrote in message
news:rjwtu75gxt.fsf@sheridan.dina.kvl.dk...
| Bertel Brander <bertel@post4.tele.dk> writes:
|
| > Thorsten Ottosen wrote:
| >
| >> Jeg kan kun sige at Mogens har fuldstøndig ret. Man bør *aldrig*
| >> bruge indbyggede arrays in C++.
|
| Man skal aldrig sige aldrig.

og alligevel skal man sige det to gange for at sige man ikke skal sige det.

anyway, boost::array har alle "fordele", som almindelige
arrays har, men færre ulemper.

-Thorsten

---

Per Abrahamsen <abraham@dina.kvl.dk> writes:

> C arrays kan blive tvunget til at bruge når man skal kommunikere med
> gammel software. De kan måske også bruges med fordel for meget
> avancerede brugere i helt specielle situationer, som når de skal
> implementere nye container-klasser.

Oh, jeg glemte lige den vigtigste fordel ved C arrays:

Man kan initialisere dem statisk. Hvis man har indlejrede data i
programmet, er det normalt både mere effektivt og bekvemt at placere
dem i statiske arrays, fremfor i en vector der må initialiseres
dynamisk.

---

"Per Abrahamsen" <abraham@dina.kvl.dk> wrote in message
news:rjmzv3425l.fsf@sheridan.dina.kvl.dk...
| Per Abrahamsen <abraham@dina.kvl.dk> writes:
|
| > C arrays kan blive tvunget til at bruge når man skal kommunikere med
| > gammel software. De kan måske også bruges med fordel for meget
| > avancerede brugere i helt specielle situationer, som når de skal
| > implementere nye container-klasser.
|
| Oh, jeg glemte lige den vigtigste fordel ved C arrays:
|
| Man kan initialisere dem statisk.

Det kan man også med boost::array<T,int>.

-Thorsten

---

"Mogens Hansen" <mogens_h@dk-online.dk> writes:

> "Per Abrahamsen" <abraham@dina.kvl.dk> wrote in message
> news:rjwtu75gxt.fsf@sheridan.dina.kvl.dk...
>
>> C arrays kan [man] blive tvunget til at bruge når man skal kommunikere med
>> gammel software.
>
> Nej - ikke tvunget.

Hvordan undgår man det hvis man vil snakke med det her interface:

extern "C"
{
typedef struct {
char name[12];
int age;
} foo_t;

void foo_init (foo_t* foo);
}

?

---

"Per Abrahamsen" <abraham@dina.kvl.dk> wrote in message
news:rjr7kfvwg6.fsf@sheridan.dina.kvl.dk...

[8<8<8<]
> Hvordan undgår man det hvis man vil snakke med det her interface:
>
> extern "C"
> {
> typedef struct {
> char name[12];
> int age;
> } foo_t;
>
> void foo_init (foo_t* foo);
> }

Lige ud af landevejen - char er ikke speciel:
vector<foo_t> foos(2);
foo_init(&foos[0]);

&foo[0] giver en foo_t*, og man kan ikke se hvor og hvordan den er
allokeret.

Naturligvis har vi samme spørgsmål som med strcpy: hvordan ved foo_init hvor
mange elementer der er i arrayet.

Venlig hilsen

Mogens Hansen

---

Mogens Hansen wrote:
> "Per Abrahamsen" <abraham@dina.kvl.dk> wrote in message
> news:rjr7kfvwg6.fsf@sheridan.dina.kvl.dk...
>
> [8<8<8<]
>
>>Hvordan undgår man det hvis man vil snakke med det her interface:
>>
>> extern "C"
>> {
>> typedef struct {
>> char name[12];
>> int age;
>> } foo_t;
>>
>> void foo_init (foo_t* foo);
>> }
>
>
> Lige ud af landevejen - char er ikke speciel:
> vector<foo_t> foos(2);
> foo_init(&foos[0]);
>

Jeg tror at det var arrayet i foo_t der er problemet, ikke foo_t
i sig selv.

--
"We learned more from a three minute record, baby
than we ever learned in school"
- Bruce Springsteen

---

"Bertel Brander" <bertel@post4.tele.dk> wrote in message
news:41f150d3$0$33621$edfadb0f@dread16.news.tele.dk...

[8<8<8<]
> Jeg tror at det var arrayet i foo_t der er problemet, ikke foo_t
> i sig selv.

Jeg forstår ikke helt.
Hvordan skulle indholdet af foo_t skulle spille nogen rolle for hvordan man
kan kalde foo_init ?

Min antagelse var at foo_t og foo_init var lavet for længe side og ikke
kunne ændres, og at foo_init forventede en pointer til første element i et
array - oprindeligt tænkt som et build-in array (ligesom f.eks. strlen).

Venlig hilsen

Mogens Hansen

---

Mogens Hansen wrote:
> "Bertel Brander" <bertel@post4.tele.dk> wrote in message
> news:41f150d3$0$33621$edfadb0f@dread16.news.tele.dk...
>
> [8<8<8<]
>
>>Jeg tror at det var arrayet i foo_t der er problemet, ikke foo_t
>>i sig selv.
>
>
> Jeg forstår ikke helt.
> Hvordan skulle indholdet af foo_t skulle spille nogen rolle for hvordan man
> kan kalde foo_init ?
>

Hvis name i foo_t var en std::vector og foo_init var implementeret i
C ville man have et problem.

--
"We learned more from a three minute record, baby
than we ever learned in school"
- Bruce Springsteen

---

"Bertel Brander" <bertel@post4.tele.dk> wrote in message
news:41f15742$0$33642$edfadb0f@dread16.news.tele.dk...

[8<8<8<]
> Hvis name i foo_t var en std::vector og foo_init var implementeret i
> C ville man have et problem.

Hvordan kunne den situation opstå ?

foo_init må være defineret samtidig eller senere end foo_t.
foo_init afhænger af foo_t, hvorimod foo_t ikke afhænger af foo_init.

Hvis foo_t indeholdt en std::vector ville det være en C++ struktur og
følgeligt kunne foo_init implementeres i C++ og der ville ikke være noget
problem.

Den situation jeg kunne forestille mig er at foo_init og foo_t er lavet i C,
og man ønsker at benytte det fra et C++ program.

Venlig hilsen

Mogens Hansen

---

"Mogens Hansen" <mogens_h@dk-online.dk> writes:

> "Bertel Brander" <bertel@post4.tele.dk> wrote in message
> news:41f150d3$0$33621$edfadb0f@dread16.news.tele.dk...
>
> [8<8<8<]
>> Jeg tror at det var arrayet i foo_t der er problemet, ikke foo_t
>> i sig selv.

Jeps.

> Jeg forstår ikke helt.
> Hvordan skulle indholdet af foo_t skulle spille nogen rolle for hvordan man
> kan kalde foo_init ?

Fordi foo_init forventer at indholdet af foo_t har et bestemt layout i
memory, og det layout kan du ikke med rimelighed duplikere fra C++
uden at bruge arrays. Præcis som vi gjorde i eksemplet.

---

"Mogens Hansen" <mogens_h@dk-online.dk> writes:

> Min antagelse var at foo_t og foo_init var lavet for længe side og ikke
> kunne ændres,

Jeps.

> og at foo_init forventede en pointer til første element i et
> array - oprindeligt tænkt som et build-in array (ligesom f.eks. strlen).

Forkert, foo_init forventer en pointer til et enkelt objekt der skal
initialiseres.

Pointen er at hvis en C rutine forventer en pointer til en array, kan
se simuleres fra C++ med v.begin (), fordi en C array konverteres til
en pointer til første element når man bruger den som argument til en
funktion.

Men hvis den array er pakket ind i en struct kan man ikke længere
bruge det trick, fordi en array er indlejret i en struct og ikke
længere en pointer som fra modtagerens side.

---

"Heureka" <stoltzo@hotmail.com> wrote in message
news:41f00749$1@news.wineasy.se...

[8<8<8<]
> Nogen foreslag?

Er du med på forskellen på initialisering og tildeling ?
I C++ er der en skarp skelnen.

Når man skriver:
int values[] = {0,0,0,0,0};
initialiserer man arrayet.

Når man skriver
int values[5];
er det initialiseret til udefinerede værdier.
Når man så senere forsøger at skrive
values = {0,0,0,0,0};
er det et forsøg til tildeling - hvilket ikke er tilladt på den måde.

Se f.eks.
The C++ Programming Language, Special Edition
Bjarne Stroustrup
ISBN 0-201-70073-5
side 283 for yderligere detaljer.

Venlig hilsen

Mogens Hansen