Mensajes

La función devuelve un int, no una matriz entera...

Lo que tienes que hacer es pasarla como parámetro en la función. Las matrices por defecto se pasan por referencia y mantienen los cambios tras finalizar la función.

Por cierto no uses getch() ni la librería conio, las dos son consideradas malas prácticas de programación 

Claro que es legal, por eso le he preguntado si no le lanza un warning, por ejemplo de comparación entre puntero y entero.

No da warning porque es una comparación con 0, y esa comparación si tiene sentido (para comprobar si es un puntero válido).

Muy interesante, tengo que verme la programación de sockets que me queda por mirar 

Por cierto:

Código (cpp) [Seleccionar] Expandir

host=gethostbyname("chat.freenode.net");

¿Que es chat.freenode.net?

Código (c) [Seleccionar] Expandir

subcadena!='\0'

Qué es eso? Ni siquiera te lanza un warning?

Es legal, lo que hace comparar el valor del puntero char con el ASCII de '\0'.

Aunque evidentemente, no es eso lo que quería hacer. Supongo que se le ha olvidado el [j]

Desconocía el punto A, creía que un array se tomaba como puntero

Genial, como estaba usando funciones del sistema windows ni me fijé en si era portable. Más adelante si saco la versión para linux ya me has ayudado bastante con ese código!

Esa función es de la API de windows xD.

Relee el mensaje que no lo has entendido bien  

Pues diciéndomelo tan seguro me esperaba que cambiara, pero si te soy sincero la salida de p1 es la del principio, sin la 'z' modificada xD

Cierto, creo que ya he pillado el problema (un array no responda igual que un puntero al parecer).

Prueba ahora:

Código (cpp) [Seleccionar] Expandir

#include <stdio.h>
#include <string.h>

struct prueba {
int a;
char b;
char* c;
};

int main()
{
struct prueba p1, p2, p3, p4;

// se inicializa p1
p1.a = 10;
p1.b = 'A';
p1.c = new char[100];
strcpy(p1.c, "ola k ase");

// se copia p1 a p2 y se imprime
p2 = p1;
printf("p2: %d %c %s\n", p2.a, p2.b, p2.c);

// p3 apunta a p1
p3 = p1;

// se copia *p3 a p4 y se imprime
p4 = p3;
printf("p4: %d %c %s\n", p4.a, p4.b, p4.c);

   // Ahora modifico c en p4)
  p4.c[2] = 'z';

   // Compruebo p1... WTF QUE HA PASADO?

     printf("p1: %d %c %s\n", p1.a, p1.b, p1.c);

return 0;
}

De hecho poder se puede:

http://stackoverflow.com/questions/9127246/copy-struct-to-struct-in-c

Lo único que no sé a qué se refiere con estructuras simples. Esta noche con más calma lo miro bien, que desde siempre he creído que se podían copiar y ahora resulta que no es tan trivial...

Saludos.

Se puede hacer directamente si las estructuras no tienen punteros. Si los tiene te compilará pero te puedes encontrar problemas extraños en la ejecución (como ya he planteado antes).

Esta es una de las razones por las que se inventaron los operadores en C++.

Pues a mi esto me funciona perfectamente...

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <string.h>

struct prueba {
int a;
char b;
char c[100];
};

int main()
{
struct prueba p1, p2, *p3, p4;

// se inicializa p1
p1.a = 10;
p1.b = 'A';
strcpy(p1.c, "ola k ase");

// se copia p1 a p2 y se imprime
p2 = p1;
printf("p2: %d %c %s\n", p2.a, p2.b, p2.c);

// p3 apunta a p1
p3 = &p1;

// se copia *p3 a p4 y se imprime
p4 = *p3;
printf("p4: %d %c %s\n", p4.a, p4.b, p4.c);
return 0;
}

Así que sí, puedes copiar structs directamente. En el ejemplo que te he dado también lo tienes con punteros.

Saludos.

¿Seguro? Prueba esto:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <string.h>

struct prueba {
int a;
char b;
char c[100];
};

int main()
{
struct prueba p1, p2, *p3, p4;

// se inicializa p1
p1.a = 10;
p1.b = 'A';
strcpy(p1.c, "ola k ase");

// se copia p1 a p2 y se imprime
p2 = p1;
printf("p2: %d %c %s\n", p2.a, p2.b, p2.c);

// p3 apunta a p1
p3 = &p1;

// se copia *p3 a p4 y se imprime
p4 = *p3;
printf("p4: %d %c %s\n", p4.a, p4.b, p4.c);

       // Ahora modifico c en p4)
       p4.c[2] = 'z';

       // Compruebo p1... WTF QUE HA PASADO?
       
      printf("p1: %d %c %s\n", p1.a, p1.b, p1.c);

return 0;
}

Estas usando la misma cadena en las 4 estructuras. Si modificas un dato en una la modificaras en todas

Para copiar estructuras se tiene que hacer elemento a elemento. En el caso de los strings tienes que usar strcpy().

Saludos!

Depende, en C++ se puede definir un operador = específico para la estructura:

Código (cpp) [Seleccionar] Expandir

struct Tonteria
{
   int Miau;
   int* Cosa;

   Tonteria operator=(const Tonteria &t) // Operador =
   {
       Miau = t.Miau;
       *Cosa = *t.Cosa;

       return *this; // Devuelvo una referencia a la misma clase, esto me sirve para concatenar varios =
   }
};

Y ya podrías usar el operador = sin problemas:

Código (cpp) [Seleccionar] Expandir

Tonteria1 = Tonteria2;

[autonóma]

Ahora si que ya no me entero, entonces lo puedo eliminar? O hace que el ejecutable sea más rápido o algo?

Lo puedes eliminar y no lo debes eliminar.

Tu imagínate que tienes un gran proyecto que tardase en compilar 20 minutos. Si cada vez que tienes que cambiar una línea de código te tiras 20 minutos no llegas a ninguna parte.

Lo que se hace, es dividir el proyecto en varios archivos cpp. Cada archivo cpp se compila de forma autonóma, después se unén los archivos compilados (linker) y se forma el programa.

De este modo que si cambias una línea de código solo tendrías que compilar ese fichero cpp. Los archivos cpp compilados suelen tener extensión .o. No hay peligro en eliminarlos pero después tendrías que volver a compilarlos desde 0.

¿Cómo se hace un proyecto con varios archivos? En Codeblocks está chupado (File -> New Emply file y lo guardas con extensión .cpp). He aquí un ejemplo con 3 archivos (uno de cabecera hpp):

Main.cpp

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <map>
#include <vector>
#include <sstream>

// Archivo de declaraciones

#include "Funciones.hpp"

using namespace std;

typedef void (*Puntero_A_Funcion)(void);

int main()
{
   void (*Funcion)(void); // Puntero a funcion sin argumentos
   string Mensaje;
   map<string,Puntero_A_Funcion> Comandos;
   vector<string> texto;
   string str;

   Comandos["write"] = Escribir;
   Comandos["copy"] = Copiar;
   Comandos["cut"] = Cortar;
    Comandos["delete"] = Borrar;
    Comandos["Destroy"] = Destruir;
    Comandos["Kill"] = Matar;

   getline(cin, str);
   stringstream is(str);

   while(is >> str) texto.push_back(str);

   cout <<"Las palabras que pusiste son: " << endl;

   for (int i = 0; i < texto.size(); i++)
       cout << i + 1 << ". " << texto[i] << endl;

   cout << endl;

   for (int i = 0; i < texto.size(); i++)
   {
       Funcion = Comandos[texto[i]]; // Obtengo el puntero a la funcion correspondiente

       if (Funcion) // Si existe la funcion
             Funcion(); // llamar a la funcion
       else
            cout<<"Error, no existe el comando introducido: "<<texto[i]<<endl;
   }

   return 0;
}

Funciones.hpp

Código (cpp) [Seleccionar] Expandir


// Se le dice al compilador que este archivo es de "inclusión única"

#pragma once

// Prototipos de las funciones

void Copiar();
void Escribir();
void Cortar();
void Borrar();
void Destruir();
void Matar();


Funciones.cpp

Código (cpp) [Seleccionar] Expandir


// Incluimos el archivo con los prototipos

#include "Funciones.hpp"

// Definiendo las funciones

void Escribir()
{
   cout<<"Has escrito write"<<endl;
}

void Cortar()
{
   cout<<"Has escrito cortar"<<endl;
}

void Copiar()
{
   cout<<"Has escrito copiar"<<endl;
}

void Borrar()
{
   cout<<"Has escrito borrar"<<endl;
}

void Destruir()
{
    cout<<"has escrito destruir"<<endl;
}

void Matar()
{
    cout<<"has escrito matar"<<endl;
}