CPP c弦切片和单元测试

Question

The point of this project is to build your own unit test and use c-strings.

The project: DNA Sequencing Strand

Here is an example of two DNA strands that match when overlapped:

Strand 1: ACGGACATAGTCATT
Strand 2:      CATAGTCATTTCATG
Combined: ACGGACATAGTCATTTCATG

I am at a loss when I try to implement the following:

Strand must have a method Strand substrand(size_t i, size_t j) const that returns a copy of the strand that starts at position i and ends at position j - 1 . Think “Python slice.”

update: I have recently answered my own question and updated the void test_substrand() and Strand Strand::substrand(size_t start, size_t end) const . I am getting a segmentation fault.

Here is my code so far with filename underneath its body.

void test_substrand()
{
    Strand s1;
    s1.setStrand("Hellow World");
    s1.substrand(1, 4);
    std::cout << "Substrand: " << s1.getStrand() << std::endl;
}

int main()
{
    test_substrand();
    return 0;
}

test.cpp

#ifndef _STRAND_H_
#define _STRAND_H_
#include <cstdlib>
#include <string>
#include <string>

class Strand
{
public:
  Strand();
  Strand(const char *src);
  ~Strand();
  Strand & operator=(const Strand &rhs);
  const char *getStrand() const;
  void setStrand(const char *strand);
  Strand & operator+=(const Strand &rhs);
  Strand operator+(const Strand &rhs) const;

  Strand substrand(size_t start, size_t end) const;

protected:
  char *mStrand;
};

#endif /* _STRAND_H_ */
/* Local Variables: */
/* mode:c++         */
/* End:             */

Strand.h

#include "Strand.h"
#include <cstring>
#include <string>

// default constructor
Strand::Strand()
  : mStrand(0)
{
}

// copy constructor
Strand::Strand(const char *src)
  : mStrand(0)
{
  *this = src;
}

// destructor
Strand::~Strand()
{
  if(mStrand != 0)
  {
    delete [] mStrand;
    mStrand = 0;
  }
}

// assignment operator
Strand &Strand::operator=(const Strand &rhs)
{
  setStrand(rhs.mStrand);
  return *this;
}

// Get Strand
const char *Strand::getStrand() const
{
  return mStrand;
}

// Set Strand
void Strand::setStrand(const char *strand)
{
  if(mStrand)
  {
    delete [] mStrand;
    mStrand = 0;
  }
  if(strand)
  {
    mStrand = new char [std::strlen(strand) + 1];
    std::strcpy(mStrand, strand);                 
  }
}

size_t Strand::size() const
{
  return mBases;
}

// operator +=
Strand &Strand::operator+=(const Strand &rhs)
{
  char *new_strand;
  new_strand = new char [std::strlen(mStrand) + std::strlen(rhs.mStrand) + 1];

  strcat(strcpy(new_strand, mStrand), rhs.mStrand); 

  setStrand(new_strand);
  delete [] new_strand;
  return *this;
}

// operator +
Strand Strand::operator+(const Strand &rhs) const
{
  Strand value;
  value = *this;
  value += rhs;
  return value;
}

// substrand "python" slice
Strand Strand::substrand(size_t start, size_t end) const
{
  size_t k, i, size;

  size = end - start;

  char *new_strand;
  new_strand = new char [size +1];
  for (k = start, i = 0; k < end; k++, i++)
  {
    new_strand[i] = mStrand[k];
  }

  new_strand[k] = 0;
  Strand setStrand(new_strand);
  delete [] new_strand;
  new_strand = 0;
  return setStrand;
}

Strand.cpp

Answer 1

There are two issues in the fixed code.

First, the testing functions ignores the result of substrand and always prints the original strand. This is the fixed code:

void test_substrand()
{
    Strand s1;
    s1.setStrand("Hellow World");
    Strand s2 = s1.substrand(1, 4);
    std::cout << "Substrand: " << s2.getStrand() << std::endl;
}

Second, your copy constructor had:

  *this = src;

It caused unlimited recursive calls to this copy constructor and the application crashed on stack exhaustion. This is a fix

Strand::Strand(const char *src)
  : mStrand(0)
{
   mStrand = new char [std::strlen(src)+ 1];
   std::strcpy(mStrand, src);
}