Guillaume: /* Structures */

2010-06-12T11:15:44Z

‎Structures

Guillaume: 1 revision

2008-12-03T10:27:01Z

1 revision

89.180.146.64: /* IO string manipulations */

2008-03-15T01:23:06Z

‎IO string manipulations

New page

This page is kind of a handbook for writing c and c++ programs. References to practical issues are assigned to this page.

== GOLDEN RULES ==

# '''In a function, never pass the arguments by value, always pass them by reference'''

== Single file [http://en.wikipedia.org/wiki/ANSI_C ANSI C] project template ==

Here's a basic template for a single-file project:
<code>[c,Y]
/*Template for a [http://en.wikipedia.org/wiki/ANSI_C ANSI C] standard program file*/

/*Place the headers here*/
#include <stdio.h>
#include <math.h>

/*Place the Macros here*/
#define OK_ 1

/*Place the Casts here*/
typedef double REAL_T;

/*Place the subroutines declaration here*/
REAL_T deg(REAL_T x);

/*Main routine*/
int main(int argc, char* argv[])
{
/*...*/
return 1;
}
/*Subroutines*/
REAL_T deg(REAL_T x){
return x/fabs(x)*floor(fabs(x));
}
</code>

== Mixing C and C++ code ==

In order to mix C routines within a C++ structure simply make sure that the C routines are written in standard [http://en.wikipedia.org/wiki/ANSI_C ANSI C] and that they're all in a separate file. Then include ''extern "C"'' syntax. Here's an example:

<code>[cpp,Y]
#include <sstream>
#include <string>
#include <math.h>
extern "C"{
#include <fes.h>
}
</code>

== Using namespaces ==

Whenever one whishes to use C++ STL standard libraries then one has to use the '''std::''' namespace. Or it can be declared in the beginning of the routine or of the code:

<code>[cpp,Y]
#include <vector>
#include <string>
#include <sstream>

int main()
{
std::string str;
</code>
or
<code>[cpp,Y]
#include <vector>
#include <string>
#include <sstream>

using namespace std;

int main()
{
string str;
</code>

== Variables in C and C++ ==

There are several built-in types of variables:
<code>[c,Y]
char c; //byte size character [0x0-FFx0]
short int sn; //byte sized integer [0-255]
int n; //word(2bytes) sized integer [0-16556]
long ln; // 4 byte sized integer
float x; // single precision real number
double dx; // double precision real number
</code>
=== Memory structure and pointers ===
In C coding, a variable is in fact the combination of two elements: its value and its pointer:
*The value is a memory register where the variable value is stored.
*The pointer is another memory register containing the memory address of the variable value.
Thus the pointer points to the variable value.
<code>[c,Y]
char* c_p; //pointer to characters
short int* sn_p; //pointer to short integers
int* n_p; //pointer to integers
long* ln_p; // pointer to long integers
float* x_p; // pointer to single precision real numbers
double* dx_p; // pointer to double precision real numbers
</code>
==== Allocate arrays ====

In C, pointers allow to allocate arrays (blocks of memory) of a given variable single type...
Here's an example of allocating a memory block:
<code>[c,Y]
double* vector_p; //Allocates the memory register of the pointer, and fills it with dumb address
vector_p = (double*) malloc( sizeof(double)*(N + 2*p) ) // Allocates a block of memory and assigns
//its memory address to vector_p.
</code>

=== [http://en.wikipedia.org/wiki/Cast_%28computer_science%29 Cast] of types of variables ===

[http://en.wikipedia.org/wiki/Cast_%28computer_science%29 Casts] are a very useful feature of [http://en.wikipedia.org/wiki/C_programming_language C programming language]. They allow to define custom types of variables. They are defined at the beginning of the code. When well used, [http://en.wikipedia.org/wiki/Cast_%28computer_science%29 casts] allow easy portability from single to double precision computing. Here are a few examples:

<code>[c,Y]
typedef float REAL_SCALAR_T;
/*typedef double REAL_SCALAR_T;*/
typedef REAL_SCALAR_T* REAL_VECTOR_T;

REAL_SCALAR_T x = 3.1416;
REAL_VECTOR_T vx;
</code>

The above code defines single precision scalar and vector variables types.

<code>[c,Y]
typedef int INT_SCALAR_T;
/*typedef long INT_SCALAR_T;*/
typedef INT_SCALAR_T* INT_VECTOR_T;

INT_SCALAR_T n = 7;
INT_VECTOR_T v;
</code>

The above code defines single precision integer and integer vector variables types.

=== Structures ===
Structures are composites of several types of variables. A typical syntax example would be:

<code>[c,Y]
struct s_myexample{
char a;
int b;
float* ptr_p;
}

char ext = s_myexample.a;
</code>

Combining structures with casts is much more useful:
<code>[c,Y]
typedef struct s_myexample{
char a;
int b;
s_myexample_t* myotherexample_p;
}s_myexample_t;
</code>

== [http://en.wikipedia.org/wiki/Macro Macros] ==

The C or C++ compiler comes with [http://en.wikipedia.org/wiki/Preprocessor preprocessing] capabilities. Hence [http://en.wikipedia.org/wiki/Macro macros] are allowed, but use them with care. Here are a few examples for syntax purposes. Preferrably, define at head of the code.
<code>[c,Y]
#define OK_ 1
#define BAD_ -1
#define DATA_ 1
#define INPUT_ 2
</code>

== IO string manipulations ==

To perform simple output to the console:
<code>[cpp,Y]
std::cout << "ERROR: Too many parameters included in command line!\n" << std::endl;
</code>

== Building the project ==

=== Building a single file project ===
g++ -c -o example.o -Iincludepath example.cpp
g++ -o example.exe -Llibpath example.o alibrary.a
The first line compiles example.cpp and outputs the object example.o. The second line links the object file agains a library (static or shared).

=== Building a several files project ===
CC="g++"
INC="-Iincludepath1 -Iincludepath2 -Iincludepath3"
LIB="-Llibpath1 -Llibpath2"
SRC="file1.cpp file2.cpp file3.cpp"
OBJ="file1.o file2.o file3.o lib1.a lib2.a"

$CC -c $INC $SRC
$CC -o example.exe $LIB $OBJ
The first line compiles and returns the object files. The second line links against the libraries (static or shared).

=== Creating a makefile for the project ===

Usually, the [http://en.wikipedia.org/wiki/Integrated_Development_Environment IDE] takes care of the [http://en.wikipedia.org/wiki/Make making] of the project. However when porting to other environments such as [[*NIX platforms]] then one may want to consider to create a [[makefile]].
[[Category:Technology]]
[[Category:Programming]]
[[Category:Linux]]
[[Category:Windows]]

@@ Line 138: / Line 138: @@
 Structures are composites of several types of variables. A typical syntax example would be:
-<code>[c,Y]
+<htm>
   struct s_myexample{
      char a;
@@ Line 146: / Line 147: @@
   char ext = s_myexample.a;
-</code>
+</pre>
 Combining structures with casts is much more useful:

← Older revision	Revision as of 10:27, 3 December 2008
(No difference)

Cpp - Revision history

Guillaume: /* Structures */

Guillaume: 1 revision

89.180.146.64: /* IO string manipulations */