na wstępię pragnę przeprosić jeśli ten temat wylądował tutaj a nie w webmasterstwie, ale prawde powiedziawszy nie wiem zbytnio gdzie go umiescic. Chwilow takze przepraszam za brak polskich znakow. Otoz usiluje napisac program ktory bede mogl za pomoca funkcji exec z php wywolac niniejszy programik. Problem pojawia sie w warunku. Otrzymuje komunikat od komiplatora odnosnie nie wlasciwej konwersji danych. Kod wyglada nastepujaco:
#include
#include
#include
void dane(int argc, char *argv[]);
int main(int argc, char *argv[])
{
dane(argc, argv);
getch();
}
void dane(int argc, char *argv[]){
using namespace std;
int ilosc;
int zasieg;
int wysokosc;
int szerokosc;
if(argc == 4){
int ilosc = static_cast(argv[0]);
/*int zasieg = static_cast(argv[1]);
int szerokosc = static_cast(argv[2]);
int wysokosc = static_cast(argv[3]);*/
}
ofstream outFile;
outFile.open("plik.txt");
outFile << ilosc+";";
outFile << zasieg+";";
outFile << szerokosc+";";
outFile << wysokosc;
outFile.close();
}
argv[0], argv[1], argv[2], argv[3] to wskaźniki na char (stringi), nie można ich więc zrzutować na int. To co Ty robisz, to rzutujesz ich adresy, co nie jest zgodne z zamierzeniem. Musisz skonwertować stringi do intów np.
DObra, wydaje mi sie ze uporalem sie z tym problemem. Mam teraz troche inne pytanie. Do funkcji przekazuje tablice za pomoca wskaznikow. Jak sprawdzic dlugosc takiej tablic?
Gdybyś używał tablic o stałym rozmiarze (np. int tab[N][2];), to można by użyć operatora sizeof. Ale jeżeli tab jest alokowany przez new, to jedyne co pozostaje, to przekazać rozmiar jako dodatkowy argument.
w takim razie jeszcze jedno pytanie. Jesli przekazuje cos przez wskaznik pracuje na nim. Czy jesli stworze nowa tablice w funkcji zostanie ona skasowana po zakonczeniu dzialania opwej funkcji, czy tez bede mogl sie dalej odwolac do owej zmiennej?
Nie wiem, czy dobrze zrozumiałem pytanie, więc odpowiem bardziej ogólnie:
#include
const unsigned int SIZE = 5;
void fun1(int *tab2);
int main() {
int *tab = new int[SIZE];
tab[0] = 7;
fun1(tab);
/* teraz tab wskazuje na fragment pamięci, w którym kiedyś była tablica */
std::cout << tab[0] << std::endl;
delete[] tab;
return 0;
}
void fun1(int *tab2) {
delete[] tab2;
tab2 = new int[SIZE];
/* została stworzona nowa tablica, ale wskaźnik tab2 jest lokalną kopią wskaźnika tab */
/* po wyjściu z tej funkcji stworzona tablica zostanie w pamięci, ale wskaźnik do niej zostanie stracony */
/* innymi słowy będzie to wyciek pamięci */
tab2[0] = 6;
}
Taki kod (przynajmniej u mnie) kompiluje się i wykonuje (na pozór) bez błędów. Ale wystarczy rzucić okiem na wynik z valgrinda (i na to, że zamiast 6 program wypisze 7):
$ valgrind ./test_cpp
==14918== Memcheck, a memory error detector
==14918== Copyright (C) 2002-2011, and GNU GPL'd, by Julian Seward et al.
==14918== Using Valgrind-3.7.0 and LibVEX; rerun with -h for copyright info
==14918== Command: ./test_cpp
==14918==
==14918== Invalid read of size 4
==14918== at 0x4008A4: main (test_cpp.cpp:12)
==14918== Address 0x5937040 is 0 bytes inside a block of size 20 free'd
==14918== at 0x4C284AC: operator delete[](void*) (in /usr/lib64/valgrind/vgpreload_memcheck-amd64-linux.so)
==14918== by 0x4008F7: fun1(int*) (test_cpp.cpp:18)
==14918== by 0x40089F: main (test_cpp.cpp:10)
==14918==
7
==14918== Invalid free() / delete / delete[] / realloc()
==14918== at 0x4C284AC: operator delete[](void*) (in /usr/lib64/valgrind/vgpreload_memcheck-amd64-linux.so)
==14918== by 0x4008D1: main (test_cpp.cpp:13)
==14918== Address 0x5937040 is 0 bytes inside a block of size 20 free'd
==14918== at 0x4C284AC: operator delete[](void*) (in /usr/lib64/valgrind/vgpreload_memcheck-amd64-linux.so)
==14918== by 0x4008F7: fun1(int*) (test_cpp.cpp:18)
==14918== by 0x40089F: main (test_cpp.cpp:10)
==14918==
==14918==
==14918== HEAP SUMMARY:
==14918== in use at exit: 20 bytes in 1 blocks
==14918== total heap usage: 2 allocs, 2 frees, 40 bytes allocated
==14918==
==14918== LEAK SUMMARY:
==14918== definitely lost: 20 bytes in 1 blocks
==14918== indirectly lost: 0 bytes in 0 blocks
==14918== possibly lost: 0 bytes in 0 blocks
==14918== still reachable: 0 bytes in 0 blocks
==14918== suppressed: 0 bytes in 0 blocks
==14918== Rerun with --leak-check=full to see details of leaked memory
==14918==
==14918== For counts of detected and suppressed errors, rerun with: -v
==14918== ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 6 from 6)
Wersja poprawna:
#include
const unsigned int SIZE = 5;
void fun1(int **tab2);
int main() {
int *tab = new int[SIZE];
tab[0] = 7;
fun1(&tab);
std::cout << tab[0] << std::endl;
delete[] tab;
return 0;
}
void fun1(int **tab2) { // tutaj tab2 jest wskaźnikiem na tab
delete[] *tab2;
*tab2 = new int[SIZE];
*tab2[0] = 6;
}
$ valgrind ./test_cpp
==14939== Memcheck, a memory error detector
==14939== Copyright (C) 2002-2011, and GNU GPL'd, by Julian Seward et al.
==14939== Using Valgrind-3.7.0 and LibVEX; rerun with -h for copyright info
==14939== Command: ./test_cpp
==14939==
6
==14939==
==14939== HEAP SUMMARY:
==14939== in use at exit: 0 bytes in 0 blocks
==14939== total heap usage: 2 allocs, 2 frees, 40 bytes allocated
==14939==
==14939== All heap blocks were freed -- no leaks are possible
==14939==
==14939== For counts of detected and suppressed errors, rerun with: -v
==14939== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 6 from 6)