Lets say I am using some string variables, but I want to ensure that there are no typing errors in some code I am using.
so I define newString as a new string type and declare a variable as ANewString.

That way if I create a function such as functionUsingNewString(a: newString) and I pass a plain string as a parameter to functionNewString the compiler declares an error.

If c is string and b is newString and I do b := c the compiler should
generate an error unless I do b := newString(c);

Is this possible?

Once upon a time, on 11/21/2012 08:37 PM to be precise, Frank Church said:

If you declare something like

Type
    NewString = Record
        Data: Array of Char;
    End;
And a function:
    Function ToNewString(a: String): NewString;
    Begin
        SetLength(Result.Data, Length(a));
        Move(a[1], Result.Data[0], Length(a) * SizeOf(Char));
    End;

; The compiler should generate an error when you try to typecast a String to a NewString.

Yes.

type newString = type string;

Any function that accepts newString as a parameter will cause a compilation error if you try to pass a normal string. You'll have to cast it to newString first.

This is not the case, as the following program demonstrates. The compiler does not even blink.

program Project1;
{$mode objfpc}{$H+}
type TnewString = type string;
function NewStringFn(ns: TnewString): integer;
var c: Char;
begin
   Result := 0;
   for c in ns do
    if (c#0) then inc(Result);
end;
var s:string = 'ansistring';
     ns:TnewString = 'new string';
begin
   writeln('The new string length is ',NewStringFn(ns));
   writeln('The old string length is ',NewStringFn(s));
end.

Kenneth Cochran wrote

Any function that accepts newString as a parameter will cause a compilation error if you try to pass a normal string. You'll have to cast it to newString first.

That is an incorrect assumptions. The compiler will happily accept both types without needing typecasting.

Regards,
- Graeme -

Graeme Geldenhuys wrote

That is an incorrect assumptions. The compiler will happily accept both types without needing typecasting.

I stand corrected. I assumed it behaved the same as Delphi in this respect. It doesn't, not even when Delphi mode is enabled.

Delphi behaves like FPC, at least Kylix 3 does. Afaik the only use for "type newstring = type string;" is so that you can declare overloaded routines that are differentiated based on those two types.

Jonas

Jonas Maebe hat am 22. November 2012 um 10:03
geschrieben:

Yes, for example you can ask the type via RTTI. For instance the LCL uses type TTranslateString = string for all string properties that should be auto translated.

Mattias