Hola,  
He ido a iniciar un pequeño socket en C++, me ha dado un mensaje de error en el que decía:.
La línea en la que me da el error pone lo siguiente:Gracias,  
fox459

NAME
       socket - create an endpoint for communication

SYNOPSIS
       #include <sys/types.h>          /* See NOTES */
       #include <sys/socket.h>

       int socket(int domain, int type, int protocol);

int packet_socket;
packet_socket = socket(AF_INET, SOCK_STREAM, 0);

int *packet_socket; // uninitialized pointer
packet_socket = socket(AF_INET, SOCK_STREAM, 0);

iterator erase (iterator position);

#include <iostream>
#include <list>
#include <algorithm>
using namespace std;
 
// P : length(l) >= 0 , 0 <= i < length(l)  ,k >= 0
void invertSegment(list<char>& l, const int i, const int k){
  list<char>::const_iterator it1,it2;
  it1 = next(l.begin(),i);  //O(l)
  it2 = next(l.begin(),min(i+k,(int)l.size())); // O(i+k)
  for(it2--;it2!=it1 ;it2-- ) // O(k))
    {
      l.insert(it1,*it2);  // O(1)
      it2=l.erase(it2);
    }
  return;    
}
 
 
 
int main() {
  list<char> l;
  int N, i, k;
  char c;
  for ( ; cin >> N >> i >> k; )
    {
      l.clear();
      for (int n = 0; n < N; n++)
	{
	cin >> c ; l.push_back(c);
	}
      invertSegment(l,i,k);
      for (list<char>::const_iterator it=l.begin(); it!=l.end(); it++) cout << *it << " ";
      cout << endl;
    }
  return true;
}
 

 it2=l.erase(it2);

 l.erase(it2);

6 1 2
1 2 3 4 5 6 
1 3 2 4 5 6 
6 1 4
1 2 3 4 5 6
1 5 4 3 2 6 
6 1 5
1 2 3 4 5 6
1 6 5 4 3 2 
6 0 6
1 2 3 4 5 6
6 5 4 3 2 1 

#include <stdio.h>
 
void rombo(unsigned altura) {
...
    if(i<h) { // Mientras el reglón no ha llegado a la altura del rombo
        int j;
        for(j=0; j<=h/2-w/2; ++j) // Calculo los espacios por escalon
            putchar(' ');         //    y los imprimo
        for(j=0; j<w; ++j) // Imprimo
            putchar('*');  //    los asteriscos
        putchar('\n'); // Al siguiente reglón
...}
 
int main() {
    rombo(6);
}

height: 0
*
height: 2
 * 
***
 * 
height: 4
  *  
 *** 
*****
 *** 
  *  
height: 6
   *   
  ***  
 ***** 
*******
 ***** 
  ***  
   *   
height: 8
    *    
   ***   
  *****  
 ******* 
*********
 ******* 
  *****  
   ***   
    *    
height: 10
     *     
    ***    
   *****   
  *******  
 ********* 
***********
 ********* 
  *******  
   *****   
    ***    
     *     
height: 12
      *      
     ***     
    *****    
   *******   
  *********  
 *********** 
*************
 *********** 
  *********  
   *******   
    *****    
     ***     
      *      
height: 14
       *       
      ***      
     *****     
    *******    
   *********   
  ***********  
 ************* 
***************
 ************* 
  ***********  
   *********   
    *******    
     *****     
      ***      
       *       
height: 16
        *        
       ***       
      *****      
     *******     
    *********    
   ***********   
  *************  
 *************** 
*****************
 *************** 
  *************  
   ***********   
    *********    
     *******     
      *****      
       ***       
        *        
height: 18
         *         
        ***        
       *****       
      *******      
     *********     
    ***********    
   *************   
  ***************  
 ***************** 
*******************
 ***************** 
  ***************  
   *************   
    ***********    
     *********     
      *******      
       *****       
        ***        
         *         
height: 20
          *          
         ***         
        *****        
       *******       
      *********      
     ***********     
    *************    
   ***************   
  *****************  
 ******************* 
*********************
 ******************* 
  *****************  
   ***************   
    *************    
     ***********     
      *********      
       *******       
        *****        
         ***         
          *          
height: 22
           *           
          ***          
         *****         
        *******        
       *********       
      ***********      
     *************     
    ***************    
   *****************   
  *******************  
 ********************* 
***********************
 ********************* 
  *******************  
   *****************   
    ***************    
     *************     
      ***********      
       *********       
        *******        
         *****         
          ***          
           *           
height: 24
            *            
           ***           
          *****          
         *******         
        *********        
       ***********       
      *************      
     ***************     
    *****************    
   *******************   
  *********************  
 *********************** 
*************************
 *********************** 
  *********************  
   *******************   
    *****************    
     ***************     
      *************      
       ***********       
        *********        
         *******         
          *****          
           ***           
            *         

#include <stdio.h>
 
void printLineR(const int N, const int n,const int start)
{
  if (start==N+1) return;
  else
    {
      const int nn = n<=(N/2)?n:N-n;
      if (start < (N/2) - nn ) printf(" ");
      if ((((N/2) - nn)<=start) && (start <= (N/2 + nn))) printf("*");
      if ((start > (N/2 + nn))) printf(" ");
      printLineR(N,n<=(N/2)?n:N-n,start+1);
    }
}
 
void printLine(const int N,const int n)
{
  printLineR(N,n,0);
  printf("\n");
}
 
 
void diamondR(const int N, const int n)
{
  if (n == N+1)  return;
  else
    {
      printLine(N,n);
      diamondR(N,n+1);
    }
 
}
/* 0 <= N */
void diamond(const int N)
{
  diamondR(N,0);
}
 
int main()
{
  int N=25;
  for (int n=0; n<N ; n+=2 ) 
    {
      printf("height: %d\n",n);
      diamond(n);
    }
}
 
 
 

Muchas gracias @SrMcLister, entonces mi algoritmo quedaria asi:
//Aunque no me convence del todo ya que al ingresar 1 o 2 me devuelve el valor de la pila.cima y no es lo que busco pero funciona

Código

int fibonacci(int n)
{
	tpila pila;
	init_stack(pila);
	while(pila.cima<n-1){ 
		push_stack(pila, pila.datos[pila.cima]+pila.datos[pila.cima-1]);
	}
	return top_stack(pila);
}
 

....

• implementar el TAD pila
• usar el TAD pila para resolver el problema de Fibonacci

#include <stack> // from STL
#include <algorithm> // for min
#include <iostream>  // cout, cin
using namespace std;
 
 
/*
 
Starting on 0!
 
P : 0 <= N ... 
I :
   0 <= n <= N
   top(stack) = fib(n)
   n > 1 -> top (pop(stack)) = fib(n-1)
 
 */
int Fibonacci(const int N)
{
  stack<int> s ;
  s.push(1);
  s.push(1);
  for(int n=min(N,1) ;  n<N ; n++)
    {
    int n1= s.top() ;
    s.pop();
    int n2 = s.top();
    s.pop();
    s.push(n1);
    s.push(n2+n1);
    }
  return s.top();
}
 
 
#define MAX 10000
int main(int argc, char **args)
{
  int N;
  for (; cin >> N  ; ) cout << Fibonacci(N) << endl;
  return 0;
}

• Las lineas 2,4,6,8,10,12... revelan la secuencia de Fibonacci
  1,1,2,3,5,8,13,21,34
  
• Las lineas 1,3,5,7,9,11... revelan el orden de los términos de aquellas
  0,1,2,3,4,5,6,7,8
  

0
1
1
1
2
2
3
3
4
5
5
8
6
13
7
21
8
34

• enteros, los que no tienen parte decimal propiamente
• decimales, los que tienen parte decimal, ya sea finita o infinita periódica

#include <stdio.h>
 
 
/* Formal Spec
   P : N >= 0 , p>=0 , q > 0 
   Q :
     rat(p/q) - (p/q + \sum i : 1 <= i <= N : pow(10,-i)*((r_{i-1}*10)/q)
      <= pow(10,-N)
 
   where r_{0} = p%q ;
         r_{n+1} = r_{n}*10 % q
 
   Informally, any rational number can be expressed with arbitrary precission
   just by operating its sucessive remainders.
*/
void exprDecUpToN(const int p, const int q,
                   int V[], const int N)
{
  int n,r;
  for(n=1, V[0]=(p/q), r=(p%q);n<N;n++)
    {
      V[n] = (10*r)/q;
      r = (10*r)%q;
    }
  return;
}
 
#define MAX 10000
int main(int argc, char **args)
{
  int N,p, q, V[MAX];
 
  for (; scanf("%d %d %d",&N,&p,&q)==3 ; )
    {
      exprDecUpToN(p,q,V,N+1);
      int n;
      printf("%d.",V[0]);
      for (n=1; n<N+1; n++) printf("%d",V[n]);
      printf("\n");
    }
  return 0;
}

1 1 2
0.5
2 1 2
0.50
4 56 8
7.0000
18 1 3
0.333333333333333333
2 3 4
0.75
4 3 4
0.7500
40 56 8
7.0000000000000000000000000000000000000000
500 47 7
6.7142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857

/*
CYCLE: Informally, a circular permutation, ie.
 
  [1,4,23,7]~[4,23,7,1]~[23,7,1,4]~[7,1,4,23]
*/
#define MAX 10000
#include <cassert>
#include <cstdlib>
#include <cstdio>
 
// Implementation on static memory.
typedef struct {
  int V[MAX];
  int N;
} CycleSeq, *pCycleSeq;
 
CycleSeq* cycle(const int V[],const int N)
{
  // Pre: assumed Def(canonical(V))
  CycleSeq *A;
  if (!(A = (pCycleSeq)malloc(sizeof(CycleSeq))))
    {
      perror("malloc");
      exit(1);
    };
  A->N = N ; 
  for(int n=0; n<N ; n++) A->V[n]=V[n];
  return A;
}
 
int contains(const int i,const CycleSeq *A)
{
  // Pre: true O(n)
  int n;
  for (n=0 ; n<A->N && (A->V[n]!=i) ; n++);
  return (n<A->N);
 
}
 
int next(const int i,const CycleSeq *A)
{
  // Pre: contains(A,i) O(n)
  int n ;
  for ( n=0 ; A->V[n]!=i ; n++);
  return (A->V[(n+1)%A->N]);
 
}
 
/* Comment: Compare cannonical forms . (Was SameCycle)*/
int equals(const CycleSeq *A, const CycleSeq *B)
{
 
  if (A->N != B->N) return 0;
 
  if (A->N == 0 ) return 1 ;
 
  // e.o.c
  assert((A->N == B->N) && A->N );
 
  int n ;
  int mA, mB;
  for (mA=mB=0, n = 1 ; n < A->N ; n++)
    {
      if (A->V[mA]>A->V[n]) mA = n ;
      if (B->V[mB]>B->V[n]) mB = n ;
    };
  // mA mB holds minimum positions; count matches in cannonical form.
  for(n=0; (n < A->N) && (A->V[(mA+n)%A->N]==B->V[(mB+n)%A->N]); n++);
  return (n == A->N);
}
 
#include <iostream>
using namespace std;
#define MAX 10000
 
int main(int argc, char *args[])
{
  CycleSeq *B,*A;
  int V1[MAX],V2[MAX];
  int N1,N2;
  for( ; cin >> N1 && cin >>N2 ; )
    {
      for(int n=0; n<N1; n++) cin >> V1[n];
      for(int n=0; n<N2; n++) cin >> V2[n];
      A= cycle(V1,N1);
      B= cycle(V2,N2);
      cout << equals(A,B) << endl;
      free(A);
      free(B);
    }
}

• Linea que marca la longitud de las permutaciones ciclicas
• Componentes de la primera permucacion
• Componentes de la segunda permucacion
• Acaba cuando no se dan pares de longitudes

5 5
6 23 4 71 9
71 9 6 23 4
1
5  5
71 9 6 23 4
6 23 4 71 9
1
5  5
6 23 4 71 9
6 23 71 4  9
0

1 1 
3 3 
1
1 1
3 4
0
2 2
1 2
2 1
1
2 3 
1 2 
1 2 3
0
4 4
1 4 23 7 
4 23 7 1
1
4  4
4 23 7 1
23 7 1 4
1
4  4
23 7 1 4
7 1 4 23
1
4  4
7 1 4 23
1 4 23 7
1
4  4
1 4 23 7
23 7 1 4 
1
4 4 
23 7 1 4 
23 1 7 4
0

 CYCLE: Informally, a circular permutation, ie.

  [1,4,23,7]~[4,23,7,1]~[23,7,1,4]~[7,1,4,23]


  Algebraic Spec: 
  ---------------

  TAD CYCLE is

  uses SEQ;

  carrier Cycle;

  ops
  ---

  cycle : Seq -> Cycle   [non free cons]

  partial next : Int Cycle -> Int   [ obs ]

  aux ops 
  --------

  contains : Int Cycle -> Bool  [obs]

  partial canonical  : Seq -> Seq  // extends TAD SEQ, but safe

  var
  ---
  n:Int, c:Cycle , s: Seq

  axioms
  ------

  contains(n,c) -> Def(next(n,c))

  nonRepeated(s) -> Def(canonical(s))

  Def(canonical(s)) -> Def(cycle(s))

  contains(n,cycle(s)) = contains(n,s)

  // canonical form of a a seq.
 length(s) = length(cannonical(s))

  let
    M = length(s)
  in
    (M==0 ||
           let 
              ms,ms' = min(s) , min(canonical(s))
           in  
           \forall i : 0<= i < M : s.at[(ms+i)%M]=cannonical(s).at[(ms'+i)%M])

  cycle(seq) = cycle(cannonical(seq))  

  Impl:
  -----

    int V[MAX];
    int N;

  INV : N<=MAX && \forall : 0 <= i < N : frec(V[i],V)=1 

  ABSTRACTION : (V1,N1) ~ (V2,N2)

     N1=N2 and
     (N1 = 0 ||
     let A = min i : 0 <= i < N1 : V1[i]
         B = min i : 0 <= i < N2 : V2[i]
     in
     \forall : 0 <= i < N1 : V1[(A+i) mod N1)] = V2[(B+i) mod N1)] )
         

#include <stdio.h>
#include <stdlib.h>
 
    int buscarMayor(int *p, int n);
 
    int main()
    {
        int vec[5] = {1, 4, 5, 2, 2},
            mayor;
        mayor = buscarMayor(vec,5);
        printf("El mayor es: %d", mayor);
        return 0;
    }
 
    int buscarMayor(int *p, int n)
    {
        int may = *p;
        while(--n){
            if (*p > may)
                may = *p;
            p++;
        }
        return may;
    }
 

        int vec[5] = {1, 4, 2, 2, 5}

       int may = *p++;  // mind the post-increment

int buscarMayor( int *p, int n)
{
  int may = *p;
  while(--n){
    if (*++p > may) // mind the pre-increment
      may = *p;
  }
  return may;
}

#define MAX 10000
#include <assert.h>
 
/* Static memory implementation */
 
typedef struct {
  int V[MAX];
  int N;
} CycleSeq, *pCycleSeq;
 
 
/* Comment: Compare cannonical forms */
int SameCycle(CycleSeq *A, CycleSeq *B)
{
 
  if (A->N != B->N) return 0;
 
  if (A->N == 0 ) return 1 ;
 
  // otherwise
  assert((A->N == B->N) && A->N );
 
  int n ;
  int mA, mB;
  for (mA=mB=0, n = 1 ; n < A->N ; n++)
    {
      if (A->V[mA]>A->V[n]) mA = n ;
      if (B->V[mB]>B->V[n]) mB = n ;
    };
  // mA mB holds minimum positions; 
 // count coincidences in cannonical form.
  int count;
  for(count=0; (count < A->N) && (A->V[mA]==B->V[mB]); mA=(mA+1)% A->N,mB=(mB+1)%A->N  )
    count++;
  return count == A->N;
}

long ftell(FILE *stream)

int fgetc(FILE *stream);

#include <stdlib.h> // exit()...
#include <assert.h> // assert
#include <stdio.h> //p printf
#include <ctype.h> // isprint
 
int main()
{
  char c;
  int n;
  FILE* fs;
  const char *pattern="%d\t%c\t%d\n";
  char row[80];
  if (!(fs=fopen("texto.txt","r")))
    {
      perror("fopen");
      exit(EXIT_FAILURE);
    }
  printf("ASCII\tPrint\tPos\n");
  while((c=fgetc(fs))!=EOF)
    {
      assert(isascii(c));
      if ((n=sprintf(row,pattern,c,isprint(c)?c:' ',ftell(fs)))<0)
	{
	  perror("sprintf");
	  exit(EXIT_FAILURE);
	}
      printf(row);
    }
  if (c!=EOF)
    {
      perror("fgetc");
      exit(EXIT_FAILURE);
    }
  fclose(fs);
  exit(EXIT_SUCCESS);
}
 

 
ASCII	Print	Pos
115	s	1
117	u	2
112	p	3
104	h	4
111	o	5
108	l	6
97	a	7
115	s	8
97	a	9
100	d	10
107	k	11
106	j	12
104	h	13
111	o	14
108	l	15
97	a	16
115	s	17
97	a	18
100	d	19
10	 	20
97	a	21
100	d	22
104	h	23
111	o	24
108	l	25
97	a	26
100	d	27
115	s	28
97	a	29
10	 	30