uto read(S)(ref S s, string message)
if (isSomeString!S) {
import std.string : strip;
writef("%s: ", message);
s = readln().strip();
return s;
}
class person
{
private:
string name, address;
int age;
float height;
public:
static person fromConsole()
{
e could have benefited from as well.
import std.stdio;
import std.traits;
auto read(T)(ref T t, string message)
if (!isSomeString!T) {
writef("%s: ", message);
readf(" %s", );
return t;
}
auto read(S)(ref S s, string message)
if (isSomeString!S) {
import std.stri
On Thursday, 16 February 2017 at 02:17:49 UTC, Ali Çehreli wrote:
On 02/15/2017 05:49 PM, Jean Cesar wrote:
> So I'm a beginner in this language and have very little time
I started
> I'm interested in apprehending concepts of object orientation
> polymorphism inheritance, multiple inheritance
On 02/15/2017 05:49 PM, Jean Cesar wrote:
> So I'm a beginner in this language and have very little time I started
> I'm interested in apprehending concepts of object orientation
> polymorphism inheritance, multiple inheritance as in c ++
D is similar to C++ but also very different.
> but I
n s;
}
class person
{
private:
string name, address;
int age;
float height;
public:
void setNome()
{
read(name, "Enter Your Name");
}
void setIty()
{
read(age, "Enter Your Age");
}
void setHeight()
{
read(height
;, message);
readf(" %s", );
return t;
}
auto read(S)(ref S s, string message)
if (isSomeString!S) {
import std.string : strip;
writef("%s: ", message);
s = readln().strip();
return s;
}
class person
{
private:
string name, address;
int age;
f
How do I make a class person where I use set and get methods to
imput the user type:
Import std.stdio;
class person
{
private:
string name, address;
int age;
float height;
public:
void setNome()
{
write("Enter Your Name:");
// the problem is here how am I goi
Ola Fosheim Grøstad:
D claims to follow C, so using unions for type punning is
ultimately implementation defined.
I am not sure if D is the same as C regarding this.
Bye,
bearophile
-portable, since some hardware architectures may use
different representations (e.g. different byte order on int and
float).
Then maybe use std.bitmanip?
import std.bitmanip;
int i = 5;
float f = bigEndianToNative!float(nativeToBigEndian(i));
// or float f =
littleEndianToNative!float
On Thursday, 5 March 2015 at 20:32:20 UTC, anonymous wrote:
That's not really simpler, though.
Maybe, but I think the union is a bit nicer because then the
compiler is responsible for more of the details. For example, it
should work with class objects without the complication of
dealing
On Thursday, 5 March 2015 at 20:03:09 UTC, Benjamin Thaut wrote:
int someValue = 5;
float sameBinary = *(cast(float*)cast(void*)someValue);
The cast(void*) isn't necessary.
On Thursday, 5 March 2015 at 20:03:09 UTC, Benjamin Thaut wrote:
Am 05.03.2015 um 21:00 schrieb Taylor Hillegeist:
How to I cast a Int to float without changing its binary
representation?
int someValue = 5;
float sameBinary = *(cast(float*)cast(void*)someValue);
ahh of course! lol :)
On Thursday, 5 March 2015 at 20:16:55 UTC, anonymous wrote:
On Thursday, 5 March 2015 at 20:03:09 UTC, Benjamin Thaut wrote:
int someValue = 5;
float sameBinary = *(cast(float*)cast(void*)someValue);
The cast(void*) isn't necessary.
Actually even the cast is unecessary, just use a uniform
How to I cast a Int to float without changing its binary
representation?
Am 05.03.2015 um 21:00 schrieb Taylor Hillegeist:
How to I cast a Int to float without changing its binary representation?
int someValue = 5;
float sameBinary = *(cast(float*)cast(void*)someValue);
On Thursday, 5 March 2015 at 20:21:18 UTC, badlink wrote:
On Thursday, 5 March 2015 at 20:16:55 UTC, anonymous wrote:
On Thursday, 5 March 2015 at 20:03:09 UTC, Benjamin Thaut
wrote:
int someValue = 5;
float sameBinary = *(cast(float*)cast(void*)someValue);
The cast(void*) isn't necessary
On Thursday, 5 March 2015 at 20:06:55 UTC, Taylor Hillegeist
wrote:
On Thursday, 5 March 2015 at 20:03:09 UTC, Benjamin Thaut wrote:
Am 05.03.2015 um 21:00 schrieb Taylor Hillegeist:
How to I cast a Int to float without changing its binary
representation?
int someValue = 5;
float sameBinary
representations (e.g. different byte order on int and
float).
D claims to follow C, so using unions for type punning is
ultimately implementation defined.
In C++ using unions for type punning is illegal/undefined
behaviour, so in C++ you should use memcpy. Memcpy also has the
advantage of explicitly
18 matches
Mail list logo
