Temas

[Instancias/archivo1]

Hola, quería saber si es posible mover un enlace simbólico de directorio, sin que este pierda la referencia al archivo al que enlaza.

Por ejemplo tengo el archivo1 en el directorio Instancias, en la siguiente ruta:

Código [Seleccionar] Expandir

Trabajos/modelos/Instancias/archivo1

creo el enlace símbolico desde el directorio modelos:

Código [Seleccionar] Expandir

Trabajos/modelos$ ln -s Instancias/archivo1 enlace

luego el enlace se creara en modelos de la siguiente manera: enlace-> Instancias/archivo1
si lo muevo al directorio inmediatamente superior

Código [Seleccionar] Expandir

Trabajos/modelos$ mv enlace ..

Este ahora se encontrara en el directorio Trabajos enlazando con la misma ruta a archivo1
enlace-> Instancias/archivo1, de manera que esa ruta ya no es válida desde ese directorio.

Por lo que me pregunto si hay alguna manera de hacer el enlace simbólico con una ruta absoluta, o algún comando que sirva para moverlos por los directorios actualizando su ruta de acceso al archivo que enlazan.

Gracias de antemano. Un saludo.

[Buenas,Estoy aprendiendo a usar postgreSQL y tengo un problema al intentarcargar el driver JDBC en mi proyecto.Uso postgreSQL 9.3 y Netbeans 7.2He agregado el archivo 'postgresql-9.3-1101.jdbc4.jar' al CLASSPATH y el servidor postgres esta corriendoPero cuando se ejecuta esta parte del codigo:]

Buenas,
Estoy aprendiendo a usar postgreSQL y tengo un problema al intentar
cargar el driver JDBC en mi proyecto.

Uso postgreSQL 9.3 y  Netbeans 7.2

He agregado el archivo 'postgresql-9.3-1101.jdbc4.jar' al CLASSPATH y el servidor postgres esta corriendo


Pero cuando se ejecuta esta parte del codigo:

Código (java) [Seleccionar] Expandir

try{
            Class.forName("org.postegresql.Driver");
        }catch(ClassNotFoundException cnfe){
            System.out.println("Driver no disponible!");
            System.out.println("error y salida");
            cnfe.printStackTrace();
            System.exit(1);
       
        }

me salta la excepción, por lo que deduzco que el driver no se carga

Excepcion:

Código [Seleccionar] Expandir

run:
Probando que el driver postgresSQL esta presente
Driver no disponible!
java.lang.ClassNotFoundException: org.postegresql.Driver
error y salida
at java.net.URLClassLoader$1.run(URLClassLoader.java:366)
at java.net.URLClassLoader$1.run(URLClassLoader.java:355)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(URLClassLoader.java:354)
at java.lang.ClassLoader.loadClass(ClassLoader.java:423)
at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:308)
at java.lang.ClassLoader.loadClass(ClassLoader.java:356)
at java.lang.Class.forName0(Native Method)
at java.lang.Class.forName(Class.java:186)
at javapostgresql.JavaPostgreSql.main(JavaPostgreSql.java:22)
Java Result: 1
GENERACIÓN CORRECTA (total time: 0 seconds)

¿Que falla?. Muchas gracias.

..solucionado

Hola me ha surgido una pequeña duda existencial.

Supongo que conocereis la aplicación spotify para la reproducción de música vía streaming, pues deezer es una aplicación con el mismo propósito y muy similar.

Entre sus prestaciones se encuentra escuchar música en modo offline. Tienes que hacer una playlit marcando que esté disponible en modo offline y sincronizarla.
Mi duda es, las canciones que se sincronizan se guardan en la memoria interna del móvil?? Por qué al parecer no ocupa nada de memoria y puedas escucharlas cuando quieras y solo las tienes disponibles dentro de la aplicación de deezer. ¿Qué mecanismo se utiliza para conseguir esto??

Saludos!

[1 C:\Dev-Cpp\Nodo.h:3, from Nodo.cpp In file included from Nodo.h:3, from Nodo.cpp]

Hola, estoy haciendo un programa que necesita implementar pilas y colas para comparar 2 palabras palíndromas. Tengo un problema a la hora de compilar y despues de horas rompiendome la cabeza pido ayuda xd.

El problema me da a mi que esta en las cabeceras de los .h. Pero no lo consigo ver, os dejo el código a ver si alguien identifica el problema. Gracias de antemano =)!!

Código [Seleccionar] Expandir

//pila.h
#ifndef __PILA_H__
#define __PILA_H__
#include "Nodo.h"
#include <iostream>
#include <string>


class Pila
{
  private:
          Nodo *primero;
          unsigned int numElemntos;
          void borrarCima();
 
  public:
         Pila();
         ~Pila();
         void apilar(char);
         bool desapilar(char &);
         unsigned int getElemntos();
         bool vaciaP();
};
#endif

Código [Seleccionar] Expandir

//Cola.h
#ifndef __COLA_H__
#define __COLA_H__
#include "Nodo.h"
#include <iostream>
#include <string>


class Cola
{
  private:
          Nodo *primero;
          Nodo  *ultimo;
          unsigned int numElemntos;
          void borrarCabeza();
 
  public:
         Cola();
         ~Cola();
         void encolar(char);
         bool desencolar(char &);
         bool vaciaC();
         unsigned int getElemntos();
};
#endif

Código [Seleccionar] Expandir

//Nodo.h
#ifndef __NODO_H__
#define __NODO_H__
#include "Pila.h"
#include "Cola.h"
#include <iostream>
#include <string>

class Nodo
{
   friend class Pila;
   friend class Cola;
   private:
         
           Nodo *siguiente;
           char caracter; 
   
   public:
          Nodo(char);
          char getElemento();
          void setElemento(char);   
};
#endif


Código [Seleccionar] Expandir

//Pila.cpp
#include "Nodo.h"
#include "Pila.h"
#include <iostream>
#include <string>

using namespace std;

Pila::Pila()
{
   primero = NULL;
   numElemento = 0;
};
Pila::~Pila()
{
    while(!vaciaP()) //{borrarcima();}
    {
      Nodo *p = primero;
      primero = primero->siguiente;
      delete (p);       
   
    }
};
             
bool Pila:: VaciaP()
{
     return primero; //numElementos==0 ->compara para tener un bool
};
             

void Pila::apilar(char c)
{
     Nodo *p = new Nodo(c);
     p->siguiente = primero;
     primero = p;
     numElementos++;
     
};
void Pila::borrarCima()
{
   
     Nodo *p = primero;
     primero = primero->siguiente;
     delete p;
     numElementos--;
}
bool Pila::desapilar (char &c)
{
     Nodo *aux;
     
     if(VaciaP())
     {
         cout << "La pila esta vacia \n";
         return false;           
     }
     else
     {
         aux = primero;
         primero = primero->siguiente;
         delete(aux);
         numElementos--;
         return true;
     }
};

char Pila::getElementos()
{
  return numElementos;
};



Código [Seleccionar] Expandir

//Cola.cpp
#include "Nodo.h"
#include "Cola.h"
#include <iostream>
#include <string>

using namespace std;

Cola::Cola()
{
        Nodo  *primero = NULL;
        Nodo  *ultimo = NULL;
        unsigned int numElemntos = 0;     
};

Cola::~Cola()
{
     while(!vaciaC()) //{borrarCabeza();}
    {
      Nodo *p = primero;
      primero = primero->siguiente;
      delete (p);       
    }
};
void Cola::encolar(char c)
{   
     Nodo *p = new Cola(c);
     if (vaciaC())
     {
        primero = *p;
        ultimo = *p;
        numElementos++;         
     }
     else
     {
          p->siguiente = ultimo;
          ultimo = p;
          numElementos++
     }
 
};
bool Cola::desencolar (char &c)
{
     Nodo *aux;
     
     if(VaciaC())
     {
         cout << "La cola esta vacia \n";
         return false;
                   
     } else if (numElementos==1)
     {
       delete (primero);
       primero=null;
       ultimo=null;
       numElementos --;
       return true;
     }
     else
     {
         aux = primero;
         primero = primero->siguiente;
         delete(aux);
         numElementos--;
         return true;
     }
};
void Pila::borrarCabeza()
{
   
     Nodo *p = primero;
     primero = primero->siguiente;
     if(primero == NULL)
     {
      final = NULL;         
     }
     delete (p);
     numElementos--;
};

char Cola::getElementos()
{
  return numElementos;
};



Código [Seleccionar] Expandir

//Nodo.cpp
#include "Nodo.h"
#include <iostream>
#include <string>

using namespace std;

Nodo::Nodo(char c)
{
   caracter = c; 
   siguiente = '\0';    //NULL 
};

char Nodo::getElemento()
{
  return caracter ;
};

void Nodo::setElemento(char c)
{
  caracter = c;   

};



Y los fallos que me tira el compilador son los siguientes:

1 C:\Dev-Cpp\Nodo.h:3,               from Nodo.cpp In file included from Nodo.h:3,               from Nodo.cpp
1 C:\Dev-Cpp\Nodo.cpp                  from Nodo.cpp
11 C:\Dev-Cpp\Pila.h ISO C++ forbids declaration of `Nodo' with no type
11 C:\Dev-Cpp\Pila.h expected `;' before '*' token
1 C:\Dev-Cpp\Nodo.h:4,               from Nodo.cpp In file included from Nodo.h:4,               from Nodo.cpp
1 C:\Dev-Cpp\Nodo.cpp                  from Nodo.cpp
11 C:\Dev-Cpp\Cola.h ISO C++ forbids declaration of `Nodo' with no type
11 C:\Dev-Cpp\Cola.h expected `;' before '*' token
12 C:\Dev-Cpp\Cola.h ISO C++ forbids declaration of `Nodo' with no type
12 C:\Dev-Cpp\Cola.h expected `;' before '*' token
C:\Dev-Cpp\Makefile.win [Build Error]  [Nodo.o] Error 1

[segmento]

Buenas amigos, aquí os traigo una dudilla de novato total que espero que me podais resolver. El  problema es el siguiente:

Con 2 bytes (1 palabra) en una arquitectura 8086 claro esta que se pueden direccionar 64k (16^4) de manera que se puede acceder a las posiciones de memoria desde 0 a FFFFh.

Lo que no entiendo es el concepto de los registros de segmento y desplazamiento que sirven para superar este límite.

la formulita como tal se que es esta 16xsegmento+desplazamiento y de esta manera se consigue un nibble más,pudiendo ahora direccionar 1Mb(16^5) desde 0 a FFFFFh.

No llego a comprender como se consigue un nibble más gracias a esto del segmento y desplazamiento. Seguro que es una chorrada pero si alguien me  pudiera aclarar este concepto un poco así en términos que entienda se lo agradecería muchísimo.

Un saludo!