Drx Capio posted:

If that's your entire file, then you're just dumping executable code in no-man's land. It needs to be in an execution path, like your main function for instance.

Drx Capio posted:

"Reduce dependencies by forcing your user to have essentially the same number of includes, only spread across many files and much more difficult to maintain!"

What a great idea.

ColdPie posted:

Yeah, not to mention they must be kept in a precise order. One.h must come before Two.h! Hope you don't forget!

Seems like a good idea on the surface, but yeah, that just doesn't work. Though it does seem like there should be a way to prevent this (actual picture from one of my recent projects):

floWenoL posted:

You know what else probably seemed like a good idea on the surface? You uploading an 800kb png and thumbnailing it.

tyrelhill posted:

Thats probably the most disorganized UML diagram I've ever seen.

ColdPie posted:

I figure there should be a way to prevent that kind of thing but hey v:)v

floWenoL posted:

No programming language will ever prevent bad design.

ColdPie posted:

What would you suggest? It includes common utilities, constants, and structs that are used in a whole bunch of sources. What's the alternative? I'm seriously asking here, I would love to avoid that mess in future projects.

JoeNotCharles posted:

Is the mess causing any concrete problems? Makefiles slow due to dependency analysis, etc? If not, don't bother trying to avoid it - the compiler's perfectly capable of dealing with crap like that. It's not 1989 anymore.

ColdPie posted:

Absolutely not, it works fine. It just feels messy and "bad designy" like he mentioned. If it's normal, all right, just doesn't seem like the best way to do things.

Plastic Jesus posted:

I came across this a year or two ago:

TSDK posted:

Good christ, that guy's an idiot.

Plastic Jesus posted:

Yes, Rob Pike is an idiot.

Plastic Jesus posted:

Yes, Rob Pike is an idiot.

Plastic Jesus posted:

What I generally do now is have a monolithic include file to distribute with my libraries, but within each project I adhere to Pike's Law. One distinct advantage that's come of this is is a better understanding of which components use which other components, making bad design is much more blatant. Note also that 95% of my code is c, not c++, so it's easier to get away with this approach.

Plastic Jesus posted:

The real question is, how pissed off is the next developer to take over my projects going to be? Very, I assume.

That Turkey Story posted:

You don't think that adhering to this "law" is a bad design on it's own!?

You don't force users to manually include all dependencies for lots of reasons, even apart from the obvious tediousness and room for error.

Plastic Jesus posted:

Yes, Rob Pike is an idiot.

TSDK posted:

TSDK's Law: Everyone is an idiot.

It doesn't matter how smart someone is, there is always some topic or opinion about which that person is an idiot.

floWenoL posted:

And compile time is a major bottleneck for large C/C++ programs. Pike's advice might be outdated, but including (non-system) headers willy-nilly is a good way to kill compile performance.

Plastic Jesus posted:

I just said that I don't do this for libraries for exactly the reasons you just listed. I do it within my own projects for exactly the reasons I just listed. I will probably flatten things when they go to release so that you do not kill me. But during development it is _nice_ to know where dependencies lie.

Presto posted:

I have about 750,000 lines of code at work (C/C++/Fortran) that builds in 4 1/2 minutes on a fairly old dual 2.2 GHz Xeon machine with parallel make, so compile time isn't a real concern.

floWenoL posted:

Honestly that's not a very large project; have you tried building one of Firefox, KDE, or OpenOffice lately? Anyway, the issue is not the from-scratch build time, but the one-line-header change build time and from making sure that that isn't approximately equal to the from-scratch build time.

Sarah Sherman posted:

I'm still pretty new to C++ (first-year student), and I have some quick questions for a personal program of mine.

Sarah Sherman posted:

I'm writing a program that will randomly generate a number between 1 and 20 for a specified number of players, and then team up the players based on what number they got. The pairings are based on highest number is teamed up with lowest number, and the two middle numbers are paired together.

Sarah Sherman posted:

How would I go about doing this? I can code most of the program just fine, but don't really have the programming knowledge to do the 'teaming up' aspect of the program.

Sarah Sherman posted:

Also, after generating these random numbers, I need to set the order of who goes first, based on how biggest number to smallest. How could I do that?

Sarah Sherman posted:

But, just to complicate things up a bit, the teams must alternate on turns. For example, if the two players on team one gets a 20 and a 19, and team two gets a 1 and a 2,

Sarah Sherman posted:

then the turns must go team one, then team two, then team one again, even though team one got both the highest numbers. I'm still fairly new when it comes to programming, so help is very much appreciated.

ShoulderDaemon posted:

I think the problem you're having is likely a problem very typical of new programming students: You think you understand what you want the computer to do, but you haven't yet set it down step by step, so you don't know how to program it. You're focusing on the "little" problems of your application instead of the "big picture", which makes everything more difficult because you aren't yet sure how the parts all need to fit together.

ShoulderDaemon posted:

Sarah Sherman posted:

I've never used the rand( ) function before, so I don't really know how to access the number it will spit out and use that to set up teams, and order of turns.

Sarah Sherman posted:

I hope that is enough information about what I'm trying to do. I don't want the program to go any further, this is just so me and my friends can easily assign teams for a game we play without going through the motions of rolling actual dice.

Sarah Sherman posted:

The output that I'm looking for (if it was a 4 player game with teams) would simply be:

code:

Enter the number of players: 4
Is this a team game or free-for-all?
Enter T for team game, or enter F for free-for-all: T 

Player 1 rolled a 2!
Player 2 rolled a 14!
Player 3 rolled a 20!
Player 4 rolled a 7!

Team 1: Player 3 and Player 1
Team 2: Player 2 and Player 4

Order of turns is: Player 3, Player 2, Player 4, Player 1

Sarah Sherman posted:

I understand now what you mean about not looking at the 'bigger picture' of the program. When I was trying to think out this program before I got to a computer, I was just focusing on the smaller parts of the program, like rolling the dice, and when I finally got to a computer realized I was stuck because I don't know how to do the other aspects of the program. I've never used the rand( ) function before, so I don't really know how to access the number it will spit out and use that to set up teams, and order of turns.

ShoulderDaemon posted:

code:

  // This die-rolling logic is a little bit complicated...
  // I'm trying to preserve exactly the "if two people have the same roll,
  // then only they reroll" behaviour.

  // First, I set each die as "not-yet-rolled", for which I use the value -1.
  for ( int i = 0; i < players; ++i )
    die[i] = -1;

  // Now, for each player, I roll a die...
  for ( int i = 0; i < players; ++i ) {

    if ( die[i] == -1 ) {
      // This player needs to roll.
      die[i] = random( ) % 20;
      fprintf( stdout, "Player %i rolled %i.\n", i + 1, die[i] + 1 );
    };

    // Check to see if this roll is the same as any other roll before it.
    for ( int j = 0; j < i; ++j ) {

      if ( die[i] == die[j] ) {
        // These players rolled the same, so they both need to reroll.
        fprintf( stdout, "Player %i has the same roll as player %i, so they both reroll.\n", i + 1, j + 1 );
        // This is probably the subtlest part of the code I've written.
        die[i] = -1;
        die[j] = -1;
        i = j - 1;
        break; // Goes back to the outer loop.
      };

    };

  };

Incoherence posted:

I'm not convinced this is particularly fair (you resolve ties as they happen, instead of having everyone roll then resolving ties). Not that it terribly matters for this application, but you might get around this by having everyone roll once, then making another pass through the whole loop to resolve ties, and then you might end up doing the same thing again recursively... okay, never mind, we're getting way off the scope of Sarah Sherman's problem.

bcrules82 posted:

http://www.cplusplus.com/reference/clibrary/cstdlib/rand.html
http://www.cplusplus.com/reference/clibrary/cstdlib/srand.html
http://www.cplusplus.com/reference/clibrary/ctime/time.html

ShoulderDaemon posted:

code:

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

int main ( int argc, char *argv[] ) {

  int ret;
  int players;
  int teams;

  // Prepare the random number generator by seeding with the time.
  srandom( time( NULL ) );

  // Ask how many players are involved.
  fprintf( stdout, "How many players total? " );
  ret = fscanf( stdin, "%i\n", &players );
  assert( ret == 1 );
  assert( players <= 20 ); // If there are more than 20 players, then
                           // we will never not have duplicate rolls.

  // Ask if this is a team game.
  // Teams only make sense with an even number of players greater than 2.
  if ( players > 2 && players % 2 == 0 ) {

    char yesno;

    do { 
      fprintf( stdout, "Is this a team game? (y/n) " );
      ret = fscanf( stdin, "%c\n", &yesno );
    } while ( yesno != 'y' && yesno != 'Y' && yesno != 'n' && yesno != 'N' );

    if ( yesno == 'y' || yesno == 'Y' ) {
      teams = 1;
    } else {
      teams = 0;
    };

  } else {
    teams = 0;
  };

  int die[players];

  // This die-rolling logic is a little bit complicated...
  // I'm trying to preserve exactly the "if two people have the same roll,
  // then only they reroll" behaviour.

  // First, I set each die as "not-yet-rolled", for which I use the value -1.
  for ( int i = 0; i < players; ++i )
    die[i] = -1;

  // Now, for each player, I roll a die...
  for ( int i = 0; i < players; ++i ) {

    if ( die[i] == -1 ) {
      // This player needs to roll.
      die[i] = random( ) % 20;
      fprintf( stdout, "Player %i rolled %i.\n", i + 1, die[i] + 1 );
    };

    // Check to see if this roll is the same as any other roll before it.
    for ( int j = 0; j < i; ++j ) {

      if ( die[i] == die[j] ) {
        // These players rolled the same, so they both need to reroll.
        fprintf( stdout, "Player %i has the same roll as player %i, so they both reroll.\n", i + 1, j + 1 );
        // This is probably the subtlest part of the code I've written.
        die[i] = -1;
        die[j] = -1;
        i = j - 1;
        break; // Goes back to the outer loop.
      };

    };

  };

  // Print out the order of the players.
  // This would be better done by sorting a list of the players;
  // the algorithm I have here is equivalent to a bubble sort, but I'm
  // using it because it's simple and speed probably doesn't matter too much.
  // This is marginally subtle and kind of fun to prove why it works.

  int highest_score = 20; // Die rolls are 0..19, so this is higher than any of them.

  // This is a loop over play positions.
  for ( int i = 0; i < players; ++i ) {

    int next_highest_score = -1;
    int next_player;

    // And this is a loop over players.
    for ( int j = 0; j < players; ++j ) {

      // We are searching for the player with the largest die roll that is
      // still smaller than highest_score.
      if ( die[j] < highest_score && die[j] > next_highest_score ) {
        next_highest_score = die[j];
        next_player = j;
      };

    };

    fprintf( stdout, "Position %i: Player %i\n", i + 1, next_player + 1 );

    highest_score = next_highest_score;

  };

  // Print out the teams, if we're in team play mode.
  if ( teams ) {

    // The algorithm here mangles the die array,
    // which is why I'm doing it after printing the turn order.

    // For each team, I'm going to select the players with the highest and lowest
    // rolls that haven't yet been chosen. This loop is over teams.
    for ( int i = 0; i < players / 2; ++i ) {

      int lowest_player, lowest_roll;
      int highest_player, highest_roll;


      // Out of bounds values.
      lowest_roll = 20;
      highest_roll = -1;

      // And this loop is over players.
      for ( int j = 0; j < players; ++j ) {

        // If this player hasn't yet been chosen...
        if ( die[j] != -1 ) {

          // Check if they are the highest roll we've seen so far.
          if ( die[j] > highest_roll ) {
            highest_roll = die[j];
            highest_player = j;
          };

          // Check if they are the lowest roll we've seen so far.
          if ( die[j] < lowest_roll ) {
            lowest_roll = die[j];
            lowest_player = j;
          };

        };

      };

      // Mark the two players as chosen.
      die[highest_player] = -1;
      die[lowest_player] = -1;

      fprintf( stdout, "Team %i: Player %i and Player %i\n", i + 1, highest_player + 1, lowest_player + 1 );

    };

  };

  return 0;

}

Sarah Sherman posted:

Holy poo poo, after looking over this code I understand (vaguely) what is happening and what is going on in each section of the code, but I definitely do not have the programming skill to actually write a program like this. Thanks a lot for the help and discussion guys, but it looks like I'm going to have to scrap this project until I know more. Once I think I have the skills to actually write this program, then I'll for sure speak up again if I need some help. This thread is a great resource, and I enjoy keeping up with this thread (and this subforum in general).

Drx Capio posted:

I'd like to add that generally if you want a set of unique numbers randomly selected from another set, it's cheaper to simply sort your set of available numbers with a random metric, then just pull your 'rolls' from the front of the randomly sorted array.

ShoulderDaemon posted:

Sorting with a random metric is O(n ln₂ n) and potentially has problems if your sorting algorithm is stable, but you can shuffle an array in linear time with, for example, the Fisher-Yates shuffle:

code:

int nums[20];
int j;
int temp;

for ( int i = 0; i < 20; ++i ) {
  j = random( ) % (i + 1);
  temp = nums[i];
  nums[i] = nums[j];
  nums[j] = temp;
};

Drx Capio posted:

I think the complexity of sorting an array of 20 numbers is pretty insignificant, and I only gave the pseudocode as an example. The person writing the program would probably prioritize good random numbers over a fast shuffle. Besides, I would probably just use random_shuffle anyway.

Drx Capio posted:

Besides, I would probably just use random_shuffle anyway.

fret logic posted:

Where's a good place to start for programming simple graphics in C? Nothing fancy, just lines or pixels to get me started. I've tried to decipher the source code for nethack, as far as how they print the ASCII characters in different places, and it's a bit above me heh.

floWenoL posted:

I think the person writing the program would probably prioritize "having my program not crash" over anything else, which sorting with a random metric would do. To fix that, you'd have to make sure that your predicate returns consistent results if you pass it the same pair twice, at which point your level of complexity is way beyond just doing the shuffle.