Definicja Pola o zmiennym rozmiarze

0

Witam, mam pytanie odnośnie definicji Pola o rozmiarze dynamicznym, tzn chce aby pole dla roznych obiektów tej samej klasy miało rózne rozmiary mianowicie chodzi mi o coś takiego:

 

#include <iostream>
#include <fstream>
using namespace std;


//Naglowki funkcji
int *TabDynam(int n);//Funkcja tworzy tablice dynamiczna o wymiarze n

//Struktury

struct tablice//struktura przechowujaca wczytane ciagi
{  int n;//dlugosc tablicy
   int *T=TabDynam(n);//TO POLE !!!!!
   ~tablice()// dealokacja pamieci
   {
       delete[]T;
   }
};
tablice *TabDynamTab(int n);//tworzy tablice struktury o nazwie tablice
int *przeciecia (tablice Tab[]);//szukanie przeciec ciagow
int main()
{   int n;
    char nazwa[100];
    //wczytywanie danych z pliku
    printf("Podaj nazwe pliku do wczytania:");
    scanf("%s",nazwa);
    FILE *pf=fopen(nazwa,"r");
    fscanf(pf,"%d",&n);//wczytanie ilosci ciagow
    tablice *op=TabDynamTab(n);//wskaznik na strukture tablice oraz utworzenie ilosci struktur rownej ilosci ciagow
    for (int i=0;i<n;i++)
    {
    fscanf(pf,"%d",&op[i].n);//wczytywanie ciagow
        for(int j=0;j<op[i].n;j++)
            {
    fscanf(pf,"%d",&op[i].T[j]);

            }

    }



    for (int i=0;i<n;i++)
{
    for (int j=0;j<op[i].n;j++)
{


cout<<(op[i].T[j]);
}
cout<<endl;
}

przeciecia(op);



}
//FUNKCJE
int *TabDynam(int n)
{
int *T=new int[n];
    return(T);
}


tablice *TabDynamTab(int n)
{
tablice *T=new tablice[n];
return(T);
}
int *przeciecia(tablice Tab[])
{
    int i=0,j=0,z=0,k=0;//i=iterator 1 tablicy j= iterator2 tablicy,z=iterator tablicy przeciec, k rozmiart tej tablicy
        if (Tab[0].n>=Tab[1].n)//szukanie rozmairu dla tablicy przeciec
        {
            k=Tab[0].n;
        }
        else
        {
            k=Tab[1].n;
        }
cout<<k;
       int *Tablica=TabDynam(k);//tablica na wartosci przeciec
       int *Tablica1=TabDynam(k);//tabica na ideksy i
       int *Tablica2=TabDynam(k);//tablica na ideksy j


    do{
        if (Tab[0].T[i]>Tab[1].T[j])
        {
               if(j<=sizeof(Tab[1].T)/4)
        {


            j++;
            cout<<"a2";
        }
        }
           else if (Tab[0].T[i]==Tab[1].T[j])
        {
           Tablica[z]=Tab[0].T[i];
           Tablica1[z]=i;
           Tablica2[z]=j;
           z++;

           i++;

           j++;
           cout<<"b3";
        }

        else if (Tab[0].T[i]<Tab[1].T[j])
        {
            if(i<=sizeof(Tab[0].T)/4)
            {


            i++;
            cout<<"c1";
        }
        }

       } while((i!=sizeof(Tab[0].T)/4) && (j!=sizeof(Tab[1].T)/4));




return(Tablica);
}

Problem pojawia się po wywołaniu funkcji przeciecia. Domyslam sie ze moze byc to blad spowodowany bledna definicja pola, ale być może błąd pojawia sie gdzieś indziej, za każda pomoc z gory dziekuje.

0

Zawsze możesz zasymulować tablicę dynamiczną.

kod funkcji z pewnej klasy:

void ttab::resize(int newSize)
{
    double * newTab = new double[newSize];
    length = newSize < length ? newSize : length;
    for(int i = 0; i < length; i++)
        newTab[i] = tab[i];
    if(tab)
        delete [] tab;
    tab = newTab;
    length = newSize;
}
 

Gdzie tab to tablica, length to długość tablicy.

1

Może da się użyć std::vector ?

#include <iostream>
#include <iterator>
#include <fstream>
#include <vector>
#include <algorithm>

int main() {
	std::ifstream is("ciag.txt");
	if(!is) {
		fprintf(stderr,"BRAK PLIKU\n");
		exit(EXIT_FAILURE);
	}
	std::istream_iterator<int> start(is), end;
	std::vector<int> numbers(start, end);

	for(auto & num : numbers)
		std::cout << num << " ";
	std::cout << std::endl;
}

http://ideone.com/jfNzTP

0

niestety, musze dzialac na tablicach.

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

#define RES_MULTIPLIER 2

typedef struct _IntVector {
	unsigned capacity;
	unsigned count;
	int* data;
} IntVector;

void resize(IntVector* vec) {
	vec->capacity = vec->capacity ? vec->capacity * RES_MULTIPLIER : RES_MULTIPLIER;
	vec->data = (int*)realloc(vec->data, vec->capacity * sizeof(int));
	if(!vec->data) exit(-1);
}

void insert(IntVector* vec, int data) {
	if(vec->count >= vec->capacity) {
		resize(vec);
	}
	vec->data[vec->count++] = data;
}

void destroy(IntVector* vec) {
	free(vec->data);
	memset(vec, 0, sizeof(IntVector));
}

int main() {
	IntVector vec;
	memset(&vec, 0, sizeof(IntVector));
	int tmp_data;
	while(scanf("%d", &tmp_data)) {
		insert(&vec, tmp_data);
	}
	printf("%u", vec.count);
	destroy(&vec);
	return 0;
}
0

Kopiesz ręcznie mając do dyspozycji koparkę ;)
Jak używasz C++ to masz 2 rodzaje tablic - pierwsza o rozmiarze znanym podczas kompilacji

 
std::array< int, 10 > temp;

i tablica dynamiczna której rozmiar zmienia się automatycznie podczas działania programu

 
std::vector< int > temp;

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