Print

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

[Mego]

I finally finished my personal C++ challenge. I have implemented function tables in a somewhat-nice way for C++, using a combination of C++ code, C preprocessor macros, a bash script, a Python script, and an often-overlooked binutils tool (ctags).

Now for the next (harder) step: member-function tables. And then, object tables.

AND THEN THE WORLD!

[Virex]

AND THEN LISP!

FTFY

[SolarShado]

Spoiler (click to show/hide)

Okay, I'm just gonna kinda dive into this. I'm new to programming/java and am dabbling currently. I didn't/don't take courses on it, so I've only been learning through one book and whatever I can scrape off the internet. TL;DR I barely have any idea what I'm doing half the time.

I have PartsList and Mech.

Code: [Select]

class PartsList {   
     
    // skeleton for all Parts
    public class framePart {
        public String prtName = null;
        public int prtCategory = 0;
        public int prtAP = 0;
        public int prtDEF = 0;
    }
       
    // ARMS
    // skeleton for all Arm Parts
    public class armPart extends framePart {
            public int prtATK = 0;
           
            public void set() {
                prtName = "Arm Part";
                prtCategory = 1;
            }
           
            public void stats() {
                System.out.println("Name: " + prtName);
                System.out.println("Cat: " + prtCategory);
                System.out.println("AP: " + prtAP);
                System.out.println("DEF: " + prtDEF);
                System.out.println("ATK: " + prtATK);
            }
    }
   
    //  Gatling Gun Arm Part
    public class gatlingGun extends armPart {
        @Override
        public void set() {
            super.set();
            prtName = "Gatling Gun";
            prtAP = 100;
            prtDEF = 25;
            prtATK = 100;
        }
    }
   
}

Code: [Select]

class Mech  {
       
    public static void main(String[] args){
        PartsList pl = new PartsList();
        PartsList.armPart p1arm = pl.new armPart();
        PartsList.gatlingGun gGun = pl.new gatlingGun();
       
        gGun.set();
        gGun.stats();
        p1arm.stats();
    }

}
I need to change a bunch of things to make it work the way I want to anyway, but there's something I was expecting to work a certain way that isn't.

That is, the output I get is,

Code: [Select]

Name: Gatling Gun
Cat: 1
AP: 100
DEF: 25
EVA: 5
ATK: 100
AMO: 3
Name: null
Cat: 0
AP: 0
DEF: 0
EVA: 0
ATK: 0
AMO: 0
the output I wanted to get would just be the first half repeated. As in, the armPart would have all its variables equal to gatlingGun. Instead I just get 0s.

It works that way if I take all the variable constructors(?) out and put them under PartsList, but I didn't want to do that. I mean, I could, but I'd like to know why this way isn't working.

Why are you using nested classes? IME that's rarely the right way to solve a problem, and it can lead to confusing code...

<opinion type="personal">Inner classes should seldom be public, and almost never have public constructors.</opinion>

[Mego]

Virex, I tried learning LISP a while back. It didn't work. But, I did get really good at matching up parentheses.

Anyway I'll probably be showing off my success here soon.

[Virex]

Virex, I tried learning LISP a while back. It didn't work. But, I did get really good at matching up parentheses.

Huh, I let my editor (usually emacs) do the parentheses matching. I couldn't do it by hand if my life depended on it

[MagmaMcFry]

I spent the first few years of my programming experience using only the Windows 95 default editor. The good news: I'm now officially awesome at finding any sort of bugs in arbitrarily obfuscated code.

[MadocComadrin]

I once tried to write a stack-based program to make sure all of my parenthesis matched, but it wouldn't compile. It turns out I forgot a parenthesis.

[Xegeth]

Venting about c++ ahead! 'Cause I feel like it.

Two things I loathe about it:

1) No easy way to maintain local scope and eliminate redundancy. If you've a function that does the same identical block of code multiple times throughout, the normal way to eliminate redundancy is to turn that block of code into a function call. This means you lose local scope. The ways around this are 1) Pass your local variables as arguments (sloppy), 2) Turn your locals into globals (retch), or 3) use macros (potentially long compile times, ahoy!). I've started gravitating toward globals and I feel dirty.

An alternative way around the problem would be creating a new class and moving the block of code into that. You'd only have to pass the local variables or references to them into it once at the start of the function, and it's only slightly slower than using global variables.

[GlyphGryph]

Hmm... c++ doesn't support code blocks and lambdas? Or do they just not inherit scope?

(It's clearly been too long)

[Nadaka]

Hmm... c++ doesn't support code blocks and lambdas? Or do they just not inherit scope?

(It's clearly been too long)

Not 100% sure what you mean by code blocks.
C++11 does have lambdas, but that is brand spanking new.

[GlyphGryph]

Code block is just another term for a closure.

Spoiler: From Wikipedia (click to show/hide)

In computer science, a closure (also lexical closure or function closure) is a function together with a referencing environment for the non-local variables of that function. [1] A closure allows a function to access variables outside its immediate lexical scope. An upvalue is a free variable that has been bound (closed over) with a closure. The closure is said to "close over" its upvalues. The referencing environment binds the nonlocal names to the corresponding variables in scope at the time the closure is created, additionally extending their lifetime to at least as long as the lifetime of the closure itself. When the closure is entered at a later time, possibly from a different scope, the function is executed with its non-local variables referring to the ones captured by the closure.

Have looked it up, apparently some versions of C++ support them.

It may not be exactly what he's describing here, of course. I'm not really thinking clearly and maybe that is all completely irrelevant.

[MorleyDev]

Closures were gonna be in C++11 but they couldn't agree on a good usage and syntax for them so postponed it. Some compilers have special builds to to support them because experimental implementations were made to test the ideas and implementations.

Lambas are in C++11 and gcc and visual studio 2010 support them, you manually specify which variables get dragged by value or by reference, or if all in parent scopes are: http://en.wikipedia.org/wiki/Anonymous_function#C.2B.2B

[kaijyuu]

Well lambas look interesting, if they work how I think they do.

What I'd love would be a local function that inherits local scope. IE,

Code: [Select]

void foo()
{
    int counter = 0;
    int counter2 = 0;
    void IncrementCounters()
    {
         counter++;
         counter2++;
    }
   

    //do random stuff
    IncrementCounters();
    //do other stuff
    IncrementCounters();
}
Not the most practical example but that's pretty much what I want. Most of the time when I have this problem, I'm doing very different things between the redundant code ("random stuff" and "other stuff" in the example would be quite different, or at least not something iterable), so a loop wouldn't work to eliminate it.

[MagmaMcFry]

Well lambas look interesting, if they work how I think they do.

What I'd love would be a local function that inherits local scope. IE,

Code: [Select]

void foo()
{
    int counter = 0;
    int counter2 = 0;
    void IncrementCounters()
    {
         counter++;
         counter2++;
    }
   

    //do random stuff
    IncrementCounters();
    //do other stuff
    IncrementCounters();
}
Not the most practical example but that's pretty much what I want. Most of the time when I have this problem, I'm doing very different things between the redundant code ("random stuff" and "other stuff" in the example would be quite different, or at least not something iterable), so a loop wouldn't work to eliminate it.

This should work:

Code: [Select]

void foo()
{
    int counter = 0;
    int counter2 = 0;
    auto IncrementCounters = [&]()
    {
         counter++;
         counter2++;
    }
   

    //do random stuff
    IncrementCounters();
    //do other stuff
    IncrementCounters();
}

[Virex]

Actually you can have a closure without having an anonymous function, at least in some languages (lisp code because fuck parenthesis haters)

Code: [Select]

(let ((ID 0))
    (defun get-ID ()
        (1+ ID)))


The function get-ID increments the ID variable every time it is called and returns the result of incrementing it. The ID variable is external to get-ID and that's why it doesn't go out of scope after get-ID exits, instead it will persist until we unintern get-ID.  It is however local to the let-block in which get-ID was defined, so no other function can access it.


We can also give multiple functions access to ID:

Code: [Select]


(let ((ID 0))
    (defun get-ID ()
        (1+ ID))
    (defun reset-ID ()
        (setf ID 0))
    (defun set-ID (x)
        (setf ID x)))
Here, there are 3 functions that can access ID. get-ID, which returns it, reset-ID, which sets it to 0 and set-ID, which sets it to specific value.


On another note, for anyone wanting to learn how a computer works, or what this enigmatic thing called assembly language is, have a look at this book (warning, direct pdf link), it explains the basic of computers and programming using assembly language.