C++ 템플릿 클래스 My_vec

Question

저는 학생이며 C++의 배열에 정적 라이브러리를 사용하고 있습니다. 따라서 수업을 할 때마다 코드를 다시 작성할 필요가 없습니다.

저는 중등 학교에서 2 학년에 있습니다. 그래서 저는 전문가가 아닙니다. 내 코드가 모든 유형 (int, float, ecc.)과 호환되기를 원하지만 몇 가지 문제가 있습니다.

내 코드를 살펴볼 수 있습니까?

나는이 페이지를 보았다 : Template (C++) - not sure if correct

My_vec.h

/*template My_vec.h 
Ben Burk 
Header file for a vector data structure. 
*/ 

#include <ostream> 

using namespace std; 

template <typename T> class My_vec 
{ 
    //member variables 
    int size, capacity; 
    T *ptr; 

public: 
    //member functions 
    template <typename T> My_vec<T>::My_vec() 
    { 
     size = 0; capacity = 10; 
     ptr = new T[capacity]; 
    } 
    template <typename T> My_vec<T>::My_vec(const My_vec<T>& vec) 
    { 
     if (!vec.is_empty()) 
     { 
      size = vec.size; 
      capacity = vec.capacity; 
      ptr = new T[capacity]; 

      for (int i = 0; i < capacity; i++) 
       ptr[i] = vec.ptr[i]; 
     } 
    } 
    template <typename T> My_vec<T>::~My_vec() 
    { 
     delete[] ptr; 
    } 
    template <typename T> My_vec<T>& My_vec<T>::operator=(const My_vec<T>& vec) 
    { 
     if (this == &vec) 
      return *this; 

     this->size = vec.size; this->capacity = vec.capacity; 
     this->ptr = new T[vec.capacity]; 

     for (int i = 0; i < this->capacity; i++) 
      this->ptr[i] = vec.ptr[i]; 
    } 
    template <typename T> int My_vec<T>::get_size() const 
    { 
     return size; 
    } 
    template <typename T> int My_vec<T>::get_capacity() const 
    { 
     return capacity; 
    } 
    template <typename T> T& My_vec<T>::operator[](int i) const 
    { 
     if (i < 0 || i > capacity) 
     { 
      try { throw i; } 
      catch (int e) 
      { 
       cerr << "An exception occurred at index: " << e << '\n'; 
       cerr << "Index out of bounds\n"; 

      } 
     } 
     else 
     { 
      return ptr[i]; 
     } 
    } 
    template <typename T> T& My_vec<T>::operator[](int i) 
    { 
     if (i < 0 || i > capacity) 
     { 
      try { throw i; } 
      catch (int e) 
      { 
       cerr << "An exception occurred at index: " << e << '\n'; 
       cerr << "Index out of bounds!\n"; 
      } 
     } 
     else 
     { 
      return ptr[i]; 
     } 
    } 
    template <typename T> bool My_vec<T>::is_empty() const 
    { 
     return (size == 0) ? 1 : 0; 
    } 
    template <typename T> T& My_vec<T>::elem_at_rank(int r) const 
    { 
     if (r <= 0 || r > capacity) 
     { 
      try { throw r; } 
      catch (int e) 
      { 
       cerr << "An exception occurred at rank: " << e << '\n'; 
       cerr << "Element could not be found!\n"; 
      } 
     } 
     else 
      return ptr[r-1]; 
    } 
    template <typename T> void My_vec<T>::insert_at_rank(int r, const T& elem) 
    { 
     if (r <= 0 || r > capacity) 
     { 
      try { throw r; } 
      catch (int e) 
      { 
       cerr << "An exception occurred at rank: " << e << '\n'; 
       cerr << "Element could not be inserted!\n"; 
      } 
     } 
     else 
     { 
      if (size + 1 > capacity) 
      { 
       capacity *= 2; 
       ptr = new T[capacity]; 
      } 
      size++; 

      for (int i = size - 1; i > r - 1; i--) 
      { 
       ptr[i] = ptr[i-1]; 
      } 
      ptr[r-1] = elem; 
     } 
    } 
    template <typename T> void My_vec<T>::replace_at_rank(int r, const T& elem) 
    { 
     if (r <= 0 || r > capacity) 
     { 
      try { throw r; } 
      catch (int e) 
      { 
       cerr << "An exception occurred at rank: " << e << '\n'; 
       cerr << "Element could not be replaced!\n"; 
      } 
     } 
     else 
     { 
      if (ptr[r-1] == NULL) 
       size++; 

      ptr[r-1] = elem; 
     } 
    } 
    template <typename T> void My_vec<T>::remove_at_rank(int r) 
    { 
     if (r <= 0 || r > capacity) 
     { 
      try { throw r; } 
      catch (int e) 
      { 
       cerr << "An exception occurred at rank: " << e << '\n'; 
       cerr << "Element could not be removed!\n"; 
      } 
     } 
     else 
     { 
      for (int i = r-1; i < size; i++) 
      { 
       ptr[i] = ptr[i+1]; 
      } 
      size--; 
     } 
    } 
}; 

ostream& operator<<(ostream& out, const My_vec<T>& vec); 
int find_max_index(const My_vec<T>& v, int size); 
void sort_max(My_vec<T>& vec); 

My_vec.cpp

#include <iostream> 
#include "My_vec.h" 

using namespace std; 

ostream& operator<<(ostream& out, const My_vec<T>& vec) 
{ 
    out << "<"; 
    for (int x = 0; x < vec.get_capacity()-1; x++) 
     out << vec[x] << ","; 
    out << vec[vec.get_capacity()-1]; 
    out << ">\n"; 
} 
int find_max_index(const My_vec<T>& v, int size) 
{ 
    int i = -1; 
    for (int x = 0; x < v.get_size(); x++) 
    { 
     if (v[x+1] > v[x]) 
      i = x+1; 
    } 
    return i; 
} 
void sort_max(My_vec<T>& vec) 
{ 
    T c = NULL; 
    for (int a = 0; a < vec.get_capacity(); a++) 
    { 
     for (int x = 0; x < vec.get_capacity()-1; x++) 
     { 
      if (vec[x+1] < vec[x]) 
      { 
       c = vec[x]; vec[x] = vec[x+1]; vec[x+1] = c; 
      } 
     } 
    } 
} 

편집 : 나는 데 문제가 컴파일 다음 파일들. 내 임무는 여러 변수 유형 char, int, double을 취할 수있는 클래스를 만드는 것입니다. 제 질문은 왜이 프로그램을 컴파일 할 수 없습니까?

Answer 1

1. 클래스 내부에서 My_vect :: 템플릿을 제거하십시오.
2. 전역 함수 템플릿을 기능화합니다. 그렇지 않으면 매개 변수로 템플릿 클래스를 사용할 수 없습니다. 그들의 구현을 헤더 파일에 넣는다.
3. 더 이상 코드가 없으므로 My_vec.cpp를 삭제하십시오.

헤더 파일은 다음과 같아야합니다

/*template My_vec.h 
Ben Burk 
Header file for a vector data structure. 
*/ 

#include <iostream> 

using namespace std; 

template <typename T> class My_vec 
{ 
    //member variables 
    int size, capacity; 
    T *ptr; 

public: 
    //member functions 
    My_vec() 
    { 
     size = 0; capacity = 10; 
     ptr = new T[capacity]; 
    } 

    My_vec(const My_vec<T>& vec) 
    { 
     if (!vec.is_empty()) 
     { 
      size = vec.size; 
      capacity = vec.capacity; 
      ptr = new T[capacity]; 

      for (int i = 0; i < capacity; i++) 
       ptr[i] = vec.ptr[i]; 
     } 
    } 

    ~My_vec() 
    { 
     delete[] ptr; 
    } 

    My_vec& operator=(const My_vec<T>& vec) 
    { 
     if (this == &vec) 
      return *this; 

     this->size = vec.size; this->capacity = vec.capacity; 
     this->ptr = new T[vec.capacity]; 

     for (int i = 0; i < this->capacity; i++) 
      this->ptr[i] = vec.ptr[i]; 
    } 

    int get_size() const 
    { 
     return size; 
    } 

    int get_capacity() const 
    { 
     return capacity; 
    } 

    T &operator[](int i) const 
    { 
     if (i < 0 || i > capacity) 
     { 
      try { throw i; } 
      catch (int e) 
      { 
       cerr << "An exception occurred at index: " << e << '\n'; 
       cerr << "Index out of bounds\n"; 

      } 
     } 
     else 
     { 
      return ptr[i]; 
     } 
    } 

    T &operator[](int i) 
    { 
     if (i < 0 || i > capacity) 
     { 
      try { throw i; } 
      catch (int e) 
      { 
       cerr << "An exception occurred at index: " << e << '\n'; 
       cerr << "Index out of bounds!\n"; 
      } 
     } 
     else 
     { 
      return ptr[i]; 
     } 
    } 

    bool is_empty() const 
    { 
     return (size == 0) ? 1 : 0; 
    } 

    T& elem_at_rank(int r) const 
    { 
     if (r <= 0 || r > capacity) 
     { 
      try { throw r; } 
      catch (int e) 
      { 
       cerr << "An exception occurred at rank: " << e << '\n'; 
       cerr << "Element could not be found!\n"; 
      } 
     } 
     else 
      return ptr[r - 1]; 
    } 

    void insert_at_rank(int r, const T& elem) 
    { 
     if (r <= 0 || r > capacity) 
     { 
      try { throw r; } 
      catch (int e) 
      { 
       cerr << "An exception occurred at rank: " << e << '\n'; 
       cerr << "Element could not be inserted!\n"; 
      } 
     } 
     else 
     { 
      if (size + 1 > capacity) 
      { 
       capacity *= 2; 
       ptr = new T[capacity]; 
      } 
      size++; 

      for (int i = size - 1; i > r - 1; i--) 
      { 
       ptr[i] = ptr[i - 1]; 
      } 
      ptr[r - 1] = elem; 
     } 
    } 

    void replace_at_rank(int r, const T& elem) 
    { 
     if (r <= 0 || r > capacity) 
     { 
      try { throw r; } 
      catch (int e) 
      { 
       cerr << "An exception occurred at rank: " << e << '\n'; 
       cerr << "Element could not be replaced!\n"; 
      } 
     } 
     else 
     { 
      if (ptr[r - 1] == NULL) 
       size++; 

      ptr[r - 1] = elem; 
     } 
    } 

    void remove_at_rank(int r) 
    { 
     if (r <= 0 || r > capacity) 
     { 
      try { throw r; } 
      catch (int e) 
      { 
       cerr << "An exception occurred at rank: " << e << '\n'; 
       cerr << "Element could not be removed!\n"; 
      } 
     } 
     else 
     { 
      for (int i = r - 1; i < size; i++) 
      { 
       ptr[i] = ptr[i + 1]; 
      } 
      size--; 
     } 
    } 
}; 

template <typename T> 
ostream& operator<<(ostream& out, const My_vec<T>& vec) 
{ 
    out << "<"; 
    for (int x = 0; x < vec.get_capacity() - 1; x++) 
     out << vec[x] << ","; 
    out << vec[vec.get_capacity() - 1]; 
    out << ">\n"; 
} 

template <typename T> 
int find_max_index(const My_vec<T>& v, int size) 
{ 
    int i = -1; 
    for (int x = 0; x < v.get_size(); x++) 
    { 
     if (v[x + 1] > v[x]) 
      i = x + 1; 
    } 
    return i; 
} 

template <typename T> 
void sort_max(My_vec<T>& vec) 
{ 
    T c = NULL; 
    for (int a = 0; a < vec.get_capacity(); a++) 
    { 
     for (int x = 0; x < vec.get_capacity() - 1; x++) 
     { 
      if (vec[x + 1] < vec[x]) 
      { 
       c = vec[x]; vec[x] = vec[x + 1]; vec[x + 1] = c; 
      } 
     } 
    } 
} 

을 나는 그것이 시작 것 같아요,하지만 할 수있는 청소의 예를 들어, 많은 여전히있다 :

1. 당신은 사용해서는 안가 헤더 파일에서 네임 스페이스를 사용합니다.

2. 이것은 무엇입니까?

   try { throw r; } 
       catch (int e) 
       { 
        cerr << "An exception occurred at rank: " << e << '\n'; 
        cerr << "Element could not be found!\n"; 
       } 
   

   이와 같은 예외를 사용하는 것은 의미가 없습니다.

3. operator [] (int i) const function. 반환 할 const T & 대신 T &