po ostatniej funkcji program nie wykonuje innych linijek kodu

0

Witam mam dziwny problem z funkcjami moją ostatnia funkcja w programie jest funkcji assignment ale niestety nie ważne co po niej napisze w main nic nie wyskakuje program sie kończy po funkcji assignment

 #include <iostream>

using namespace std;

int size_tab;
int tab[0];
int tab2[0];
int *wsk , *wsk2;

int what_size_tab/*jaki rozmiar tablicy*/( int k );
void assignment/*przypisanie*/( int size_tab , int k );

int main()
{
    for ( int k = 0 ; k < 2 ; k++)
    {
        size_tab = what_size_tab( k );
        cout << "rozmiar tablicy " << k+1 << " to " << size_tab << endl;

        if ( k == 0)
        {
            wsk = &size_tab;
            cout << "Wskaznik ma wartość " << *wsk << endl;
        }
        else if ( k == 1 )
        {
            wsk2 = &size_tab;
            cout << "Wskaznik ma wartość " << *wsk2 << endl;
        }
        //if ( k == 1 )
            //break;
        assignment( size_tab , k );
    }
    cout << "Wskaznik ma wartość: " << *wsk << endl;
    cout << "Wskaznik ma wartość: " << *wsk2 << endl;

    return 0;
}

//***************************************************************************

int what_size_tab/*jaki rozmiar tablict*/( int k )
{
    int size = 0;
    cout << "Podaj rozmiar tablicy " << k+1 << endl;
    cin >> size;
    return size;
}

//***************************************************************************

void assignment/*przypisanie*/( int size_tab , int k )
{
    cout << "Przypisujem wartości do tablicy " << k+1 << endl;

    for ( int i = 0 ; i < size_tab ; i++)
    {
        int number = 0;
        if ( k == 0 )
        {
            cin >> number;
            tab[i] = number;
        }
        else if ( k == 1 )
        {
            cin >> number;
            tab2[i] = number;
        }
    }
}

//***************************************************************************

Teraz wiem że jak chce drugi raz wpisać

cout << "Wskaznik ma wartość " << *wsk2 << endl; 

(nie ważne gdzie czy za for czy za funkcja) program tego nie chce pokazać

0

Co znaczy "kończy się"? Poza tym nie widzę tu nigdzie konstruktora new , w assignment przypisujesz wartości do 0-elementowej tablicy. Podejrzewam, że tu program po prostu wywala, gdyż używasz niedozwolonego miejsca w pamięci.

3
int tab[0];
int tab2[0]

W C++ statyczna tablica nie może mieć rozmiaru 0. To nawet nie powinno się kompilować. Potem np. robisz tak: tab[i] = number;. Ale przecież tab ma rozmiar 0! Nie można odwoływać się do żadnego elementu i bo go nie ma.

Wygląda to tak, jak byś myślał, że najpierw można zrobić tablicę bez rozmiaru a później jakoś go jednak uzyskać kiedy poda go użytkownik. To czego potrzebujesz to dynamiczna tablica, czyli w C++ std::vector.

0
==19200== Invalid read of size 4
==19200==    at 0x8048887: main (prog.cpp:34)
==19200==  Address 0x4 is not stack'd, malloc'd or (recently) free'd
==19200== 
==19200== 
==19200== Process terminating with default action of signal 11 (SIGSEGV)
==19200==  Access not within mapped region at address 0x4
==19200==    at 0x8048887: main (prog.cpp:34)
 

chodzi o linijkę
cout << "Wskaznik ma wartość: " << *wsk << endl;
tworzysz zmienną lokalną w forze:

     for ( int k = 0 ; k < 2 ; k++)
    {
        size_tab = what_size_tab( k );

a potem po wyjściu poza for'a odwołujesz się do niej. Niestety biedaczka już nie istnieje ...

0

Dzięki za porady ale jako że jestem początkujący to nie rozumiem wszystkiego
Heretyk Mor a przypadkiem nie jest tak ze wskaźniki mają cały czas tą wartość do której zostały przypisane i czy jak dam static do zmiennej size_tab to wystarczy.

Endrju a tu mam problem z deklarowanie tablic możesz mi powiedzieć jak mam zadeklarować lub gdzie to zrobić (w main czy może w funkcji )by była ona dostępna zawsze (program musi mi pamiętać te liczby które do niej wpisuje), i by to inny użytkownik podawał takiej tablicy rozmiar.

0

Wskaźnik jest to zmienna, a więc można zmienić wartość w czasie działania programu. Powiem ci jak to w twoim kodzie wygląda : tworzysz globalny wskaźnik i globalną zmienną size_tab , potem wchodzisz do pętli for , przypisujesz adres zmiennej size_tab do jednego i drugiego wskaźnika i gdy zmienisz zmienną size_tab to wartość zmieni się w obu wskaźnikach, gdyż wskazują na tą samą zmienną. Nie wiem czy to chciałeś osiągnąć w kodzie.

Static jest to określenie zmiennej, która wartość jest wspólna dla wszystkich instancji danej klasy, ty tu nie używasz klas, więc po co chciałbyś ją tu użyć?

Co do tworzenia tablic tablice dynamiczne tworzysz poprzez new typ_zmiennej[ilość_elementów] i wtedy kiedy ich nie potrzebujesz musisz zwolnić to miejsce w pamięci za pomocą delete[] nazwa_zmiennej tablicowej. Tyle że jeśli zmieniasz rozmiar częściej niż 1 raz to musisz przekopiować dane ze starej tablicy do nowej. Wygodnym rozwiązaniem jest tutaj tak jak napisał endrju vector, tam nie musisz nic tworzyć tylko dodajesz i usuwasz elementy "w locie".

1

Zapoznaj się z inkrementacją: http://4programmers.net/Forum/1101404

0

Witam poczytałem dalej Symfonie C++ i dowiedziałem się że jest coś takiego jak new i delete wiec trochę pozmieniałem program do tego co przeczytałem.

#include <iostream>

using namespace std;

int size_tab;

int *pointer_tab = new int[size_tab];                                           
int *pointer_tab2 = new int[size_tab];                                          
int *pointer_size_tab = new int;
int *pointer_size_tab2 = new int;

int what_size_tab/*jaki rozmiar tablicy*/( int k );
void assignment/*przypisanie*/( int size_tab , int k );
void to_write_out/*wypisac*/( int k );
int compare/*porównaie*/( int *pointer_size_tab , int *pointer_size_tab2 );       

int main()
{
    int result_compare_size = 0;

    for ( int k = 0 ; k < 2 ; k++)
    {
        size_tab = what_size_tab( k );
        cout << "rozmiar tablicy " << k+1 << " to " << size_tab << endl;

        if ( k == 0)
        {
            pointer_size_tab = &size_tab;
            cout << "Wskaznik ma wartość " << size_tab << endl;
            assignment( size_tab , k );
        }
        else if ( k == 1 )
        {
            pointer_size_tab2 = &size_tab;
            cout << "Wskaznik ma wartość " << size_tab << endl;
            assignment( size_tab , k );
        }
        to_write_out/*wypisanie*/( k );
    }
    result_compare_size = compare/*porównaie*/( pointer_size_tab , pointer_size_tab2 );
    cout << "wspolny rozmiar tablic to " << result_compare_size << endl;
    return 0;
}

//***************************************************************************

int what_size_tab/*jaki rozmiar tablict*/( int k )
{
    int size = 0;
    cout << "Podaj rozmiar tablicy " << k+1 << endl;
    cin >> size;
    return size;
}

//***************************************************************************

void assignment/*przypisanie*/( int size_tab , int k )
{
    cout << "Przypisujem wartości do tablicy " << k+1 << endl;

    for ( int i = 0 ; i < size_tab ; i++)
    {
        int number = 0;
        if ( k == 0 )
        {
            cin >> number;
            pointer_tab[i] = number;
        }
        else if ( k == 1 )
        {
            cin >> number;
            pointer_tab2[i] = number;
        }
    }
}

//***************************************************************************

void to_write_out/*wypisac*/( int k)
{
    for ( int i = 0 ; i < 3 ; ++i)
    {
        if ( k == 0)
            cout << "tablica" << i << " wartosc " << *(pointer_tab++) << "wskaznik rozmiar " << *pointer_size_tab << endl;
        else if ( k == 1)
            cout << "tablica" << i << " wartosc " << *(pointer_tab2++) << "wskaznik rozmiar " << *pointer_size_tab2 << endl;
    }
}

//***************************************************************************

int compare/*porównanie*/( int *pointer_size_tab , int *pointer_size_tab2 )
{
    cout << "rozmiar 1 tablicy " << *pointer_size_tab << "   rozmiar 2 tablicy " << *pointer_size_tab2 << endl;

    if (pointer_size_tab2 > pointer_size_tab)
    {
        return *pointer_size_tab;
    }
    else if (pointer_size_tab > pointer_size_tab2)
    {
        return *pointer_size_tab2;
    }
    else
    {
        return *pointer_size_tab;
    }
}
 

I mam teraz dziwny problem bo po wyjściu z petli for która jest w main w wskaźniku pointer_size_tab pointer_size_tab2 jest to samo więc obawiam się ze w pointer_tab i pointer_tab2 będą również te same wartości

0

A czy w ogóle rozumiesz swój kod ? Skoro nie jesteś czegoś pewien to znaczy, że nie do końca pojmujesz co się w nim dzieje. Obydwa wskaźniki do tablicy wskazują na różną wartość, tak przynajmniej wynika z kodu, ale pointer_size_tab i pointer_size_tab2 wskazują na tą samą zmienną i gdy zmieniasz wartość w size tab zmienia się wartość zarówno w pointer_size_tab i pointer_size_tab2. Operator new on tylko przypisuje nowy adres dla zmiennej, ale ty potem przypisujesz adres size_tab do obydwu wskaźników, efektem czego one wskazują na to samo. Wartość we wskaźniku jest stała bo jest nią adres do zmiennej a nie stan zmiennej w danym momencie. Wskaźnik tylko wskazuje na dany obiekt.

0

Nie do końca jeszcze rozumiem te wskaźniki. Dopiero jestem na tym rozdziale w Symfonii C++, ale mam jeszcze jedno pytanie to dlaczego wewnątrz funkcji for wskaźniki są takie jakie podałem. Pointer_size_tab i pointer_size_tab2 maja inne wartości takie jaki podałem. Czy jak np. zmienię ze jeden wskaźnik będzie na size_tab a do drugiego dam na m = size_tab i później z tego zrobię wskaźnik to będzie dobrze ( i oczywiście zrobię coś by do m tylko raz przypisywać wartość).

No chyba ze będę dwa razu wywoływał funkcji what_size_tab do każdego dam inna zmienna np size_tab1 i size_tab2(wsadzę tą cześć do )

if ( k == 0)
        {
            size_tab = what_size_tab( k );
            pointer_size_tab = &size_tab;
            cout << "Wskaznik ma wartość " << size_tab << endl;
            assignment( size_tab , k );
        }
        else if ( k == 1 )
        {
            size_tab1 = what_size_tab( k );
            pointer_size_tab2 = &size_tab;
            cout << "Wskaznik ma wartość " << size_tab << endl;
            assignment( size_tab , k );
        } 

I moje ostatnie pytanie czy z tak zadeklarowanego wskaźnika globalnie (jak w programie ) int *pointer_tab = new int[size_tab]; mogę korzystać w całym program będzie on widoczny w każdej funkcji nawet rozdzielonych?

0
 int *pointer_tab = new int[size_tab];

Globalne deklaracje są zbędne i często prowadzą do błędów.

operator[] indeksowania wymyślono, aby z niego korzystać.
Ustawiasz wskaźnik na tablicę, korzystaj z zapisu tablicowego.
Wtedy kod jest zdecydowanie czytelniejszy.

{
	int* tab_ptr = new int[SIZE]; // SIZE = 2

	for (int i = 0; i < SIZE; i++)
	{
		tab_ptr[i] = i + 1; // prawda, że czytelniej
	}

	for (int i = 0; i < SIZE; i++)
	{
		std::cout << *(tab_ptr++) << ' '; // tutaj jest jeszcze okryta pułapka
		// ponowna próba odczytania tablicy będzie możliwa po cofnięciu wskaźnika
	}

	// obecnie pokazuje za ostatni  element
	tab_ptr = tab_ptr - 2; // cofniecie wskaznika o dwa miejsca (początek tablicy)
	// można skorzystać z arytmetyki wskaźników, która nie przesuwa wskaźnika
	std::cout << *(tab_ptr + 1) << std::endl; // drugi element tablicy, ale wskaźnik nadal jest ustawiony na początek
}
0

Dobrze a możecie mi poradzić po co sięgnąć bo jak tu czytam to Symfonia chyba już jest przestarzała a chciałem jeszcze kupić pasje C++ i wideo kurs od zera do gier kodera ( ale nie po to by programować gry ). ale może wy mi coś poradzicie.

I jeszcze jedno czy możecie mi poradzić bo chodziło mi o to ze chciałem mieć w C++ jakieś narzędzie do tego ze jak w tablice wpisze swoje liczby to by to było widoczne w każdej funkcji i po przeczytaniu w Symfonii C++ rozdziału o wskaźnikach to myślałem ze tak będzie new i delate. Ale tak nie jest new mi działa tylko w obrębie for i jak mam tam funkcje ale jak wyjdne poza for to musiałby wszystko robić od nowa i wskaźniki też nie działają

1

Już pisałem, jak chcesz coś kupić, to kup książkę na czasie. Psja to jest wytłumaczenie jak może być zbudowana implementacja stl-a i parę innych rzeczy, ale jeśli nie znasz podstaw, szkoda na nią czasu, a tych podstaw nie poznasz dobrze z symfonii, bo po prostu jest stara i wiele rzeczy przez to tam opisanych może być niewłaściwych. Na początek proponuję Stroustrupa - tego

1

C++. Biblioteka standardowa. Podręcznik programisty. Wydanie II jako uzupełnienie wiedzy. Obszernie STL, algorytmy i więcej. C++11.

0

Programowanie. Teoria i praktyka z wykorzystaniem C++. Wydanie II poprawione
Język C++. Kompendium wiedzy
A która książka z tych była by lepsza do nauki C++(jak widzie Symfonie mogę odłożyć na regał)

Później jak już którąś przeczytam to zacznę C++. Biblioteka standardowa. Podręcznik programisty. Wydanie II

0

Ok trochę poprawiłem nie wszystko tak jak pisaliście ale dowiedziałem się ze do wskaźnika najlepiej przypisywać tylko jedna zmienna. Ale już po napisaniu całego kodu mam dziwny problem wskaźniki tablic sumują mi się tylko na pierwszej pozycji tablicy. Dziwne jest to że jak sprawdzam jakie wartości siedzą w danym wskaźniku to wszystko pasuje tylko nie mogą się zsumować.

#include <iostream>
#include <stdlib.h>

using namespace std;

int size_tab;
int size_tab2;

int *pointer_size_tab = new int;
int *pointer_size_tab2 = new int;

int *pointer_tab = new int[size_tab];                                                                           //pod wskaznikiem wsk_tab jest tablica z odpowiednim rozmiarem
int *pointer_tab2 = new int[size_tab2];                                                                         //pod wskaznikiem wsk_tab2 jest tablica z odpowiednim rozmiarem

int what_size_tab/*jaki rozmiar tablicy*/( int k );
int what_size_tab2/*jaki rozmiar tablicy*/( int k );
void assignment/*przypisanie*/( int size_tab , int size_tab2 , int k , int *pointer_tab , int *pointer_tab2 );
int compare/*porównaie*/( int *pointer_size_tab , int *pointer_size_tab2 );                                     //pointer(ang) == wskaźnik(pl)
void tab_sum_tab2/*sumowanie tab i tab2*/( int result_compare_size , int *pointer_tab , int *pointer_tab2 );

int main()
{
    int result_compare_size;

    for ( int k = 0 ; k < 2 ; k++)
    {
        if ( k == 0)
        {
            size_tab = what_size_tab( k );
            cout << "rozmiar tablicy " << k+1 << " to " << size_tab << endl;
            pointer_size_tab = &size_tab;
            //cout << "Wskaznik ma wartość " << size_tab << endl;
            assignment( size_tab , size_tab2 , k , pointer_tab , pointer_tab2 );
        }
        else if ( k == 1 )
        {
            size_tab2 = what_size_tab2( k );
            cout << "rozmiar tablicy " << k+1 << " to " << size_tab << endl;
            pointer_size_tab2 = &size_tab2;
            //cout << "Wskaznik ma wartość " << size_tab2 << endl;
            assignment( size_tab , size_tab2 , k , pointer_tab , pointer_tab2);
        }
    }
    result_compare_size = compare/*porównaie*/( pointer_size_tab , pointer_size_tab2 );
    cout << "wspolny rozmiar tablic to " << result_compare_size << endl;

    system("clear");

    tab_sum_tab2/*sumowanie tab i tab2*/( result_compare_size , pointer_tab , pointer_tab2 );
    return 0;
}

//***************************************************************************

int what_size_tab/*jaki rozmiar tablict*/( int k )
{
    int size = 0;
    cout << "Podaj rozmiar tablicy " << k+1 << " ";
    cin >> size;
    return size;
}

//***************************************************************************

int what_size_tab2/*jaki rozmiar tablicy*/( int k )
{
    int size1 = 0;
    cout << "Podaj rozmiar tablicy " << k+1 << " ";
    cin >> size1;
    return size1
            ;
}

//***************************************************************************

void assignment/*przypisanie*/( int size_tab , int size_tab2 , int k , int *pointer_tab , int *pointer_tab2 )
{
    //cout << "\nK wynosi: " << k << "\n" << endl;
    int number;

    if ( k == 0)
    {
        for ( int i = 0 ; i < size_tab ; i++)
        {
            cin >> number;
            pointer_tab[i] = number;
            cout << "tab[" << i << "] = " << pointer_tab[i] << endl;
        }
    }
    else if( k == 1)
    {
        for ( int i = 0 ; i < size_tab2 ; i++)
        {
            cin >> number;
            pointer_tab2[i] = number;
            cout << "tab[" << i << "] = " << pointer_tab2[i] << endl;
        }
    }
}

//***************************************************************************

int compare/*porównanie*/( int *pointer_size_tab , int *pointer_size_tab2 )
{
    //cout << "rozmiar 1 tablicy " << *pointer_size_tab << " rozmiar 2 tablicy " << *pointer_size_tab2 << endl;

    if (*pointer_size_tab2 > *pointer_size_tab)
    {
        //cout << "\nwartość pointer_size_tab opcja1 " << *pointer_size_tab << "\n" << endl;
        return *pointer_size_tab;
    }
    else if (*pointer_size_tab > *pointer_size_tab2)
    {
        //cout << "\nwartość pointer_size_tab opcja2 " << *pointer_size_tab2 << "\n" << endl;
        return *pointer_size_tab2;
    }
    else
    {
        //cout << "\nwartość pointer_size_tab opcja3 " << *pointer_size_tab << "\n" << endl;
        return *pointer_size_tab;
    }
}

//**************************************************************************

void tab_sum_tab2/*sumowanie tab i tab2*/( int result_compare_size , int *pointer_tab , int *pointer_tab2 )
{
    int result_sum = 0;

    for ( int i = 0 ; i < result_compare_size ; i++ )
    {
        result_sum = pointer_tab[i] + pointer_tab2[i];

        cout << "sumowanie " << result_sum << endl;
        cout << "wastość tab 1 " << *pointer_tab << " wartosc tab2 " << *pointer_tab2 << endl;

        cout << "\ntab[" << i << "](" << *(pointer_tab++) << ") + tab2[" << i << "](" << *(pointer_tab2++) << ") = tab3[" << i << "](" << result_sum << ")" << endl;
    }
}
 
0

Przecież to co zrobiłeś teraz niewiele się różni od tego co było poprzednio.

Zmienne globalne:

int size_tab;
int size_tab2;

Mają z definicji wartość 0.

Potem robisz tak:

int *pointer_tab = new int[size_tab];
int *pointer_tab2 = new int[size_tab2]; 

WTF! Alokujesz dwie tablice o rozmiarze zero każda.

Jaki to ma sens?

A w ogóle to co po Ci to:

int *pointer_size_tab = new int;
int *pointer_size_tab2 = new int;

Patrz. Najpierw musisz wczytać liczbę elementów od użytkownika a dopiero potem alokować cokolwiek.

Nie używaj new []. Używaj std::vector. Nie używaj zmiennych globalnych. W ogóle. Nie są Ci do niczego potrzebne.

Przy okazji, nie pisz w ten sposób:

int what_size_tab/*jaki rozmiar tablicy*/( int k );

Tego się nie da czytać. Komentarz powinien być powyżej funkcji, ewentualnie jak bardzo chcesz to po prawej.

0

myślałem ze new jest dobre do dynamicznych tablic tak był w Symfonii wiem że jest przestarzała i mam zamiar kupić inna książkę ale mam pytanie to znaczy ze teraz już większość programistów nie używa new i delate. Teraz to już mam trochę mętlik :D

0

std::vector

Jeśli na siłę chcesz korzystać ze wskaźników to smart pointery (std::shared_ptr<>, std::unique_ptr<>, itp.

0

Wiesz ja nawet jeszcze nie przeczytałem Symfonii więc to co piszecie to ciężko mi zastosować. Na stronach których znajduje są tylko schematy i nie wiem jak je ugryź. Po przeczytanie Symfonii zajmę się książka która polecił mi Kaczus, więc mam nadzieje że tam to wszystko będzie. Na razie chciałbym by ten problem udało mi się rozwiązać przy pomocy tego co się uczę.

0
std::vector<int> vect(10); // dynamiczna tablica 10 elem
vect[0] = 1; // odwołuje się do komórek kontenera jak do zwykłej tablicy
std::cout << vect[0] << '\n'; 

Nic więcej nie potrzeba. Kontener sam alokuje i zwalnia pamięć.

Oprócz tego biblioteka STL udostępnia mnóstwo funkcji do obsługi kontenerów.
Wystarczy trochę obycia z nimi.
Jest dość intuicyjna. Funkcje i metody powtarzają się dla większości kontenerów.

1 użytkowników online, w tym zalogowanych: 0, gości: 1