By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
445,918 Members | 2,294 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 445,918 IT Pros & Developers. It's quick & easy.

help passing pointer to char array as argument

P: n/a
Hello

I need to populate an array of char arrays at run-time. A very
simplifed version of the code is below.

char ** list should contain cnt char arrays. The values of char ** list
are set by the function foo(). A pointer to char ** list is passed to
foo() as an argument.

The problem is that when foo() returns, char ** list contains rubbish
and does not always contain cnt char arrays. Can anyone tell me what
I'm doing wrong? Note that I don't want to use the vector or string for
efficiency. Note that the code that get the time has nothing to do with
the real programme. It's just a simplification for the purpose of this
posting.
(I have noticed that if the values are constant char arrays there is no
problem)

//************************************************** *******************************
#include <iostream.h>
#include <time.h>
#include <string.h>
#include <stdlib.h>

void foo(char *** array, int cnt){

char buf[256];

for(int i=0; i<cnt; i++){
long t = time(NULL); // just for demonstration
itoa(t, buf, 10);
(*array)[i] = buf;
cout << i << " " << (*array)[i] << '\n';
}
}

int main(int argc, char ** argv){

int cnt = 10;
char ** list = new char*[10];

foo(&list, cnt);

for(int i=0; i<cnt; i++){
cout << i << " " << list[i] << "\n";
}

delete [] list;

return 0;
}
//************************************************** *******************************

Thanks!!!!!

Jul 5 '06 #1
Share this Question
Share on Google+
9 Replies


P: n/a
ro*************@telefonica.net writes:
>void foo(char *** array, int cnt){
> char buf[256];
This fixes the value of buf for the duration of the function, so
> (*array)[i] = buf;
will set all the elements to the same value - the value of buf.

Also, buf is a local variable, so when foo ends, the space used by buf can be recycled.

The short answer to your question is to reconsider using containers.

Jul 5 '06 #2

P: n/a

ro*************@telefonica.net wrote:
Hello
void foo(char *** array, int cnt){

char buf[256];

for(int i=0; i<cnt; i++){
long t = time(NULL); // just for demonstration
itoa(t, buf, 10);
(*array)[i] = buf;
cout << i << " " << (*array)[i] << '\n';
}
}
For starters, you're assigning the same local buffer 'buf' multiple
times, then that's going out of scope at the end of the function.
No offence mate, but you're clearly struggling juggling three levels of
indirection; you're going to be a lot better off using std::vector and
std::string. They are designed precisely to allow programmers to avoid
these sorts of gymnastics and pitfalls. Your concerns about
"performance" are misplaced, get the thing working in a clear and
understandable way and then worry about tweaking it for performance
*if* you need to. Which you won't.

Jul 5 '06 #3

P: n/a
ro*************@telefonica.net wrote:
Hello

I need to populate an array of char arrays at run-time. A very
simplifed version of the code is below.

char ** list should contain cnt char arrays. The values of char ** list
are set by the function foo(). A pointer to char ** list is passed to
foo() as an argument.

The problem is that when foo() returns, char ** list contains rubbish
and does not always contain cnt char arrays. Can anyone tell me what
I'm doing wrong? Note that I don't want to use the vector or string for
efficiency. Note that the code that get the time has nothing to do with
the real programme. It's just a simplification for the purpose of this
posting.
Why not just use std::vector<std::stringand save yourself a lot of
trouble?

--
Ian Collins.
Jul 5 '06 #4

P: n/a

Tim Love wrote:
ro*************@telefonica.net writes:
void foo(char *** array, int cnt){
char buf[256];
This fixes the value of buf for the duration of the function, so
(*array)[i] = buf;
will set all the elements to the same value - the value of buf.

Also, buf is a local variable, so when foo ends, the space used by buf can be recycled.

The short answer to your question is to reconsider using containers.
Thanks, Tim.
I might be wrong but I'm using a pointer to char ** list and assigning
the value of buf. char ** list's values should persist after foo()
returns. Isn't that right? Thanks!!!

Rob

Jul 5 '06 #5

P: n/a
ro*************@telefonica.net writes:
>Thanks, Tim.
I might be wrong but I'm using a pointer to char ** list and assigning
the value of buf. char ** list's values should persist after foo()
returns. Isn't that right?
But what persists is just a pointer. It's pointing to memory that's being
rewritten then freed, so it's not a useful pointer.

http://burks.bton.ac.uk/burks/langua...t/pointers.htm may help,
but vectors+strings are a safer bet.
Jul 5 '06 #6

P: n/a
TB
ro*************@telefonica.net skrev:
Tim Love wrote:
>ro*************@telefonica.net writes:
>>void foo(char *** array, int cnt){
char buf[256];
This fixes the value of buf for the duration of the function, so
>> (*array)[i] = buf;
will set all the elements to the same value - the value of buf.

Also, buf is a local variable, so when foo ends, the space used by buf can be recycled.

The short answer to your question is to reconsider using containers.

Thanks, Tim.
I might be wrong but I'm using a pointer to char ** list and assigning
the value of buf. char ** list's values should persist after foo()
returns. Isn't that right? Thanks!!!
You're assigning the address of 'buf' to each pointer, and 'buf' only
exists within the scope of 'foo()', not outside in 'main()'. The address
points to some location on the stack, which is recycled and overwritten
by subsequent stack operations, like the following call to
std::basic_ostream::operator<<(...).

You need to allocate the buffer with 'new' if you want it to persist,
or dismiss any thoughts of efficiency and do as others have replied,
skip deep indirection and use the provided framework of containers.

For example:

#include <sstream>
#include <vector>
#include <string>
#include <ctime>
#include <ostream>
#include <algorithms>

void foo(std::vector<std::string&v, unsigned cnt) {
std::ostringstream strm;
for(unsigned i = 0; i < cnt; ++i) {
strm << std::time(0);
v.push_back(strm.str());
strm.str("");
}
}

int main(int argc, char* argv[])
{
std::vector<std::stringv;
foo(v,10);
std::copy(v.begin(),
v.end(),
std::ostream_iterator<std::string>(std::cout,"\n") );
return 0;
}

--
TB @ SWEDEN
Jul 5 '06 #7

P: n/a

TB wrote:
>
You're assigning the address of 'buf' to each pointer, and 'buf' only
exists within the scope of 'foo()', not outside in 'main()'. The address
points to some location on the stack, which is recycled and overwritten
by subsequent stack operations, like the following call to
std::basic_ostream::operator<<(...).

You need to allocate the buffer with 'new' if you want it to persist,
or dismiss any thoughts of efficiency and do as others have replied,
skip deep indirection and use the provided framework of containers.

TB @ SWEDEN
Thanks to you and others who have got back to me. I'll take this
advice; but I'm still curious as to the following:

Essentially: is it possible to manipulate the values an array of chars
from within the scope of a function so that they persist?

foo(char *** list){
// manipulate list elements
}

I assume if I allocate memory with "new", for example...

(*array)[i] = new char[256];

....how can I then free the memory? I assume "delete [] list" won't do
it.

Thanks!!!
Rob

Jul 5 '06 #8

P: n/a
TB
ro*************@telefonica.net skrev:
TB wrote:
>You're assigning the address of 'buf' to each pointer, and 'buf' only
exists within the scope of 'foo()', not outside in 'main()'. The address
points to some location on the stack, which is recycled and overwritten
by subsequent stack operations, like the following call to
std::basic_ostream::operator<<(...).

You need to allocate the buffer with 'new' if you want it to persist,
or dismiss any thoughts of efficiency and do as others have replied,
skip deep indirection and use the provided framework of containers.

TB @ SWEDEN

Thanks to you and others who have got back to me. I'll take this
advice; but I'm still curious as to the following:

Essentially: is it possible to manipulate the values an array of chars
from within the scope of a function so that they persist?

foo(char *** list){
// manipulate list elements
}

I assume if I allocate memory with "new", for example...

(*array)[i] = new char[256];

...how can I then free the memory? I assume "delete [] list" won't do
it.
#include <iostream>
#include <ctime>
#include <cstdlib>

void foo(char **& array, unsigned cnt){
for(unsigned i = 0; i < cnt; ++i){
char * buf = new char[256];
long t = std::time(0);
std::itoa(t, buf, 10);
array[i] = buf;
std::cout << i << " " << array[i] << std::endl;
}
}

int main(int argc, char ** argv){
unsigned cnt = 10;
char ** list = new char*[10];

foo(list, cnt);

for(unsigned i = 0; i < cnt; ++i) {
std::cout << i << " " << list[i] << std::endl;
}

for(unsigned i = 0; i < cnt; ++i) {
delete[] list[i];
}
delete[] list;

return 0;
}

--
TB @ SWEDEN
Jul 5 '06 #9

P: n/a
#include <iostream>
#include <ctime>
#include <cstdlib>

void foo(char **& array, unsigned cnt){
for(unsigned i = 0; i < cnt; ++i){
char * buf = new char[256];
long t = std::time(0);
std::itoa(t, buf, 10);
array[i] = buf;
std::cout << i << " " << array[i] << std::endl;
}
}

int main(int argc, char ** argv){
unsigned cnt = 10;
char ** list = new char*[10];

foo(list, cnt);

for(unsigned i = 0; i < cnt; ++i) {
std::cout << i << " " << list[i] << std::endl;
}

for(unsigned i = 0; i < cnt; ++i) {
delete[] list[i];
}
delete[] list;

return 0;
}

--
TB @ SWEDEN
Thanks very much TB!!!

Rob

Jul 5 '06 #10

This discussion thread is closed

Replies have been disabled for this discussion.