I have small C program that uses a pointer to change the start address of a string, and when I tried to do the same code but with D, the D code printed the address of the string after I increased it one step instead of printing the string the pointer pointing to. Is there a difference between "char *" pointers between C and D.

#include <stdio.h>
#include <stdlib.h>

int main()
{

char ch[]="Hello World!";
char *p;

p=&ch;
p++;

printf("%s\n", p);

return 0;

}

module main;

import std.stdio;

int main(string[] args)
{

char[] ch="Hello World!".dup;
char *p;

p=&ch[0];
p++;

writefln("%s", p);

return 0;

}

I don't know what writefln is doing, but this following D code is the exact similar to your C code

import core.stdc.stdio;

void main()
{
    const(char)[] ch = "Hello World!";
    const(char)* p;

    p = &ch[0];
    p++;

    printf("%s", p);
}

ello World!

Here is the way to do it with writefln (i think)

import std;
import core.stdc.string;

void main()
{
    const(char)[] ch = "Hello World!";
    const(char)[] ch2 = "abc";
    const(char)* p;

    p = &ch[0];
    p++;
	
    auto str = p[0 .. strlen(p)];
    writefln("%s", str);
}

Note that i removed your .dup it is unecessary, string literals needs const(char)

After looking at the doc, writefln needs a slice, so we just do that and pass it

On Monday, 25 July 2022 at 09:04:29 UTC, pascal111 wrote:

No, no difference. Pointers are the same in both languages. What's different is the behavior of %s in writeln vs printf. See the documentation on format strings at:

https://dlang.org/phobos/std_format.html

Essentially, %s tells the formatter to output something appropriate for the given type. For an actual D string, you see the text. For an integral or floating point type, you see the number. For a pointer, you see the the address. And so on.

Do in your case, to get writefln to print the text instead of the pointer address, you could import std.string and use fromStringz:fromStringz(p).

This will give you a D string without allocating any memory. Basically an immutable slice of the memory pointed at by p. That's fine for this use case, but if you wanted to hang on to the string beyond the lifetime of the pointer, you'd have to use std.conv.to instead (e.g., to!string(p)).

On Monday, 25 July 2022 at 09:36:05 UTC, ryuukk_ wrote:

import std;
import core.stdc.string;

void main()
{
    const(char)[] ch = "Hello World!";
    const(char)[] ch2 = "abc";
    const(char)* p;

    p = &ch[0];
    p++;
	
    auto str = p[0 .. strlen(p)];
    writefln("%s", str);
}

I tried your advice with two ways; once with a constant and other with an array, but the result isn't the same. The array case has more letters in the output.

module main;

import std.stdio;
import core.stdc.stdio;
import core.stdc.string;

int main(string[] args)
{

    const(char)[] ch1 = "Hello World!";
    char[] ch2="Hello World!".dup;

    const(char) *p1;
    char *p2;

    p1=ch1.ptr;
    p2=ch2.ptr;

    writeln(p1[0..strlen(p1)]);
    writeln(p2[0..strlen(p2)]);

	return 0;
}

Runtime output:

https://i.postimg.cc/sfnkJ4GM/Screenshot-from-2022-07-25-13-12-03.png

On Monday, 25 July 2022 at 11:14:56 UTC, pascal111 wrote:

    const(char)[] ch1 = "Hello World!";
    char[] ch2="Hello World!".dup;

    const(char) *p1;
    char *p2;

    p1=ch1.ptr;
    p2=ch2.ptr;

    writeln(p1[0..strlen(p1)]);
    writeln(p2[0..strlen(p2)]);

	return 0;
}

Do not post screenshots of text.

strlen only works on null-terminated strings. The result of .dup is not null-terminated, so strlen doesn't work on it.

On Monday, 25 July 2022 at 11:14:56 UTC, pascal111 wrote:

import std;
import core.stdc.string;

void main()
{
    const(char)[] ch = "Hello World!";
    const(char)[] ch2 = "abc";
    const(char)* p;

    p = &ch[0];
    p++;
	
    auto str = p[0 .. strlen(p)];
    writefln("%s", str);
}

    const(char)[] ch1 = "Hello World!";
    char[] ch2="Hello World!".dup;

    const(char) *p1;
    char *p2;

    p1=ch1.ptr;
    p2=ch2.ptr;

    writeln(p1[0..strlen(p1)]);
    writeln(p2[0..strlen(p2)]);

	return 0;
}

ch1is a string literal, just like in C, it is null terminated

ch2 is a GC allocated char array, it is NOT null terminated

strlen is the lib C function, it counts strings up to \O

for p1 it'll print correctly, it is a pointer from the null terminated string

for p2 strlen doesn't make sense, since it is a pointer from a string that is NOT null terminated

On Monday, 25 July 2022 at 13:51:35 UTC, ryuukk_ wrote:

    const(char)[] ch1 = "Hello World!";
    char[] ch2="Hello World!".dup;

    const(char) *p1;
    char *p2;

    p1=ch1.ptr;
    p2=ch2.ptr;

    writeln(p1[0..strlen(p1)]);
    writeln(p2[0..strlen(p2)]);

	return 0;
}

Yes, I have to add "\0":

module main;

import std.stdio;
import core.stdc.stdio;
import core.stdc.string;

int main(string[] args)
{

    const(char)[] ch1 = "Hello World!";
    char[] ch2="Hello World!".dup;

    const(char) *p1;
    char *p2;

    ch2~="\0";

    p1=ch1.ptr;
    p2=ch2.ptr;

    writeln(p1[0..strlen(p1)]);
    writeln(p2[0..strlen(p2)]);

	return 0;
}

This is how to do it the D way:

int main(string[] args)
{
	string ch1 = "Hello World!";
	char[] ch2="Hello World!".dup;

	string s1=ch1[1..$];
	char[] s2=ch2[1..$];

	writeln(s1);
	writeln(s2);

	return 0;
}