C++ Index

Delphi Index



Structures in C++ and records in Delphi
Translating C++ Code into Delphi Pascal


A structure in C is analogous to a record in Delphi.  A record can be thought of as a kind of complex variable declaration.

type
MyData = record
   phonenum : string;
   married : boolean;
   age : integer;
   name : string;
end;
var
Datalist : MyData;

In this example we use the type statement to create a custom data type, in this case a record.  The declaration of the record can then be used in the var statement to initalize an actual instance of the declared data type.  The record above is a kind of a custom variable which consists of a number of different variable types stored as a single data record.

We can access a field of the record using the dot operator.

thephonenum := Datalist.phonenum;

Sometimes it is more convenient to use pointers to records.

type MyDataListPointer = ^MyData;

The declaration of the MyData record then follows as above and then in the var declaration we declare a pointer to a record instead of a static instance of a record.

var
DataListPtr : MyDataListPointer;

We then create an actual record from this pointer using the new statement.

new(DataListPtr);

And we access the fields of the record using pointer syntax.

DataListPtr^.phonenum := '336-3344';

There are many variations in the way records (or structures) are stored and manipulated (linked lists, arrays of records, etc.)  It is impossible to access common graphics formats, Windows or Linux API functions, etc., without dealing with records and so this is a very common and very important data type. Records, or structures as they are called in C, are used throughout APIs and as interfaces to many standard functions.  (For example a common bitmap graphic consists of a structure (or record in Delphi), which is referred to as  the Bitmap info header, which stores in record form all the information about the height, width, color depth, etc., of the following raw bitmap data in the file.)  The usefulness of records (or structures as C calls them) in database applications should be obvious, and they are used in any application where related data must be stored conveniently in a single structure.

If you are familiar with records in Delphi, the structure in C encapsulates the same idea using the syntax defined for this purpose in the C language.  The keyword 'record' and the syntax illustrated above is used to define records in Delphi, and C uses the keyword struct and the following syntax...

struct MyData {
    char phonenum[8];
    bool married;
    int age;
    char name[20];
};

This struct statement creates the equivalent of the record declared in Delphi above.  This declaration defines the 'type' of the structure, just as using the type declaration in Delphi to declare a variable of the type record.  To create an instance of the record in Delphi you use it in the var declaration as the variable type for the variable being declared as demonstrated above.  In C you can crate an instance of the structure by including the name of the variable after the closing curly braces and before the final semi-colon which completes the definition.

struct MyData {
    char phonenum[8];
    bool married;
    int age;
    char name[20];
}Datalist;

In the example above we have described the type of the structure and then we created an instance of the structure - a variable given the name Datalist.  Note that C is case sensitive, so a variable named Datalist is not the same as a variable named datalist or DataList, whereas all three would refer to the same variable in Delphi, which is not case sensitive.

Alternatively, an instance of the structure can be declared at any place in code prior to using the structure, just as any other variable is declared in C.  Unlike in Delphi, the variable type precedes the name of the instance of the variable.

MyData DataList;

This declares a variable DataList which is the type MyData, which means that the program allocates memory for the structure defined above, creating an instance of this record.

The fields of the record can then be accessed using the dot operator, as in Delphi, and using standard C functions.

To copy a string into a field within the structure...

strcpy(Datalist.phonenum, "383-4455");

or to fill in other fields...

Datalist.age = 51;

Datalist.married = true;

And so on...

Instances tructures can be declared as arrays of records, for example as part of a database application.  Here we will declare an array of 20 records...

MyData Datalist[20];

Each individual record can then be accessed using array syntax combined with the dot operator used to access record fields...

Datalist[0].age = 51;

And so on...

Structures can also be filled in using the following syntax.  Let's assume that the a record exists with a string field, and a couple of integer fields, and the structure name is Datalist.

Datalist = { "Some Name", 12, 102};

Arrays can also be filled in the same way.  The following C++ example creates an array of 3 strings.

string sarray[3];
sarray[0] = 'Hello';
sarray[1] = 'there';
sarray[2] = 'world';

This could also be accomplished using the following code...

string sarray = {'Hello', 'there', 'world'};

Initializer lists (like the above) can be used when the array is declared and in this case the dimension of the array can be omitted (the compiler can make the determination based on the initializer list).

Arrays can also be dynamically created, and the dimension can be passed as an integer variable, making the declaration truly dynamic.  Here we assume that x is an integer variable that has been previously initialized to the required number of strings in the array.  Notice that declaration is different in that the use of the pointer symbol (the asterik) indicates that this is going to be a dynamic array...

string* sarray = new string[x];
sarray[1] = 'Hello';
sarray[2] = 'there';
sarray[3] = 'world';

Here the programmer is going to have to code to make sure that bounds of the array are not violated, since the compiler will not know if '3' is out of range since the array was declared dynamically using a variable (x in the example above).

In C++ the name of an array is actually a pointer to the first element in an array.  When arrays are passed to functions as parameters you might see either of the two following ways of describing the array...

int somefunction(int anarray[], int size);

int somefunction(int* anarray, int size);

Both the above declarations describe an array parameter passed to a function, with the pointer pointing to the first element in the array.

Within the body of the function the elements of the array are then accessed using the usual syntax...

anarray[2] = 12;

Multidimensional arrays are declared as follows...

int anarray[4][6][7];   ... a 3-d array...

Initializer lists can be used when the array is declared...

int anarray[2][2] = { {2, 4}, {5, 6} };

C++, like Delphi, allows types to be declared and then the type to be used to declare instances of variables.  In the example above the delphi 'type' keyword was used to declare records consisting of variables.  This record type was then used to create an actual instance of the record type.

In C++ the keyword used is 'typedef' (the definition of a type which can then be used to create instances of variables...)  In both Delphi and C++ arrays can also be declared as types and then the type used to create actual arrays (typically this is done in the case of multidimensional arrays).  The type definition is included at the top of the unit...

#include <whatever.h>
...etc etc ...
const int X = 12;
const int Y = 14;
typedef int TwoDArray[X][Y];
..etc etc ...
int somefunction(TwoDArray, int, double);

In the body of the code the type (TwoDArray) is then used to create instances of the variable in the usual way...

TwoDArray anarray;

An initializer list can also be used to put values into the array as it is delcared  as illustrated above, although it is also typical to use loops (for loops in particular) to initialize or otherwise manipulate arrays...

The fields of a multidimensional array are accessed as follows...

anarray[2][8] = 32;


Previous page - C++ loops     Next page - pointers, the stack and the heap

C++ to Delphi Index      Delphi Index



A Unified Field Theory

failed_gravity_theory.gif - 10361 Bytes



The Unified Field Theory
is also available as a zip file ->
unified.zip

Introduction :The Pioneer Effect and the New Physics. A brief description of the new physics required to explain the 'Pioneer Effect', which is the constant deceleration of space craft as they fly through space.






Principles of Evolution: A Study in the Evolution of Bedbugs



A couple of years ago my bedroom was invaded by bedbugs. There were two variant genetic lines. One type of bedbug was an enlongated, thin, tubular insect, and the second genetic line was a flat, perfectly circular insect. The result of the cross breeding of these two genetically distinct variants was the production of a bedbug with charcteristics of both, an enlongated, flat bedbug with a central bulge (such that the shape of the bedbug was somewhere between 'long' and 'circular'). The long skinny bedbugs were such strange and unfamiliar looking insects that at first I did not recognize them as being bedbugs, and considered them to be a seperate species of insect. However, as the photographs of bedbugs above indicate, enlongated and skinny bedbugs are not uncommon, and the photographs also show the variants that are produced by genetic combinations that result in an insect somewhere in between 'circular' and 'enlongated'.

Therefore it is my hypothesis that evolution occurs by means of the transfer of dominate genes, with the production of such dominant genes being the product of 'biological algorithms', a genetic software program that brings physical characteristics into harmony with behavior, such that when behavior changes, and a conflict then exists, this acts as a trigger and causes the release of dominant genes. The result is rapid evolution of species. The bedbug is a relatively new insect, not the product of millions of years of evolution but rather an insect that is evolving in real time. The newly emerging dominant form of the insect is the flat, round ciruclar insect, well adapted to living in human bedrooms (it is flat, rather than tubular, thus allowing it to hide in the smallest cracks, living a stealthy lifestyle, and it is round, which gives the insect a maximum storage capacity such that it must endanger itself only a few times a month by emerging to feed.

Other examples of rapid evolution include the development of long legs in an invasive species of toad in Australia. As the toads move into the mountainous regions of Australia, and their behvaior changes, making them 'climbing toads', over the course of just a couple of decades the toads in the highlands have grown long legs specially adapted to climbing. It is worth noting here that the toads are poisonous, and are a successful invasive species because they have no natural predators in Australia, and so it would not be the case that the toads with long legs were 'the fittest survivors', because all the toads are survivors, and therefore predation does not explain the rapid emergence and spread of such well adapted, long legged toads. Once again we see evidence for the existence of biological algorithms and the rapid spread of dominant genes through a population, which once introduced proceed to overwhelm the older genes which are being replaced (making toad long legged and a bed bug round and flat).


A Theological Experiment

My interest in pursuing the Unified Field Theory is spurred on by my need to discover the theoretical explanation of a new form of propulsion (as explained on this page: Why the Unified Field Theory?). The experiment involving the bedbugs came out of nowhere.

I also believe that it is possible to justify theological propositions using experimental methods. If a thing is an objective truth then it can be verified and proven true by means of experimentation. Such a theological proposition is of more value than a ‘divine revelation’, since such revelations depend upon nothing more than establishing authority figures which requires the creation of artificial hierarchies, for the only reason why I might be encouraged to believe an authority figure who orders me to believe unsubstantiated opinions is if I could somehow be convinced that this authority possessed a mind that was somehow superior to mine, and thus was fit to express opinions as though opinions were unquestionable facts and thus worthy of being elevated to the status of absolute dogma.

There is a self evident human inequality which is visibly apparent. Some people are ‘beautiful’ and thus are the true elite on this planet, and some people are not. It is this sexual inequality and the degeneration that follows upon beauty that is the true driving force behind all the evil that happens on earth. The need for ruthless oppression and the pursuit of wealth and the consequent creation of suffering and poverty which must follow upon this practice is for the purpose of creating an artificial alpha elite.

The true elites are the young and the beautiful. The artificial elite are the rich and the wealthy. The elite aging rich artificial alpha male has no good looks, for he is physically degenerate, but he will be found escorting beauty because he has a beautiful wallet. If he loses his wallet he will be found at home with all the other unattractive aged beta males sitting in a rocking chair watching reruns of Bonanza. No money, no sex. It is for this reason that the alpha males are found to be so ruthless and so violent in pursuit of their goal. The alpha male has fallen. The beta male has arisen and now the whole planet is full of ruinous destruction for it.

We see in religion a confused and contradictory reaction to this reality. On the one hand religion preaches a sexless heaven where castration and the clitorectomy create ‘pure spirits’. Muslims throw women under sacks. On the other hand religion supports hierarchy and is the prop of the elite alpha male. It is for this reason that religion is incoherent when it comes to speaking about sex.

Now we see this same principle at work in all of nature. Guppies dance and show off their colorful tails and the guppy who dances with the most colorful tail is the sexually successful guppy. Therefore it is the doctrine of the ruthless oppressor which teaches that the solution to human sexual violence is to be found in castration and the creation of pure ghosts. This would be equivalent to damning an aardvark for having the ‘sinful aardvark nature’ or prosecuting an anteater for the high crime of ‘ant genocide’.

Therefore it was my theological hypothesis that the correct solution to this problem is to give every guppy a beautiful colorful tail. I compare this solution to the classic religious solution which is to cut off every tail since having a tail is ‘sinful’. If having a tail is sinful then God must be sinful for no human being has any choice in deciding whether or not they would be born with a colorful tail, or whether they would not.

When I was young I was a beautiful guppy with a lovely tail. So everyone seemed to think. I am older now. My nose became very badly sunburned and destroyed. It seemed good to me to test my hypothesis by using these ‘biological algorithms’ to correct this problem. I healed half my nose as you can see by the line separating the still very dark patch on the side in the photograph below.





I documented my experiment on these pages. one two t hree four fi ve six


I have confirmed to my own satisfaction that my theological proposition is correct and that religious dogma is erroneous, being based as it was upon nothing more than ‘divine revelation’ which is just a form of opinionated speculation. For the time being I am not continuing this experiment, for I must wait until the weather on this planet improves, and the dark clouds of ruthless oppression break letting a little sun shine come through so that I can show the world the truth about God, by showing people how God goes about giving an old guppy back his beautiful colorful tail.


Until then I will have to sit on the sidelines, while all my scientific breakthroughs are deliberately ignored, while I wonder to myself what ever in the world could be wrong with the human race, because what this all will prove at the end of it all is that there definitely was something wrong with the people on this planet.