CODEWITHSUNDEEP
c++c
vico
vico

Reputation: 18175

good manier to get char[] from another function. Starting thinking in c/c++

As I understood the correct programming style tells that if you want to get string (char []) from another function is best to create char * by caller and pass it to string formating function together with created string length. In my case string formating function is "getss".

void getss(char *ss, int& l)
{

    sprintf (ss,"aaaaaaaaaa%d",1);
    l=11;
}


int _tmain(int argc, _TCHAR* argv[])
{

    char *f = new char [1];
    int l =0;
    getss(f,l);

    cout<<f;
    char d[50] ;
    cin>> d;
    return 0;
}

"getss" formats string and returns it to ss*. I thought that getss is not allowed to got outside string length that was created by caller. By my understanding callers tells length by variable "l" and "getcc" returns back length in case buffer is not filled comleatly but it is not allowed go outside array range defined by caller.

But reality told me that really it is not so important what size of buffer was created by caller. It is ok, if you create size of 1, and getss fills with 11 characters long. In output I will get all characters that "getss" has filled.

So what is reason to pass length variable - you will always get string that is zero terminated and you will find the end according that.

What is the reason to create buffer with specified length if getss can expand it?

How it is done in real world - to get string from another function?

Upvotes: 4

Views: 247

Answers (7)

Fr&#233;d&#233;ric Hamidi
Fr&#233;d&#233;ric Hamidi

Reputation: 262919

Actually, the caller is the one that has allocated the buffer and knows the maximum size of the string that can fit inside. It passes that size to the function, and the function has to use it to avoid overflowing the passed buffer.

In your example, it means calling snprintf() rather than sprintf():

void getss(char *ss, int& l)
{
    l = snprintf(ss, l, "aaaaaaaaaa%d", 1);
}

In C++, of course, you only have to return an instance of std::string, so that's mostly a C paradigm. Since C does not support references, the function usually returns the length of the string:

int getss(char *buffer, size_t bufsize)
{
    return snprintf(buffer, bufsize, "aaaaaaaaaa%d", 1);
}

Upvotes: 2

Bo Persson
Bo Persson

Reputation: 92211

In C++ you don't have to build a string. Just output the parts separately

std::cout << "aaaaaaaaaa" << 1;

Or, if you want to save it as a string

std::string f = "aaaaaaaaaa" + std::to_string(1);

(Event though calling to_string is a bit silly for a constant value).

Upvotes: 1

ted
ted

Reputation: 4975

For cpp consider smart pointers in your case propably a shared_ptr, this will take care of freeing the memory, currently your program is leaking memory since, you never free the memory you allocate with new. Space allocate by new must be dealocated with delete or it will be allocated till your programm exits, this is bad, imagine your browser not freeing the memory it uses for tabs when you close them.

In the special case of strings I would recommend what OP's said, go with a String. With Cpp11 this will be moved (not copied) and you don't need to use new and have no worries with delete.

std::string myFunc() {
    std::string str
    //work with str
    return str
}

Upvotes: 1

Sergey Kalinichenko
Sergey Kalinichenko

Reputation: 726479

By my understanding callers tells length by variable "l" and "getcc" returns back length in case buffer is not filled comleatly but it is not allowed go outside array range defined by caller.

This is spot on!

But reality told me that really it is not so important what size of buffer was created by caller. It is ok, if you create size of 1, and getss fills with 11 characters long. In output I will get all characters that "getss" has filled.

This is absolutely wrong: you invoked undefined behavior, and did not get a crash. A memory checker such as valgrind would report this behavior as an error.

So what is reason to pass length variable.

The length is there to avoid this kind of undefined behavior. I understand that this is rather frustrating when you do not know the length of the string being returned, but this is the only safe way of doing it that does not create questions of string ownership.

One alternative is to allocate the return value dynamically. This lets you return strings of arbitrary length, but the caller is now responsible for freeing the returned value. This is not very intuitive to the reader, because malloc and free happen in different places.

The answer in C++ is quite different, and it is a lot better: you use std::string, a class from the standard library that represents strings of arbitrary length. Objects of this class manage the memory allocated for the string, eliminating the need of calling free manually.

Upvotes: 1

ForEveR
ForEveR

Reputation: 55887

In real world in C++ is better to use std::string objects and std::stringstream

char *f = new char [1];

sprintf (ss,"aaaaaaaaaa%d",1);

Hello, buffer overflow! Use snprintf instead of sprintf in C and use C++ features in C++.

Upvotes: 1

Wolfgang Ziegler
Wolfgang Ziegler

Reputation: 1685

In this case you are simply lucky that there is no "important" other data after the "char*" in memory. The C runtime does not always detect these kinds of violations reliably. Nonetheless, your are messing up the memory here and your program is prone to crash any time.

Apart from that, using raw "char*" pointers is really a thing you should not do any more in "modern" C++ code.

Use STL classes (std::string, std::wstring) instead. That way you do not have to bother about memory issues like this.

Upvotes: 1

user529758
user529758

Reputation:

You were only lucky. Sprintf() can't expand the (statically allocated) storage, and unless you pass in a char array of at least length + 1 elements, expect your program to crash.

Upvotes: 1

Related Questions