Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C++ > Compiling:)

Reply
Thread Tools

Compiling:)

 
 
joesoap
Guest
Posts: n/a
 
      08-20-2003
Hey

ok sorry I posted that message twice...Im trying to attach my code...but
Im having trouble!!!
Anyway here we go again...

Im trying to Implement this BitString.h class.(This class must be able
to manipulate a bit-string! A bit string is basically a string with only
'1's and '0's in it!

There are 4 constructors ( they convert a int,char,char*, and a double
all to a bitstring!

ok Now here's my problem.
First of all Im running Linux so Im using a gnu compiler(g++).
I have a test program called assignment2.C...I compile this and it gives
me a segmentation fault!!

I was wondering if anybody might know why.
The code should be attached..so feel free to check it out!!

joesoap

#include "BitString.h"


BitString::BitString(char * number)
{

nBitstring = 0;

for(int i = 0; ; i++)
{
if( number[i] == '\0')
{
break;
}
if((number[i] != '1') && (number[i] != '0'))
{
throw InvalidNumber();
}
nBitstring++;
}
bitstring = number;
}

BitString::BitString(int number)
{

int mod;
nBitstring = 0;

for (int i = 0; ; i++)
{

mod = number % 2;
number = number / 2;

if(mod == 0)
{
bitstring[i] = '\0';
bitstring[i] = '0';
nBitstring++;
}
if(mod == 1)
{
bitstring[i] = '\0';
bitstring[i] = '1';
nBitstring++;
}
if(number == 0)
{
bitstring[i] = '\0';
bitstring[i] = '1';
i++;
nBitstring++;
bitstring[i] = '\0';
break;
}

}

int count = nBitstring - 2;
char temp[count];

for(int i = 0; ;i++)
{
temp[i] = bitstring[count];
if(count == 0)
{
i++;
temp[i] = '\0';

break;
}
count--;
}

bitstring = temp;
//cout<<bitstring<<endl;


}

BitString::BitString(double number)
{
int first;
int last;
double temp1;
int mod;
nBitstring = 0;


first = (int)number;
temp1 = number - first;
last = (int)(temp1 * 100);

for (int i = 0; ; i++)
{

mod = first % 2;
first = first / 2;

if(mod == 0)
{

bitstring[i] = '\0';
bitstring[i] = '0';
nBitstring++;
}
if(mod == 1)
{

bitstring[i] = '\0';
bitstring[i] = '1';
nBitstring++;
}
if(first == 0)
{

bitstring[i] = '\0';
bitstring[i] = '1';
i++;
nBitstring++;
bitstring[i] = '\0';
break;
}

}

int count = nBitstring - 2;
char temp[count];

for(int i = 0; ;i++)
{
temp[i] = bitstring[count];
if(count == 0)
{
i++;
temp[i] = '\0';

break;
}
count--;
}
bitstring = temp;


bitstring[nBitstring-1] = '.';
nBitstring++;

//int dot = nBitstring;
bitstring[nBitstring-1] = '\0';



for (int i = nBitstring-1 ; ; i++)
{

mod = last % 2;
last = last / 2;


if(mod == 0)
{

bitstring[i] = '\0';
bitstring[i] = '0';
nBitstring++;
}
if(mod == 1)
{

bitstring[i] = '\0';
bitstring[i] = '1';
nBitstring++;
}
if(last == 0)
{

bitstring[i] = '\0';
bitstring[i] = '1';
i++;
nBitstring++;
bitstring[i] = '\0';
break;
}

}

//cout<<bitstring<<endl;
/*
int c = nBitstring -(dot+1);
cout<<c<<endl;
char t[c];

for(int i = c; ;i++)
{
t[i] = bitstring[c];
if(c == 0)
{
i++;
t[i] = '\0';

break;
}
c--;
}
bitstring = t;

cout<<bitstring<<endl;*/
}

BitString::BitString(char num)
{
char * a;
a = &num;
int mod;
int number = 0;
number = atoi(a);
if(number > 9)
cout<<"Only characters from 0 to 9 allowed"<<endl;
nBitstring = 0;

for (int i = 0; ; i++)
{

mod = number % 2;
number = number / 2;

if(mod == 0)
{
bitstring[i] = '\0';
bitstring[i] = '0';
nBitstring++;
}
if(mod == 1)
{
bitstring[i] = '\0';
bitstring[i] = '1';
nBitstring++;
}
if(number == 0)
{
bitstring[i] = '\0';
bitstring[i] = '1';
i++;
nBitstring++;
bitstring[i] = '\0';
break;
}

}

int count = nBitstring - 2;
char temp[count];

for(int i = 0; ;i++)
{
temp[i] = bitstring[count];
if(count == 0)
{
i++;
temp[i] = '\0';

break;
}
count--;
}

bitstring = temp;
//cout<<bitstring<<endl;
}


BitString:perator char()
{


}
BitString:perator int()
{}

BitString:perator char*()
{}

BitString:perator double()
{}

char* BitString:: get()
{
return bitstring;
}

int BitString::HammingDistance(BitString &number)
{throw InvalidNumber();}


istream &operator >>(istream & is , BitString &number)
{
return is;
}

ostream & operator << (ostream & os, BitString &number)
{

for(int i = 0; i < number.nBitstring ; i++)
{
os<<number.bitstring[i];

}

return os;
}

bool BitString:perator & (BitString & number)
{
for(int i = 0; i < number.nBitstring;i++)
{
if(bitstring[i] != number.bitstring[i])
{
return false;
}
else
{
return true;
}
}

}

bool BitString:perator & (int number)
{
BitString a(number);

for(int i = 0; i <a.nBitstring;i++)
{
if(bitstring[i] != a.bitstring[i])
{
return false;
}
else
{
return true;
}
}
}

bool BitString:perator & (double number)
{
BitString a(number);

for(int i = 0; i <a.nBitstring;i++)
{
if(bitstring[i] != a.bitstring[i])
{
return false;
}
else
{
return true;
}
}
}

bool BitString:perator & (char number)
{
BitString a(number);

for(int i = 0; i <a.nBitstring;i++)
{
if(bitstring[i] != a.bitstring[i])
{
return false;
}
else
{
return true;
}
}
}

bool BitString:perator & (char * number)
{
BitString a(number);

for(int i = 0; i <a.nBitstring;i++)
{
if(bitstring[i] != a.bitstring[i])
{
return false;
}
else
{
return true;
}
}
}

bool BitString:perator | (BitString & number)
{
for(int i = 0; i < number.nBitstring;i++)
{
if(bitstring[i] != number.bitstring[i])
{
return false;
}
else
{
return true;
}
}

}

bool BitString:perator | (int number)
{
BitString a(number);

for(int i = 0; i <a.nBitstring;i++)
{
if(bitstring[i] != a.bitstring[i])
{
return false;
}
else
{
return true;
}
}
}

bool BitString:perator | (double number)
{
BitString a(number);

for(int i = 0; i <a.nBitstring;i++)
{
if(bitstring[i] != a.bitstring[i])
{
return false;
}
else
{
return true;
}
}
}

bool BitString:perator | (char number)
{
BitString a(number);

for(int i = 0; i <a.nBitstring;i++)
{
if(bitstring[i] != a.bitstring[i])
{
return false;
}
else
{
return true;
}
}
}

bool BitString:perator | (char * number)
{
BitString a(number);

for(int i = 0; i <a.nBitstring;i++)
{
if(bitstring[i] != a.bitstring[i])
{
return false;
}
else
{
return true;
}
}
}

BitString BitString:perator ^ (BitString &number)
{ throw InvalidNumber();}

char &BitString:perator [] (int number)
{throw InvalidNumber();}

char BitString:perator [] (int number) const
{throw InvalidNumber();}

BitString BitString:perator + (int number)
{throw InvalidNumber();}

BitString BitString:perator + (double number)
{throw InvalidNumber();}

BitString BitString:perator + (char number)
{throw InvalidNumber();}

BitString BitString:perator + (char* number)
{throw InvalidNumber();}

BitString BitString:perator + (BitString &number)
{throw InvalidNumber();}

BitString BitString:perator += (int number)
{throw InvalidNumber();}

BitString BitString:perator += (double number)
{throw InvalidNumber();}

BitString BitString:perator += (char number)
{throw InvalidNumber();}

BitString BitString:perator += (char* number)
{throw InvalidNumber();}

BitString BitString:perator += (BitString &number)
{throw InvalidNumber();}

BitString BitString:perator - (int number)
{throw InvalidNumber();}

BitString BitString:perator - (double number)
{throw InvalidNumber();}

BitString BitString:perator - (char number)
{throw InvalidNumber();}

BitString BitString:perator - (char* number)
{throw InvalidNumber();}

BitString BitString:perator - (BitString &number)
{throw InvalidNumber();}

BitString BitString:perator -= (int number)
{throw InvalidNumber();}

BitString BitString:perator -= (double number)
{throw InvalidNumber();}

BitString BitString:perator -= (char number)
{throw InvalidNumber();}

BitString BitString:perator -= (char* number)
{throw InvalidNumber();}

BitString BitString:perator -= (BitString &number)
{throw InvalidNumber();}

BitString BitString:perator ~()
{throw InvalidNumber();}

BitString BitString:perator >> (BitString &number)
{throw InvalidNumber();}

BitString BitString:perator << (BitString &number)
{throw InvalidNumber();}


#ifndef BITSTRING_H
#define BITSTRING_H

#include <iostream>
#include <istream>
#include <cctype>
#include <cstdio>
#include <stdlib.h>
#include <string.h>



using namespace std;


class BitString
{

private:

char * bitstring;
int nBitstring;

public:

BitString(char *);
BitString(int);
BitString(double);
BitString(char );


class InvalidNumber{};

operator char();
operator int();
operator char*();
operator double();

char* get();
int HammingDistance(BitString &);


friend istream &operator >> (istream & , BitString &number);
friend ostream &operator << (ostream &,BitString &number);


bool operator & (BitString &);
bool operator & (int);
bool operator & (double);
bool operator & (char);
bool operator & (char *);

bool operator | (BitString &);
bool operator | (int);
bool operator | (double);
bool operator | (char);
bool operator | (char *);

BitString operator ^ (BitString &);

char &operator [] (int);
char operator [] (int) const;
BitString operator + (int);
BitString operator + (double);
BitString operator + (char);
BitString operator + (char *);
BitString operator + (BitString &);

BitString operator += (int);
BitString operator += (double);
BitString operator += (char);
BitString operator += (char *);
BitString operator += (BitString &);

BitString operator - (int);
BitString operator - (double);
BitString operator - (char);
BitString operator - (char *);
BitString operator - (BitString &);

BitString operator -= (int);
BitString operator -= (double);
BitString operator -= (char);
BitString operator -= (char *);
BitString operator -= (BitString &);

BitString operator ~();

BitString operator >> (BitString&);
BitString operator << (BitString&);
};
#endif


#include "BitString.h"
#include "BitString.C"
#include <iostream>
#include <cctype>
#include <cstdio>
#include <cstring>
#include <cstdlib>

using namespace std;

int main()
{

char *t = "100110";
int n = 123;

//try{
//BitString a(t);
//BitString b(n);
//BitString c(123.45);
BitString d('3');
//BitString e(t);

char test;

test = char(d);
//cout<<test<<endl;
cout<<d<<endl;

//}
//catch(BitString::InvalidNumber)
//{
//cout <<"Invalid Binary number, use only the numbers 0 and 1"<<endl;
//}

}

 
Reply With Quote
 
 
 
 
John Harrison
Guest
Posts: n/a
 
      08-20-2003
>
> Start slowly. Don't implement lots of functions and code and the
> wonder why there are lots of problems you can't sort out. Implement
> *one* function, test it and only after that start implementing
> the next one.
>


This is the very best advice that can be given to a newbie, but for some
reason newbies never want to follow it.

To the OP, takes this advice, take it slowly. If you rush to write lots of
code you'll get into a situation where you have lots of interlinked errors,
fixing one will uncover others, you'll never know where you are or why
things sometimes seem to work and sometimes don't, and you'll end up taking
three times are long as you need to.

john


 
Reply With Quote
 
 
 
 
Martin Piper
Guest
Posts: n/a
 
      08-20-2003
"John Harrison" <(E-Mail Removed)> wrote in message
news:bhvqkd$3oh1s$(E-Mail Removed)-berlin.de...
> >
> > Start slowly. Don't implement lots of functions and code and the
> > wonder why there are lots of problems you can't sort out. Implement
> > *one* function, test it and only after that start implementing
> > the next one.
> >

>
> This is the very best advice that can be given to a newbie, but for some
> reason newbies never want to follow it.
>
> To the OP, takes this advice, take it slowly. If you rush to write lots of
> code you'll get into a situation where you have lots of interlinked

errors,
> fixing one will uncover others, you'll never know where you are or why
> things sometimes seem to work and sometimes don't, and you'll end up

taking
> three times are long as you need to.


As a beginner myself I find that something complex is best
achieved in isolation, in otherwords; i'll start a new project
and develop the function to the parameters I want, testing the
output and then move it to the main project, where it's tested again
when compiled. And, this is probably a bad habit, but I compile the
module after every couple of lines of code, looking for syntax errors.

Keeps the ball juggling down to a minimum for me.


 
Reply With Quote
 
Agent Mulder
Guest
Posts: n/a
 
      08-20-2003
MP> this is probably a bad habit, but I compile the
MP> module after every couple of lines of code,
MP> looking for syntax errors.

Of course you do. As a beginner, you need to spend time on
your editor (vi). Access multiple files quick and easy. Load
them all at once in a script and use Ctrl-N and Ctrl-P or
whatever to jump from one to the next. Use F2 to compile
the file-under-the-cursor, use F3 to compile the whole
project, use F4 to remove all object files and executable etc.

-X


 
Reply With Quote
 
Mike Wahler
Guest
Posts: n/a
 
      08-20-2003

John Harrison <(E-Mail Removed)> wrote in message
news:bhvqkd$3oh1s$(E-Mail Removed)-berlin.de...
> >
> > Start slowly. Don't implement lots of functions and code and the
> > wonder why there are lots of problems you can't sort out. Implement
> > *one* function, test it and only after that start implementing
> > the next one.
> >

>
> This is the very best advice that can be given to a newbie, but for some
> reason newbies never want to follow it.
>
> To the OP, takes this advice, take it slowly. If you rush to write lots of
> code you'll get into a situation where you have lots of interlinked

errors,
> fixing one will uncover others, you'll never know where you are or why
> things sometimes seem to work and sometimes don't, and you'll end up

taking
> three times are long as you need to.


I'd like to add that John's advice does not only
apply to the novice. It's the way professionals
do it too. One Step At A Time. Don't add more
code until what you already have works correctly.

-Mike



 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off




Advertisments