Print

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

[Skyrunner]

I think someone already said this, but why don't you expand the variable names?

So r->resistance, rnot->initialResistance, vs->resistorVoltage, rs->resistanceOfResistor. vm->voltageOfMeter.

So it would look like


(note, I have a question or two inside)

Spoiler (click to show/hide)

#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;

int main()
{
   double resistance, // r
 initialResistance = 50, //rnot
 k = 0.5, //problem's dummy value
 resistorVoltage = 20 //vs,
resistanceOfResistor = 75 //rs,
voltageOfMeter; //vm
   double temperature = 0;
   do {
// The equations given in the question
      resistance = initialResistance + k * temperature;
      voltageOfMeter = resistance * resistorVoltage / (reistanceOfResistor + resistance);
      voltageOfMeter = (20 * temperature + 2000) / (250 + temperature);
// I have a question here. Why do you assign a value to vm (voltageOfMeter) twice?
// The actual loop.
         cout << "When t is " << temperature << " The voltage of the meter is " << voltageOfMeter << "." << endl;
      temperature+=10; //You can use += instead of t = t + 10;. It's exactly the same thing.
   } while (t!=110);

   system("pause");
}

The reason for expanding the variable names is because of increased readability. Before I changed them, I had to keep looking up to see what the heck "vm" is. But now, I can see what it is in one glance. It's easier to see if you're doing anything wrong, for example. Short, 1~6 letter variable names irk programmers a lot.
I put the original equation's variables in comments. This is actually how I did my models that were based off a scientific paper. I put the variable names in comments and expanded them so I can tell what I'm doing. The paper, for example, called for fT, fB, fR, fL. I expanded them to fluxToTop, fluxToBottom, fluxToRight, fluxToLeft. Much more readable. Same with Ks (sedimentCapacityConstant), Kd (sedimentDepositingConstant), or cc (runoffCurveConstant).

Also notice that I inserted a lot of spaces. Spaces also help your code look much more readable.

[Siquo]

Short, 1~6 letter variable names irk programmers a lot.

No, they don't. Using a do while with a double and an exact check one bigger than your range is what irks me.

[Skyrunner]

Short, 1~6 letter variable names irk programmers a lot.

No, they don't. Using a do while with a double and an exact check one bigger than your range is what irks me.

Huh, he checks for != o_o
It should be <= 110, at least.

Also, you seem to not have seen old source code for a huge simulator. >.> Every file name is less than 10 characters, each variable is cryptic and terse, and the code itself is unknowable.

[olemars]

Scientist code is always like that. Especially older scientists, since they learned programming on computers with punchcard readers.

[Dutchling]

Why are there std's in the code?

[Siquo]

Why are there std's in the code?

Because nobody likes using namespace std;

[MorleyDev]

Why are there std's in the code?

Stack Overflow explains why importing a namespace (such as std) is considered bad practice in C++. I only do it if I'm outright bringing one namespace into another, which is pretty rare an event.

[Dutchling]

Are namespace low level language shenanigans? As I never heard of them :x

[GlyphGryph]

Eh, I see no reason not to use namespaces. I mean, obviously you should never use them in your interfaces, the bits of code other people actually use and interact with and include in their own files. But for self-contained blocks of code, I don't see the potential issue.

[Valid_Dark]

Time for a Namespace Lesson!!!

Are namespace low level language shenanigans? As I never heard of them :x

Not really,
a namespace is kind of like a struct or a class,
Syntax is:

namespace namespace_name
{
//Namespace members would go here
void examplefunction()
     {
        //examplefunction stuff.
     }
}

to access a member of a namespace, you use the scope resolution operator "::"
so to call the example function it would be
namespace_name::examplefunction();

They are used for libraries and stuff because it lets them use function names, that other libraries might be using, so to use a function from it you have to include the namespace name.  In the standard library there is a namespace called "std"
members of that namespace include things like cout and cin, which are commonly used.
so, in order to use cout or cin, you'd normally have to write it like this.
std::cout  or std::cin

if your program uses a lot of functions from one namespace, it might be a better idea to access it using a "using namespace" line,
so if towards the beginning of your code, you write  "using namespace std;"
you can access cin and cout without using the namespace name, so in this case it would be
cout or cin

"Hey! that looks both easy AND fun! why don't we do the using namespace thing for ALL the namespaces?!"

woah! calm down there cowboy, yes that may look like a good idea at first, but it includes ALL of the function names from that namespace, so what if you wanted to use 2 namespaces that both had a function with the same name? It wouldn't know what to do with itself, and probably wouldn't do what you want it to.

[Soadreqm]

woah! calm down there cowboy, yes that may look like a good idea at first, but it includes ALL of the function names from that namespace, so what if you wanted to use 2 namespaces that both had a function with the same name? It wouldn't know what to do with itself, and probably wouldn't do what you want it to.

Doesn't the compiler warn you when you do that? Because it kind of seems to me like it should. "Hey dude you got like six different functions named 'bluh()' available in this context which one do you want me to use here?"

[Skyrunner]

Actually, if the signatures are different (the int, int or void things), it just overloads them no problem. O.o

Note: not sure what they are called...

[MorleyDev]

It essentially brings the definitions of all functions and classes into another namespace. You can actually do:

Code: [Select]


namespace foo
{
    void bar();
}

namespace piano
{
    using namespace foo;
}

int main()
{
    piano::bar();
    return 0;
}

In fact creating that kind of behaviour in a library is the only time I ever will use using statements in C++. Otherwise they just risk causing more trouble than they are worth.

[Skyrunner]

Why not using statements in cpp files? O_o Those aren't shared.

[MorleyDev]

Why not using statements in cpp files? O_o Those aren't shared.

Because they include headers, and headers define functions. It's an accident waiting to happen, and I find tends to make it harder to follow what's going on in a piece of code. The prefix's add clarity, and readability is an important thing in coding. Quite frankly, there's just no reason to use the using namespace instead of std::, but plenty of reasons not to. I'd rather not do the wrong thing in the first place by habit, instead of waiting for the compiler to tell me I'm doing it wrong.

Heck, consider the following C++11 line:
auto pcount = &count;

...am I getting a pointer to a variable called count, or a function pointer to std::count?