Newsgroup: it.comp.lang.c++
Titolo: Dubbio

C++ it means "a function with no arguments."
Questa mi giunge nuova. In C il numero di argomenti variabile non si indica
con (...) ?
Massimo

con (...) ?
Non solo, e' in C++ che si indica necessariamente cosi'.
In C non e' necessario specificarlo, si assume per default un numero
variabile di argomenti.
--
Andrea Laforgia (ICQ 87230455)
http://www.geocities.com/AndreaLaforgia
"ci sono tre tipi di persone nel mondo : quelli che
 sono bravi in matematica e quelli che non lo sono."

 variabile di argomenti.
Ma da quanto tempo ?
Perché libri sul C che ho comprato e letto fino a uno/due anni fa (prima di
iniziare col C++) non hanno *MAI* parlato di argomenti variabili, la lista
di argomenti vuoti è sempre stata presentata come equivalente a f(void)...
Massimo

Attento che per argomenti variabili non si intende quello che si
gestisce con le macro va..., quanto il fatto che il compilatore e'
libero di non controllare che il numero di argomenti passati sia lo
stesso di quelli dichiarati.
Ciao,
Nicola

non si indica con (...) ?
Con
   int f(int x,...);
tu dici al compilatore che la funzione accetta un numero
variabile di argomenti (un intero e altri ignoti).
Invece con
   int f();
tu dichiari (in "C") di non voler dire al compilatore
quali sono gli argomenti della funzione f. E' una cosa
molto diversa (e brutta :) )
La dichiarazione 
   int f(...);
non ha molto senso... come si farebbe ad accedere ai
parametri variabili ? Come potrebbe la funzione capire
che non e' stato passato *alcun* parametro ?
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

 ha scritto nel messaggio
news:3A89470E...@divalsim.it...

Ah, ecco, c'era qualcosa...
Non la sapevo questa però, è possibile evitare in blocco il controllo dei
tipi soltanto svuotando le parentesi ?!?
Massimo

Mi piacerebbe sapere cosa accadrebbe in un caso come questo.
Ho una banalissima classe con un membro privato, divisa in due files:
// myclass.h
class myclass
{
private:
    int x;
public:
    void setx(int);
    int getx(void);
};
// myclass.cpp
#include "myclass.h"
void myclass::setx(int n)
{
    if(n >= 0)
        x = n;
    return;
}
int myclass::getx(void)
{
    return(x);
}
Compilo il file myclass.cpp, creando un file oggetto (ad esempio myclass.o).
A questo punto, includendo myclass.h in un file, compilando e linkando con
myclass.o, posso utilizzare la classe myclass e non ho accesso al membro
privato x, ad esempio in questo caso l'accesso ristretto impedisce che x
assuma un valore negativo.
Dopodiché, creo il seguente programma:
// main.cpp
#include <iostream>
using namespace std;
// notare che non viene incluso myclass.h
class myclass
{
public:
    int x;    // dichiaro x come public
    void setx(int);
    int getx(void);
};
int main(int argc,char **argv)
{
    myclass c;
    c.setx(3);
    cout << c.getx();    // stampa 3
    c.setx(-4);
    cout << c.getx();    // stampa sempre 3
    c.x = -4;    // funziona ?
    cout << c.getx()    //    cosa stampa ?
    return(0);
}
Il Visual C++ 6.0 non segnala alcun errore e stama "3", "3" e "-4".
Cosa dice lo standard al riguardo (se dice qualcosa) ?
Massimo

Cosa dice lo standard al riguardo (se dice qualcosa) ?
Stai violando la ODR. Hai dato definizioni non equivalenti
di una stessa entita' e quindi potrebbe succedere di *tutto*.
Nota che i compilatori *non* sono obbligati ad accorgersi che
stai facendo casino (potrebbe essere molto complicato
rilevare il problema visto che un compilatore vede una
compilation unit per volta).
Purtroppo a volte quello che hai descritto capita senza
volere (ad esempio se definisci una classe "di appoggio"
direttamente in un .cpp e la usi in quel contesto senza
sapere che un altro modulo - scritto da qualcun altro -
ha definito una propria classe di appoggio, definita
diversamente, che ha lo stesso nome).
Questa e' una delle ragioni per cui gli "unnamed namespace"
non sono sostituibili con l'uso di "static".
Credo ci sia stato un thread su questo argomento un paio
di mesi fa.


In C si. In C++ no.
Ciao,
Nicola