Print

Please login or register.
1 Hour 1 Day 1 Week 1 Month Forever
Login with username, password and session length

Control Flow

2 (2.2%)

Arrays, Strings, Pointers, and References

8 (9%)

Functions

4 (4.5%)

Basic object-oriented programming

30 (33.7%)

A bit more advanced OOP (Composition, Operator overloading, Inheritance, Virtual Functions)

18 (20.2%)

Templates

8 (9%)

Other (Explain)

4 (4.5%)

Working with files?  (Streams)

15 (16.9%)

Total Members Voted: 89

[lordnincompoop]

Hm. A profiler goes with an IDE? I can't find any for my Geany.

Also, well, I might have found a critical bottleneck (or something) in my very idea. Can somebody tell me if any shenanigans are involved in compiling code written on Linux, on Windows? Especially if it involves SDL.

Also, is there any advantage in using short over integer, even if hypothetical?

Yes. It saves on memory space.

[Virex]

Some other operations, like division may also require less cycles if you're using a short.

[Supermikhail]

Yeah, finally bothered with a sizeof program. short is 2 bytes, int is 4 and long is 8 on my computer.

In other news, segfault has finally caught up with me, what do you know! Now I'm looking for a way to store a string of characters so that I could write it together with the rest of an object to a binary file. If I make it a char array with fixed length, it just doesn't compile, because sometimes it's apparently still just a pointer whatever I do.

For anybody curious or incredulous:

Code: [Select]

#include <iostream>
using namespace std;

class Element
{
public:
Element() {}
~Element() {}

Element(char[], short, double , short[] , short );

void DisplayName() const;
short GetNumber() const { return itsNumber; }
double GetElectronegativity() const { return itsElectronegativity; }
short GetValnumber() const { return itsValnumber; }
void DisplayValencies() const;

void AssignValues(char[], short, double , short[] , short );

private:
char itsName[20];
short itsNumber;
double itsElectronegativity;
short itsValency[7];
short itsValnumber;
};

Element::Element(char name[20], short number, double electronegativity, short valency[7], short valnumber)
{
itsName = name;
itsNumber = number;
itsElectronegativity = electronegativity;
itsValnumber = valnumber;
for(int i=0; i<valnumber; i++)
{
itsValency[i] = valency[i];
}
cout << "*Element constructor called*\n";
}

void Element::DisplayName() const
{
cout << itsName;
}

void Element::AssignValues(char name[20], short number, double electronegativity, short valency[7], short valnumber)
{
itsName = name;
itsNumber = number;
itsElectronegativity = electronegativity;
itsValnumber = valnumber;
for(int i=0; i<valnumber; i++)
{
itsValency[i] = valency[i];
}
cout << "*Values assigned*\n";
}

void Element::DisplayValencies() const
{
for(int i=0; i<itsValnumber; i++)
{
cout << itsValency[i];
if( i==(itsValnumber-1) )
cout << "." << endl;
else
cout << ", ";
}
}

Assign values is a copy of Element constructor, because I've decided to separate the program into reading and writing, and don't want to create two different objects, yet.

[Shades]

Is there a reason your using char arrays for strings rather than stl::string? (which also has nice streaming operations if you want conversion to a byte buffer)

[Supermikhail]

Well, er, because I don't know how to use it properly, and my book on C++ mentions it only teasingly... Oh, it's stl::! Does that mean I can using namespace it? So using stl::string really won't be considered an overkill?

[Shades]

You can using namespace it, just make sure if you do that you put the using in source not header files. It works in fine in both of course but in the headers leads to trouble.

Where I work there is a set of 5 using namespaces in a generic header which causes no end of problems when we get name clashes... which is often poor poor codebase (/rant)

[Supermikhail]

Yep. Turns out I don't know how to use string. How do I use it? Can't I have string as a return value? I've looked at a C++ reference, and got no idea.

[Shades]

Treat it like any other object you have, you can return it or references or pointers to it happily and you can add it to other strings or to char* and char[] to concatenate the string into a new one. It has a length() method and overloads the comparison operators if you need to compare it. I think it also has a equals() method as well which is more strcmp like.

Finally it has a c_str() method if you really really need to convert it to a char*

[Supermikhail]

Uh... how do I declare a constructor with it? As far as I can manage, it doesn't like either Element(std::string ), or Element(std::string &).

[Shades]

Both should work fine, although I tend to use Element(const std::string&)

Edit: Make sure your including <string> as well, you probably are but it can't hurt to mention it.

[ILikePie]

It seems C and Java like writing to files in very different ways. I have two programs do the same thing:

Spoiler (click to show/hide)

Java:

Code: [Select]

import java.io.*;
class tst {
    public static void main(String[]args) {
    try {
        File file = new File ("./java");   
        FileOutputStream out = new FileOutputStream (file);
        DataOutputStream in  = new DataOutputStream (out);
        for (int i = 0; i < 256; i++) {           
        in.writeShort(i);
        }
    } catch (IOException e) {
        System.out.println("Write error");
    }
    }
}C:

Code: [Select]

#include <stdio.h>
int main () {
  FILE *file = fopen ("./c", "w");
  short i = 0;
  for (; i < 255; i++) {
    fwrite(&i, sizeof(short), 1, file);
  }
  fclose(file);
}

and yet, their output is very different

Spoiler (click to show/hide)

Code: [Select]

ron@Tux ~/Media/tmp $ hexdump java
0000000 0000 0100 0200 0300 0400 0500 0600 0700
0000010 0800 0900 0a00 0b00 0c00 0d00 0e00 0f00
0000020 1000 1100 1200 1300 1400 1500 1600 1700
0000030 1800 1900 1a00 1b00 1c00 1d00 1e00 1f00
0000040 2000 2100 2200 2300 2400 2500 2600 2700
0000050 2800 2900 2a00 2b00 2c00 2d00 2e00 2f00
0000060 3000 3100 3200 3300 3400 3500 3600 3700
0000070 3800 3900 3a00 3b00 3c00 3d00 3e00 3f00
0000080 4000 4100 4200 4300 4400 4500 4600 4700
0000090 4800 4900 4a00 4b00 4c00 4d00 4e00 4f00
00000a0 5000 5100 5200 5300 5400 5500 5600 5700
00000b0 5800 5900 5a00 5b00 5c00 5d00 5e00 5f00
00000c0 6000 6100 6200 6300 6400 6500 6600 6700
00000d0 6800 6900 6a00 6b00 6c00 6d00 6e00 6f00
00000e0 7000 7100 7200 7300 7400 7500 7600 7700
00000f0 7800 7900 7a00 7b00 7c00 7d00 7e00 7f00
0000100 8000 8100 8200 8300 8400 8500 8600 8700
0000110 8800 8900 8a00 8b00 8c00 8d00 8e00 8f00
0000120 9000 9100 9200 9300 9400 9500 9600 9700
0000130 9800 9900 9a00 9b00 9c00 9d00 9e00 9f00
0000140 a000 a100 a200 a300 a400 a500 a600 a700
0000150 a800 a900 aa00 ab00 ac00 ad00 ae00 af00
0000160 b000 b100 b200 b300 b400 b500 b600 b700
0000170 b800 b900 ba00 bb00 bc00 bd00 be00 bf00
0000180 c000 c100 c200 c300 c400 c500 c600 c700
0000190 c800 c900 ca00 cb00 cc00 cd00 ce00 cf00
00001a0 d000 d100 d200 d300 d400 d500 d600 d700
00001b0 d800 d900 da00 db00 dc00 dd00 de00 df00
00001c0 e000 e100 e200 e300 e400 e500 e600 e700
00001d0 e800 e900 ea00 eb00 ec00 ed00 ee00 ef00
00001e0 f000 f100 f200 f300 f400 f500 f600 f700
00001f0 f800 f900 fa00 fb00 fc00 fd00 fe00 ff00
0000200


Code: [Select]

ron@Tux ~/Media/tmp $ hexdump c
0000000 0000 0001 0002 0003 0004 0005 0006 0007
0000010 0008 0009 000a 000b 000c 000d 000e 000f
0000020 0010 0011 0012 0013 0014 0015 0016 0017
0000030 0018 0019 001a 001b 001c 001d 001e 001f
0000040 0020 0021 0022 0023 0024 0025 0026 0027
0000050 0028 0029 002a 002b 002c 002d 002e 002f
0000060 0030 0031 0032 0033 0034 0035 0036 0037
0000070 0038 0039 003a 003b 003c 003d 003e 003f
0000080 0040 0041 0042 0043 0044 0045 0046 0047
0000090 0048 0049 004a 004b 004c 004d 004e 004f
00000a0 0050 0051 0052 0053 0054 0055 0056 0057
00000b0 0058 0059 005a 005b 005c 005d 005e 005f
00000c0 0060 0061 0062 0063 0064 0065 0066 0067
00000d0 0068 0069 006a 006b 006c 006d 006e 006f
00000e0 0070 0071 0072 0073 0074 0075 0076 0077
00000f0 0078 0079 007a 007b 007c 007d 007e 007f
0000100 0080 0081 0082 0083 0084 0085 0086 0087
0000110 0088 0089 008a 008b 008c 008d 008e 008f
0000120 0090 0091 0092 0093 0094 0095 0096 0097
0000130 0098 0099 009a 009b 009c 009d 009e 009f
0000140 00a0 00a1 00a2 00a3 00a4 00a5 00a6 00a7
0000150 00a8 00a9 00aa 00ab 00ac 00ad 00ae 00af
0000160 00b0 00b1 00b2 00b3 00b4 00b5 00b6 00b7
0000170 00b8 00b9 00ba 00bb 00bc 00bd 00be 00bf
0000180 00c0 00c1 00c2 00c3 00c4 00c5 00c6 00c7
0000190 00c8 00c9 00ca 00cb 00cc 00cd 00ce 00cf
00001a0 00d0 00d1 00d2 00d3 00d4 00d5 00d6 00d7
00001b0 00d8 00d9 00da 00db 00dc 00dd 00de 00df
00001c0 00e0 00e1 00e2 00e3 00e4 00e5 00e6 00e7
00001d0 00e8 00e9 00ea 00eb 00ec 00ed 00ee 00ef
00001e0 00f0 00f1 00f2 00f3 00f4 00f5 00f6 00f7
00001f0 00f8 00f9 00fa 00fb 00fc 00fd 00fe     
00001fe


Notice how C writes it's bytes in one way, (00aa) and Java writes them backwards (aa00). How do I write bytes to a file in Java in the same order they are written in C?

[qwertyuiopas]

C's byte order is the same as your system's. Java is system-independant, and orders the bytes the same way on all computers.

See http://en.wikipedia.org/wiki/Endianness for details about byte order, or look up something specific to Java or C.

[Supermikhail]

Well, that's fancy. Segfault, I mean.

For anyone curious:

Code: [Select]

//element.hpp

#include <iostream>
#include <string>

class Element
{
public:
Element() {}
~Element() {}

Element( const std::string &, short &, double &, short [], short &);

std::string GetName() const { return itsName; }
short GetNumber() const { return itsNumber; }
double GetElectronegativity() const { return itsElectronegativity; }
short GetValnumber() const { return itsValnumber; }
void DisplayValencies() const;

void AssignValues( const std::string , short, double , short[] , short );

private:
std::string itsName;
short itsNumber;
double itsElectronegativity;
short itsValency[7];
short itsValnumber;
};

Element::Element( const std::string & name, short &number, double &electronegativity, short valency [], short &valnumber)
{
itsName = name;
itsNumber = number;
itsElectronegativity = electronegativity;
itsValnumber = valnumber;
for(int i=0; i<valnumber; i++)
{
itsValency[i] = valency[i];
}
std::cout << "*Element constructor called*\n";
}

void Element::AssignValues(const std::string name, short number, double electronegativity, short valency[], short valnumber)
{
itsName = name;
itsNumber = number;
itsElectronegativity = electronegativity;
itsValnumber = valnumber;
for(int i=0; i<valnumber; i++)
{
itsValency[i] = valency[i];
}
}

void Element::DisplayValencies() const
{
for(int i=0; i<itsValnumber; i++)
{
std::cout << itsValency[i];
if( i==(itsValnumber-1) )
std::cout << ".\n";
else
std::cout << ", ";
}
}


Code: [Select]

//element_setup.cpp

#include <iostream>
#include <fstream>
#include "element.hpp"
#include <string>

using namespace std;

int menu()
{
int choice;
cout << "****Menu****\n\n";
cout << "(1)Write.\n";
cout << "(2)Read.\n";
cout << "(3)Quit.\n\n";
cout << ": ";
cin >> choice;
return choice;
}



int main(int argc, char** argv)
{
string name;
short number;
double electronegativity;
short valency[7];
short valnumber;

cout << name.length();

int choice;
while((choice=menu())!=3)
{
if (choice == 1)
{
cout << "Enter the desired element's name: ";
cin >> name;
cout << "\nEnter " << name << "'s number in the Periodical Table: ";
cin >> number;
cout << "\nEnter " << name << "'s electronegativity: ";
cin >> electronegativity;
cout << "\nEnter " << name << "'s overall number of valencies: ";
cin >> valnumber;
for (int i = 0; i<valnumber; i++)
{
cout << "Enter valency number " << i+1 << ": ";
cin >> valency[i];
}
cout << "\n";

Element elemwrite(name, number, electronegativity, valency, valnumber);

ofstream fout("elements_data", ios::binary);
if( !fout )
{
cout << "Unable to open elements data for writing" << endl;
return 1;
}

fout.write((char*) & elemwrite, sizeof elemwrite);

fout.close();
}
else
if (choice == 2)
{
ifstream fin("elements_data", ios::binary);
if( !fin )
{
cout << "Unable to open elements data" << endl;
return 1;
}
else

Element elemread(name, number, electronegativity, valency, valnumber);

fin.read((char*) & elemread, sizeof elemread);

cout << "Element read\n";

cout << "Element " << elemread.GetName();
cout << "'s number in the Periodical Table is ";
cout << elemread.GetNumber() << ".\n";
cout << "Its electronegativity is ";
cout << elemread.GetElectronegativity() << ".\n";
valnumber = elemread.GetValnumber();
if( valnumber == 1 )
cout << "It has single possible valency which is ";
else
{
cout << "Its overall number of possible valencies is ";
cout << valnumber << " which are ";
}
elemread.DisplayValencies();
cout << "\n";

fin.close();
}
else
cout << "Please select again!\n";
}

return 0;
}

Well, it seems I can't make it output a string of characters to a binary file correctly. Which means I have to resort to a text file. And then write an encryption function for it.

[qwertyuiopas]

You might be writing a few pointers, and when they are read back, the memory they point to might not exist anymore. Probably the string.

Perhaps write a method that, when passed an ofstream, will write the data to it, and one for reading from an ifstream? The string would need to be converted to a plain char array, either manually or by some string method.

[Supermikhail]

That will probably involve writing character by character, and I can only dream of conceiving something that will read such a file correctly. And I suspect then there's no need to use string.

Well, tonight the world either changes, or is destroyed in a fiery catsplosion when I'm so depressed after a failed attempt to reconcile my pointers that I'll spend the rest of the night playing DF.