Thread: simple but not working

Just a wild guess....

Check the string operators:

http://www.cppreference.com/cppstrin...operators.html

See any that for operator+ that takes in two const char *'s?

On a related note:

I am converting a number to a string and would like to code...

Code:

std::string DecToBin(int num);
...
messageOut = "header 1:  " + DecToBin(num);

And for the last hour I've been discovering that whenever and however I invoke DecToBin(num)...
e.g.

Code:

test1 = DecToBin(num);
messageOut = "header1:  " + test1;

...that the executable returns "segmentation fault". I step through the code and find that a normally solid function (elsewhere and upstream in the method) returns negative.

What I'm wondering is that because I've defined DecToBin(int num) as an outside function to the class method that calls it, is it possible that some of its internal char* methods are conflicting with the class methods memory allocations?

Mystery...

Dave++:

If you're returning a local string object, that could be why you're seg faulting. I don't think you should return local objects. Someone correct me if I'm wrong....

Originally Posted by Daved

Why are you using char*'s at all?

...

Because string literals are char *'s when you get down to it. That's how you create string objects.

MacGyver,
Can you expand on your previous comment?

More testing...
In gdb I can comment out the call to the function, with a simple default value in its place, and then reset the DAQ hardware and everything works fine, but then as soon as I uncomment the line...everything fails. AND then when I comment the line out again errors persist until I reset the hardware.
Interestingly, the function itself works alright (set var=newval, and step though an if) but its inclusion alone seems to cause the code to fault ahead of itself and then behind as well.

So, if I get you right, I need to create a global pointer for the string?

Dave

It's the code from Mike

http://cboard.cprogramming.com/showthread.php?t=90911

I modified to return std::string

Code:

std::string strOut = std::string(str);    // using Daved approach as shown above
return(strOut);

fyi - clocking out for the day

The problem is likely that you didn't allocate space for the char* when you moved it inside the function. You could declare str as char str[100] if you are using mike_g's version, but I would use a bitset as I mentioned in that thread:

Code:

std::string getbinary(int num)
{
    return std::bitset<32>(num).to_string<char, std::char_traits<char>, std::allocator<char> >();
}

The ugliness of the to_string method will be fixed in later C++ standard.

For fun, I welcome people to comment on this "super" version, which is probably more than you need:

Code:

#include <iostream>
#include <bitset>
#include <string>
#include <climits>
#include <limits>

template<bool truncate_zeroes, size_t bits>
std::string get_binary_impl(unsigned long val)
{
    std::string s(std::bitset<bits>(val).to_string<char, std::char_traits<char>, std::allocator<char> >());
    return truncate_zeroes ? (val == 0 ? "0" : s.substr(s.find_first_not_of('0'))) : s;
}

template<size_t bits>
std::string get_binary(unsigned long val)
{
    return get_binary_impl<false, bits>(val);
}

std::string get_binary(unsigned long val)
{
    return get_binary_impl<true, sizeof(unsigned long)*CHAR_BIT>(val);
}

int main()
{
    std::cout << get_binary(0) << '\n';
    std::cout << get_binary(5) << '\n';
    std::cout << get_binary<8>(0) << '\n';
    std::cout << get_binary<8>(5) << '\n';
    std::cout << get_binary(1431655765) << '\n';
    std::cout << get_binary(std::numeric_limits<unsigned long>::max()) << '\n';
}

fun, but if you wanted to be super-anally-runtime efficient you could specialise get_binary_impl for true and false values of truncate_zeroes instead of a runtime ?:

but that would be ridiculous

Originally Posted by Daved

Of course, there's no reason to do that when you can just do:

Code:

std::string messageOut = "header 1: test";

In the rare case that you want to add two string literals, you can just create a temporary string out of one of them so that you are always adding to a string:

Code:

std::string messageOut = "header 1: " + std::string("test");

Also, the preprocessor automatically concatenates adjacent string literals, so this

Code:

"hello"
"world" "nice to"
    "meet you"

is the same as

Code:

"hello world nice to meet you"

It's useful for really long string constants. It lets you stick to an 80 character limit more easily.