LinuxQuestions.org

LinuxQuestions.org (/questions/)
-   General (http://www.linuxquestions.org/questions/general-10/)
-   -   Source Code Superthread (http://www.linuxquestions.org/questions/general-10/source-code-superthread-806394/)

Kenny_Strawn 05-06-2010 07:05 PM

Source Code Superthread
 
If any of you write code, this is the thread to post it in. Show us some samples of code if you like, and also use this thread to give tips to writing good code. I decided to create a superthread for code lessons and code posted just for the fun of it. But code to help people has to stay in the support thread it was posted in.

Jeebizz 05-06-2010 07:48 PM

Code:

#include <iostream>

int main()
  {
  cout<<"Hello World!"<<endl;
  return 0;
  }

And I'm patenting it! Next person to write a hello world program in C++ owes me money! :mad:

:rolleyes:

exvor 05-06-2010 08:46 PM

Thats ok because I patented hello world in C and thats where the C++ variant came from so you actually owe me money :P.

Code:


#include<stdio.h>

int main (int argc, char * argv[])
{
  printf("Hello world!\n");
  return 0;
}


Jeebizz 05-06-2010 09:02 PM

And to quote Homer Simpson: DOH! :doh:

exvor 05-06-2010 09:25 PM

Thus illustrating why software patents are the worst idea ever in the software industry.

Dogs 05-06-2010 09:28 PM

Ok... For an assignment that took 1 minute to read and understand, I wrote all of this code.

Literally, the assignment said get num from user, raise it to power, print results, check if they want to do another number.


main.cpp

Code:


#include <iostream>
#include "user.h"
#include "powerizer.h"
#include "replay.h"
#include "header_footer.h"
using namespace std;


/*

        C++ Beginning - Lab 4 - 1307.xxx
        April 9, 2010.
       
        A-Option -
        Inputs:
                User enters number and power
               
        Outputs:

                Program prints number raised to power to stdout.

        Error conditions are handled during number submission
        and answer submission. Option to repeat the program is
        included.
*/

int main_driver();

int main(){

        // greet the user
       
        print_intro();

        // Initiate the main controlling section of the program
       
        main_driver();

        // die

        return 0;
               
}


int main_driver(){
   
    int number;
    int power;
    long int result;


    // get number from user
    // get power from user
    // raise number to power
    // print results
    // check for replay
   
    do{
         
          // get number and power
         
          cout << "Enter the number to raise to a power." << endl;
          number = user_submitted.g_number();
          cout << "Enter the power to raise number to." << endl;
          power = user_submitted.g_number();

          // do it
         
          result = process.raise_number_to_power(number, power);
         
          // print out the results
         
          print_results(number, power, result);

          // check for replay
         
    }while(option_for_replay());
   
return 0;
}


user.h

Code:

/*
 *        Welcome to user.h. This header file contains routines to
 *        handle user input regarding the numbers they want to
 *        work with in the program (and not for user input
 *        regarding whether or not the user wants to restart
 *        the program. That is handled by option_for_replay.h)
 */


#include <iostream>
using namespace std;

#define MAX_ELEMENT 20 // max elements in any array in this program.

#define debug 0 //  <- make this positive for debug messages.

/*
  In an effort to better understand C, I'll use
  structures for this assignment. In an effort to write
  better code, I've done all of this in an 80x25 terminal
  and using vi, which is the most challenging text editor
  I've come across so far. Also with a serious attempt at
  readable code.
*/

// Build structures for user submitted info


/* user_submitted_entires pertains to the numer, and the power
    that the user entered. It contains public functions
    for getting a number, and printing number and power. */



struct user_submitted_entries{

    // g_number() gets a number and returns it.
   
    int g_number();
         
    private:

          // Private variables number and power.

          int power;
          int number;

}user_submitted; // <-- create an object user_submitted that can be accessed globally.


/*        user_input pertains to the validity of the user's submissions.
          it contains public functions to prepare the array for
          the users entry, to check it, to get the length,
          and to convert the array to an integer. */

struct user_input{
   
    // dot_array() goes from 0 to max_element filling the array with '.'s
   
    void dot_array(char array[]);

    // validate_entry() checks to see if the users submission was useable in the
    // rest of the program. It returns 1 if the answer is bad, 0 if it is good.
   
    int validate_entry(char ent_num[]);
   
    // g_num_of_elements_in() scans the array for things that aren't '.'s, and returns where the last one was found.
   
    int g_num_of_elements_in(char num[]);

    // make_char_array_a_number() takes an array and its length, and converts it into an integer.
   
    int make_char_array_a_number(char num[], int num_of_elements);

}input; // <-- create object input that can be accessed globally.



// I was happy to learn that part of an idea
// I came up with for multiplying numbers
// in a matrix that is designed to
// replicate physically writing math
/* on a piece of notebook paper would work in this program.


    ( the matrix-math program is useful because I can store more than
          2^32 in a 100 element vector.. a lot more
          in the end the idea would simulate long-hand multiplication,
          addition, subtraction, and division of problems that could be
          multiple pages wide.

          --- UPDATE --- Professor says Arrays != Matrices

              For example -


          2342342342378297834234
          4534534534534543523423
          *_____________________
          //////////// A ////////
          /////////// lot of//////
          //////////work  here///
          +_____________________
          /// bigger answer here      ///
          // but remember that everything
          // you see is an element in the
          // matrix                // )
*/



/*
        this function moves through a char array,
        strips each element of its ASCII code, multiplies the
        the element by the power of 10 represented by its
        place in the array (123 = 3*1+2*10+1*100), and
        assigns the result to "number", which is then returned.
        The char array is started from the end, because 123 is
        stored in elements [0][1][2] respectively. I did this
        because I didn't know how to handle situations where
        a user is entering an integer number, but instead inputs
        a letter or some other nonsense. The results were generally overflows.
*/
       
int user_input::make_char_array_a_number(char num[], int num_of_elements){

        if(debug){ cout << "Entered make_char_array_a_number()" << endl; }

        int converted_to_number = 0;
        int current_power_of_ten;
        int current_element;

        for(        current_element = num_of_elements,  current_power_of_ten = 1;

                                  --current_element >= 0;
       
          current_power_of_ten *= 10          ){
           
                    converted_to_number += (num[current_element] - '0') * current_power_of_ten;
        }

if(debug){ cout << "Leaving make_char_array_a_number()." << endl; }
       
        return converted_to_number;
}                       


// get the number, and make sure it is a number!

int user_submitted_entries::g_number(){
        char entered_num[MAX_ELEMENT];
        int gotten_number;
        int length;
       
       
        if(debug){ cout << "Entered g_number()." << endl; }

        // prompt toggle changes the prompt from default friendly to
        // "restart and enter the right information" mode after the first run through the program
        // because, presumably, if you come back through for any reason, it is because you entered something wrong.
       
        int prompt_toggle = 0;
        do{
                if(prompt_toggle == 0){
                        cout << ":";
                }else{
                        cout << "Positive Entries Only" << endl;
                        cout << ":";
                }
                prompt_toggle++;


                if(debug){ cout << "In g_number() -> dotting array" << endl; }

              /* to avoid having the array cluttered with old answers, especially
                  in the case of wrong answers, it is necessary to clean the array
                  before each use. I hereby state that being full of periods is being clean.*/

                input.dot_array(entered_num);

                if(debug){ cout << "In g_number() -> Done dotting array" << endl; }
       
                cin >> entered_num;


                /*
                  if entered_num turns out to be
                  something other than a number or a '.',
                  then validate_entry will be positive.
                */
       
        if(debug){ cout << "In g_number() -> validating entry" << endl; }
               
        }while( input.validate_entry(entered_num) );

        if(debug){ cout << "In g_number() -> Entry validated" << endl; }
       
       
        /* g_num_of_elements_in searches from 0 to MAX_ELEMENT
          for a period. This will indicate the end of the
          entered number. It depends on validate_entry being called
          before it. Convenient, since validate_entry is designed
          to fit in the condition of a do{}while() loop.
          g_num_of_elements_in does not care what you entered, just
          how much you entered. As opposed to validate_entry
          which does not care about how much you entered, but what
          you actually entered.
          */
                   

        if(debug){ cout << "In g_number() -> Getting Length" << endl; }

        length = input.g_num_of_elements_in(entered_num);       

        if(debug){ cout << "In g_number() -> Length Obtained" << endl; }

       
        /*
                this aptly named function does exactly
                what it says it does... as it tears apart
                an array of characters, walks through
                each one and multiplies it by the
                power of 10 represented by its position
                in the array, the results are stored in an integer.
                It returns that integer.
        */
       
        if(debug){ cout << "In g_number() -> Making char* to number" << endl; }


              gotten_number = input.make_char_array_a_number(entered_num, length);
       

        if(debug){ cout << "In g_number() -> char* is now a number." << endl; }


        cout << "You entered [" << gotten_number << "]\n" << endl;

        if(debug){ cout << "Leaving g_number()" << endl; }

        // Finally, return the number you got.

        return gotten_number;
}


    /*
    my answer to the question of, "How do I initialize an array
    so that it is uniform except for situations I'm looking for,
    and that will allow me to perform mathematical operations on
    each element without any issues was to intialize the character
    array with periods, and use my tests based on whether or not
    something was a period, a number, or something I don't want.

    */


// Write to array[i] with periods.

inline void user_input::dot_array(char array[]){
       
        if(debug){ cout << "Entered dot_array()" << endl; }

        int current_element;
        for(current_element = MAX_ELEMENT;
              --current_element >= 0;                ){

            array[current_element] = '.';
        }
        if(debug){ cout << "Verification of write to array" << endl;
                  cout << "Start value [" << array[0] << "] End value [";
                  cout << array[MAX_ELEMENT - 1] << "]" << endl;
        }

        if(debug){ cout << "Leaving dot_array()" << endl; }

}

/*
  This exceedingly inefficient, but Russian Reliable method
  for finding the length of an array is part of another idea I have.
  It works by going from one end of an array of dots to the other,
  looking for things that aren't dots. Mostly this is a result
  of my lack of understanding when it comes to reliably validating data.

  Though I will say this.. The issue with my user input method
  is not caused by cin or by the looping structure. It is caused by
  some buffer I am not aware of that retains the information even
  when my program rejects it. Some buffer that feeds cin. I don't know
  if it is operating system specific, or if it is specific to C++,
        but I have the same issue when I don't use cin (ex, happens with getch, getchar, scanf, etc)
        so stdin must have a buffer or something that bridges stdin to the program.
*/

inline int user_input::g_num_of_elements_in(char check[]){

        if(debug){ cout << "Entered g_num_of_elements_in()" << endl; }


        int found_length;       
        int cur_elem;


        // go from 0 to max_element looking for things that are '.'
       
        for( cur_elem = 0; cur_elem  < MAX_ELEMENT; cur_elem++    ){

       
                        if( check[cur_elem] == '.'){
                                found_length = cur_elem-1;
                               
                                if(debug){       
                                        cout << "Found Last digit in element[";
                                        cout << cur_elem-2 << "]";
                                        cout << "\nRETURNING:  " << found_length;
                                        cout << endl;
                                }
                                if(debug){ cout << "leaving g_number()\n"; }

                               
                                return found_length;
                        }else{
                        // do nothing because it is not the number, but part of the number.
                        }
        }

        if(debug){ cout << "Failed in g_num_of_elements_in()." << endl; }

        return 0;
}


// check to make sure the input is valid.

inline int user_input::validate_entry(char ent_num[]){

        if(debug){ cout << "Entered validate_entry" << endl; }


        int i;

        // TEST CONDITIONS FOR VALIDITY

        bool failed_entry = false;
        for(i = 0; i < MAX_ELEMENT && ent_num[i] != '\0'; i++){

            if( !(ent_num[i] == '.') && !(isdigit(ent_num[i]))){ failed_entry = true; }

        }
           


          if(debug && !failed_entry){ cout << "Answer was good." << endl; }

    return failed_entry;
}


replay.h

Code:

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

// Brain freeze at 4AM..
// super obvious example ensues.

/*
        Basically, allow the user to enter whatever.
        After that, check only the first element of the char array
        that the user just filled with whatever. If it isn't
        yes or no, ask again (but also switch the message.)
        First pass through for the message is a greeting,
        the next is a courteous error message.
*/

int option_for_replay(){
        char users_response_to_question[100];
        char extracted_answer;
        bool wrong_answer = false;     

        do{
                if(!wrong_answer){

                cout << "Would you like to go again? enter Yyes or Nno\n";

                }else{
               
                cout << "Please enter a valid response of Yyes or Nno" << endl;

                }

                cin >> users_response_to_question;
                extracted_answer = users_response_to_question[0];

                if(        isalpha(      extracted_answer    )          ){
                        if(        extracted_answer                        //is
                                        == 'y'                        ||        //or
                                extracted_answer                        //is
                                        == 'Y'                        ){
                                // then the answer is yes

                                cout << "Ok, restarting the program.\n\n";
                                return true;

                        }else if(        extracted_answer                //is
                                                == 'n'                ||        //or
                                        extracted_answer                //is
                                                =='N'          ){
                                // then the answer is no
                       
                                cout << "Shutting down the program.\n" << endl;       
                                return false;

                        }else{
                                wrong_answer = true;
                        }
                }else{
                        wrong_answer = true;
                }
        }while(wrong_answer);
       
cout <<  "Never should have gotten here.. go ahead and restart then." << endl;
return true;

}

powerizer.h

Code:

#include <iostream>
using namespace std;

// Struct declaration and definition

/*
        pretty basic way of raising num to pow.
        take the number that has been interrogated
        thoroughly, and multiply it by its power, which has
        also been interrogated.
        Store that result in number_raised_to_power;
*/

struct powerizer{

        // variable for storing the results

        long int number_raised_to_power;

        // function for factorializing a number

        int raise_number_to_power(int &num, int &pow);


}process; // object process to be accessible globally.



int powerizer::raise_number_to_power(int &base, int &pow){
      int p = pow;
      if(debug){ cout << "Entered raise_number_to_power(int base, int pow)" << endl; }

        // number_raised_to_power is assigned 1
        // because its first use is in multiplication.
        // pow controls the loop, num is the base

        number_raised_to_power = 1;



        for( ; --p >= 0; ){
                number_raised_to_power *= base;
                if(debug){ cout << pow << endl; }
        }
       
        return number_raised_to_power;

        if(debug){ cout << "Leaving raise_number_to_power()" << endl; }

}


header_footer.h

Code:

#include <iostream>
using namespace std;

// Print welcome screen

void print_intro(){
        cout << "\n\n==================================================================" << endl;
        cout << "Welcome to Jonathan Findley's Powerizer v1.00" << endl;
        cout << "Part of C++ Lab 4 on loops, powers, and that sort of thing...." << endl;
        cout << "Enter the number you want to raise to a power, " << endl;
        cout << "and the program will print the result after exponentiation." << endl;
        cout << "==================================================================\n" << endl;
}

// Print results

void print_results(int &number, int &power, long int &result){
        cout << "======================================================" << endl;
        cout << number << " raised to the power of ";
        cout << power << " is equal to ";
        cout << result;
        cout << endl;
        cout << "======================================================" << endl;
}


brianL 05-06-2010 10:29 PM

You're mistaken, these two are my Intellectual Property:
Code:

#include <iostream>

int main()
  {
  cout<<"Hello Brian!"<<endl;
  return 0;
  }

Code:

#include<stdio.h>

int main (int argc, char * argv[])
{
  printf("Hello Brian!\n");
  return 0;
}


MrCode 05-06-2010 11:22 PM

Written after seeing this xkcd:

Code:

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

int numIters = 0;

int Collatz(int num,int maxIters)
{
        printf("%i\n",num);
        numIters += 1;

        if(numIters <= maxIters)
        {
                if(num > 1)
                {
                        if(num % 2 == 0)
                                Collatz(num / 2,maxIters);
                        else
                                Collatz((num * 3) - 1,maxIters);
                }
                else
                {
                        printf("The number provided reduces to 1.\nThis would be a point in a Collatz fractal.\n");
                        return 0;
                }
        }
        else
        {
                printf("The number provided causes the iterations to escape to infinity.\nThis would not be a point in a Collatz fractal.\n");
                return 1;
        }

        return 0;
}

int main(int argc,char* argv[])
{
        if(argc != 3)
                printf("Usage: ./collatz <number> <max iterations>\nUsed for calculating a Collatz sequence based on the number passed to the\nprogram.\n");

        int numParam,iterParam;

        numParam = atoi(argv[1]);
        iterParam = atoi(argv[2]);

        Collatz(numParam,iterParam);

        return 0;
}

I would totally use the algorithm to write a fractal generator, but (as of yet) I don't know how to handle pixel-by-pixel graphics in GTK+. Time to do some reading! :D

smeezekitty 05-07-2010 01:03 AM

Quote:

Originally Posted by MrCode (Post 3959936)
Written after seeing this xkcd:

Code:

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

int numIters = 0;

int Collatz(int num,int maxIters)
{
        printf("%i\n",num);
        numIters += 1;

        if(numIters <= maxIters)
        {
                if(num > 1)
                {
                        if(num % 2 == 0)
                                Collatz(num / 2,maxIters);
                        else
                                Collatz((num * 3) - 1,maxIters);
                }
                else
                {
                        printf("The number provided reduces to 1.\nThis would be a point in a Collatz fractal.\n");
                        return 0;
                }
        }
        else
        {
                printf("The number provided causes the iterations to escape to infinity.\nThis would not be a point in a Collatz fractal.\n");
                return 1;
        }

        return 0;
}

int main(int argc,char* argv[])
{
        if(argc != 3)
                printf("Usage: ./collatz <number> <max iterations>\nUsed for calculating a Collatz sequence based on the number passed to the\nprogram.\n");

        int numParam,iterParam;

        numParam = atoi(argv[1]);
        iterParam = atoi(argv[2]);

        Collatz(numParam,iterParam);

        return 0;
}

I would totally use the algorithm to write a fractal generator, but (as of yet) I don't know how to handle pixel-by-pixel graphics in GTK+. Time to do some reading! :D

Why not use SDL, it beats the pants off of GTK for pixel-by-pixel.

jiml8 05-07-2010 03:40 AM

I got you all beat. Here is my original patented Fortran 66 "Hello World" program.

Code:


      PROGRAM HIWORLD(INPUT,OUTPUT,TAPE60=INPUT,TAPE61=OUTPUT)
      CHARACTER HIW*11
      PARAMETER HIW='Hello World"
      WRITE (200,61) HIW
200  FORMAT(1X, 11A1)
      END

Y'all owe ME, since all of your work is a derivative of my original work.

Kenny_Strawn 05-16-2010 09:31 PM

Any idea WHY you like software patents? Other than to lock software (and any competitors) to the GPL, I don't see any need for them other than to create a monopoly and violate antitrust law.

exvor 05-16-2010 09:33 PM

Quote:

Originally Posted by Kenny_Strawn (Post 3970911)
Any idea WHY you like software patents? Other than to lock software (and any competitors) to the GPL, I don't see any need for them other than to create a monopoly and violate antitrust law.

Kenny I don't think anyone here likes software patents? The whole point of our jesting is to make fun of it.

fbsduser 05-25-2010 10:25 PM

Code:

SECTION .data

        msg        db        "Hello, world!",0xa ;
        len        equ    $ - msg

        SECTION .text
        global main

main:
        mov    eax,4                ; write system call
        mov    ebx,1          ; file (stdou)
        mov    ecx,msg        ; string
        mov    edx,len        ; strlen
        int    0x80                ; call kernel

        mov        eax,1                ; exit system call
        mov    ebx,0     
        int    0x80                ; call kernel

Ya'll OWE ME 'cause I patented Hello World in assembler :rolleyes: ;)

linuxlover.chaitanya 05-26-2010 02:08 AM

Nobody owes me money :( I use bash

Code:

#!/bin/bash

        echo "Hello world"


MrCode 05-26-2010 02:35 AM

askme revised (WIP):

Code:

#include <stdio.h>

char* questions[3] = {"What are you doing now?",
                      "Who are you?",
                      "How are you feeling?"};

char* answers[3] = {"None of your beeswax...",
                    "Who are YOU?",
                    "Why do you care?"};

int main(int argc,char** argv)
{
        if(argc < 2)
        {
                printf("Usage: ./askme <phrase>\n");
                printf("(where <phrase> is a question)\n");
               
                return 1;
        }
        else
        {
                int i;
                for(i = 0; i <= 2; i++)
                {
                        if(strcmp(*argv,questions[i]) == 0)
                                printf("%s",answers[i]);
                        else
                                break;
                }
        }       

        return 0;
}

Can't get it to print anything when I issue one of the queries, though. I'm giving the argument in quotes, too. :scratch:


All times are GMT -5. The time now is 12:29 AM.