Posts by deceptikon

i suck because i had zero knowledge on Unix or Linux

No, that's silly. Will learning other operating systems help round you out as a developer? Sure. Does your "goodness" as a programmer depend on knowing *NIX platforms? Absolutely not.

Let me put it this way. I'm primarily a Windows developer, but I do know several Unix variants. In my work, that knowledge has benefitted me in only four areas:

• Converting Linux-specific code to Windows (rare).
• IT support/consulting where a Unix system is in place.
• Navigating a Linux web server.
• Recognizing file formatting differences between Windows and Unix (eg. newline representation).

In other words, the benefit has been largely minimal and I could easily have managed without any intimate knowledge of *NIX.

Done. Show me yours and I'll show you mine.

Undefined behavior is unpredictable by definition. You could certainly figure out why it "works", but it would be specific to that version of that compiler.

At a glance, the logic looks okay. There are some nasty habits that should be eliminated though:

#include<conio.h>

The conio library is not needed in this program, it and all functions from it should be removed to maximize portability. This header is not standard, so you're basically limiting yourself to Turbo C variants.

void main()

This is not standard either. If the compiler supports it, you're fine. If the compiler doesn't support it, you've invoked undefined behavior. Given the risk, it's much better to simply use int main() and return 0 at the end.

gets(str);

Please forget that gets exists. In the latest standard it's been deprecated, and there's no way to make it safe. If you try to input a string with more than 99 characters, you're basically screwed. fgets is the recommended alternative.

I won't go into a rant about clrscr and getch, because they're both functions from the conio library and I've already recommended that they be removed. However, if you want, I can go into more detail about why they're bad in this case.

One problem with the logic is that it doesn't take punctuation into account. Let's say your sentence is "Hi fellow pickles, I'm a pickle too!!!!!!". You'd incorrectly say that "too!!!!!!" is the longest word, because bangs aren't excluded from the count.

Ok, so I tried to change my class properties as Pritaeas suggested, but this didn't work.

It should work, but it's hard to tell why not without seeing a complete bare bones example that exhibits the problem.

Would this be an appriopriate use of (get;set;)?

Yes. In fact, that would be my default choice for publicly accessible data items:

public class TCard
{
    public int Suit { get; set; }
    public int Rank { get; set; }
}

Though in this case I'd prefer to also write classes or enumerations representing suit and rank, since just using int means you'd end up having to validate and error check invalid values.

Yes, someone can help. What do you have so far? If you don't have anything, what's your thought process for working it out? Have you analyzed the structure of a sentence to break it down into words?

Note that "help" does not constitute doing work for you.

I'm a little confused about inlining member functions.

It would help to understand how regular functions typically work. A single definition of the code is created, then calling code jumps into the definition to execute the function. Inlined functions have their bodies essentially pasted directly where the call is so that there's no jump and relatively little bookkeeping overhead. For smaller functions that aren't called in a great many places, this can improve performance.

But beware, because inlined functions can also degrade performance by increasing the code size to the point that it crosses cache lines. Or if the function isn't completely CPU bound, any benefit of inlining can easily disappear.

Does all code actually have to be on one line

No, though the shorter the function is, the higher the chance of it actually being inlined. Note that marking a function as inline (or putting it in the class declaration) is just a hint, the compiler is free to ignore it.

or does it simply mean writing the whole function inside the class rather than from outside using the :: syntax?

You can define the function outside of a class and use the inline keyword to the same effect.

Wouldn't have been easier to use iTextSharp instead?

Last I checked, iTextSharp didn't support PDF rasterization directly.

Are any particular one which should be used at specific times?

I favor the guideline that you should use '\n' unless you know that the stream must be flushed immediately and nothing else consistently does it for you. Times where you have a lone output statement and the stream must be flushed with std::endl or std::flush are surprisingly rare, mostly due to tied streams:

cout << "Prompt: "; // No consistent flushing here
cin >> choice; // This statement flushes cout for you

I understand endl flushes the stream (although i'm not 100% what this means)

When an output stream is flushed, the internal buffer is sent to the destination device. For performance reasons, when you write characters to a stream they're collected into a buffer. Then when the buffer fills up, it's written in toto to the target device. The performance benefit is that a potentially expensive operation is minimized by reducing the number of times it happens.

why they put it ??

They're being explicit, I suppose. If a function returns void, there's no need to place a return at the end. Falling off the closing brace does it automagically.

what is the logical meaning of it ??

It means that the function will hand execution back to the calling function, but return no value.

is it the same as (return0;) ??

No. return 0; does return a value, and cannot be used in a function with a return type of void.

Put simply, ASP.NET does web pages and WCF does client/server communication.

Welp, since ddanbe covered the second error, I'll mention the first. You have a name conflict. The class and method are both called Main. Since the method has to be called Main, change the class to something like Program and the compiler should properly report that your floating-point literal needs a type qualifier.

Did you figure it out? As mentioned before, I really am trying to help, but without flat out giving you the answer.

Only OP Kudos members can ask every type of questions without showing their efforts.

On the contrary, our rules apply across the board. Everyone is required to adhere to them or risk punishment; kudo posters, featured members, moderators, admins, even Dani herself.

On a side note, the technique you're showing is called type punning. It's rather common in lower level code. If you're feeling frisky, an example of union-based punning to break down a floating-point value can be found in one of my teaching libraries here and here.

In the same way , if u say int *a = 5 , then a is the same as arr or &arr[0]. its just a pointer that points to a certain memory.

Noting, of course, that an array is not a pointer. Though an array name in most contexts is converted to a pointer.

In fact , you can just as well write printf("%d",c[1]) instead of printf("%d\n",*(c+i)) , Both mean the same thing to the program

Further solidifying the equivalence, you can also write printf("%d", 1[c]) because addition is commutative. Don't do that in real code though, it's an interesting yet useless trick.

Lastly , You do get a warning : initialization from incompatible pointer type when compiling

Which is cleared up with a cast. It's important to understand the warnings and avoid them where necessary. But if the warning is known to be spurious, it's best to make it go away so that the compilation log is clean. That way real warnings and errors stand out more.

I also think it maybe best if DaniQueen introduce a way to decrease points to those who are doing this

I'm not entirely sure what you mean by "points", but voting and reputation work both ways. If you find someone spoonfeeding beginners, then by all means given them a downvote or negative rep. What you're asking for already exists. :)

The compiler is correct, varying doesn't exist at that point. You declare it in textBox1_TextChanged, but try to use it in a completely different method. Why not just use textBox1.Text directly and not worry about handling TextChanged?

MessageBox.Show("Hello!", textBox1.Text, MessageBoxButtons.OK);

Or do you just not ask that question and automatically stay away from any undefined operations?

No and yes, respectively. Undefined behavior is super bad, but questioning why something is undefined improves understanding of the concept and helps one to avoid it in cases that aren't textbook examples.

What's your preferred method for saving your program's settings?

It depends on the settings and the complexity of the program in my case. For simpler things, I prefer app.config. For more complex things I prefer my own XML file using serialization. Sometimes I'll go with storing settings in a database. The registry is not recommended.

Is there a preffered industry standard?

Not a single one. :)

Does .Net provide a namespace for reading writing a programs settings?

Yes. The API that facilitates app.config is exposed for you to use. However, unless you're using it in conjunction with app.config, things get hairy. I vastly prefer managing custom XML or INI separately.

As VS creates settings in XML in the app.config file should I sipmly take this as preferred.

That should be your default preference when all else is equal.

It's impossible to answer your question as asked because the benefits of cores versus clock speed are situational. What's the average use case of the intended machine?

You can't do that. There is no way other people can use your "project" without also having purchased and installed MS Access.

I'll be sure to let my clients know that the software they're using is impossible. ;)

I need to be able to take a string and put it into an array of chars, how can i do this?

If the string is a literal, it's as easy as this:

char test[] = "08/11/2014";

If the string is obtained some other way, and all you have is a pointer to it, you need to create an "array" that can hold it, and copy the characters. In this case, I'd suggest dynamic memory:

// Don't forget to include space for the null character
char *test = malloc(strlen(dat) + 1);

// Always check for failure
if (test)
{
    strcpy(test, dat);

    ...

    free(test); // All done, clean up the mess
}

The problem with some random string you know little about is you don't know the size. So it's tricky to use an array proper due to requiring a compile-time constant[1].

[1] Yes, C technically allows variable length arrays starting with C99. However, they're not recommended for various good reasons. Let me know if you want more detail on why VLAs should be avoided in favor of more classic techniques.

Haaaa 'weenie points'

Everyone seems to like my peen points terminology. :D

I'm 33 guys, im not fussed about reputation.

Same age as me. I'd be lying if I said reputation doesn't affect me, but typically it only matters when coming from someone I respect. If Mike ever downvoted me or gave me negative rep, for example, it would sting more than some drive-by no name McWhothehellareyou.

"But it works because I've just tested it. Why is it wrong?"

Heh, I get that at work all the time. It's tough explaining how something is wrong even though it happens to work at the time.

is the down voter tallented enough to know its wrong and down vote it whilst at the same time not being bothered to provide a solution or help.

Unlikely. We all have huge egos, and a big part of being right is making sure everyone knows we're right. Anonymous voting doesn't contribute toward that goal. ;)

Of course, then there's the risk of making an incorrect correction. But the ego blinders have a large effect. I can guarantee from experience that knocking someone down a few notches after they correct you with their own mistake is pure pleasure. If you haven't had the chance to do that yet, I'd strongly recommend sticking around until you do.

Imagine an array:

{1, 2, 3, 4, 5, 6}

Now imagine dividing it up into pairs:

{1, 2}
{3, 4}
{5, 6}

Then swap each pair:

{2, 1}
{4, 3}
{6, 5}

Put back together you have the final result:

{2, 1, 4, 3, 6, 5}

Which in pseudocode would be something like this:

a = {1, 2, 3, 4, 5, 6}
n = 6
i = 0

While (i < n)
    # Swappy swap
    temp = a[i]
    a[i] = a[i + 1]
    a[i + 1] = temp;

    # Jump to the next pair
    i = i + 2
Loop

Need it in 15 mins

Yeah...15 minutes would be really pushing it even for an expert who knows exactly what to write and doesn't require any debugging.

I'm happy to offer advice to help you learn when you have more time, but for this particular project, you're SOL.

Internet recources on algorithms are suprisingly sparse, especially compared to "regular" programming.

Ironically, my go-to quick reference for algorithms and data structures is a website. It's the most complete reference in a single location to the best of my knowledge, and tends to be recently updated. Not perfect, but a book certainly won't be either. You'll learn to use multiple references in such cases.

in·her·i·tance (n)

1. money, property, etc., that is received from someone when that person dies
2. something from the past that is still important or valuable
3. the act of inheriting something

So, why are we dividing the thing in headers(declarations) & cpp (defintions) ? We can write defintions in headers also.

That introduces the problem of multiple definitions. C doesn't really have an explicit one definition rule like C++, but in practice it's there. You can have as many redundant declarations as you want, but the instant you have two of the same definition in a translation unit, you're borked.

Secondly, In your example, as printf defintions is changed, then we need to change all the usages of the printf() also as you do. In that case also, my code will crash because I am using the old format only. If we can change all the lines where printf is used so as to make our code compatiable, then we can change the declartion also. what's the major use?

I was hoping you'd catch on to that. The answer is yes indeed, though fixing the declarations adds yet another thing you need to remember to change.

Now for the example I really wanted to give originally. Here's what actually happened when C99 changed declarations. Before, printf looked like this:

int printf(const char *fmt, ...);

Afterward, it looked like this:

int printf(const char * restrict fmt, ...);

On top of being a tossup as to whether that will cause compilation errors, how would you know about the change without closely monitoring the C standard?

The solution I gave will work for the int surely but it might give wrong for the double. Am I right?

You are correct, sir! And why is that? :)

Actually, I am confused that what the problem was there in C and how c++ has solved it.

Let's say you have two libraries with a print function in C. How do you use them both at the same time? The answer is you don't, at least not without writing a wrapper library of your own that uses unique names to resolve the conflict. In C++, those functions would (should!) be wrapped in a namespace and there's no problem from the start.

For ex: if I say 'string' that means diffferent if I say std::string. Right?

Conceptually, yes. It's complicated with things like using namespace std, but the core of namespaces is indeed to ensure a unique name.

Headers has just the declarations as I already know. namespaces include all the definitons? right?

Namespaces don't include anything. A more accurate way to describe it would be that headers contain declarations and declarations may be wrapped in namespaces to guarantee uniqueness.

but how is it resolved by compiler that which function to call?

Compiler magic. ++T1 gets converted to T1.operator++() and T2++ gets converted to something like T2.operator++(0) under the hood. There's no ambiguity to resolve, the compiler recognizes which operator you used and calls the correct overload.

"Number" is ambiguous. Let's throw a wrench into the mix:

double a, b;

Beware, the answer isn't as simple as you think. :D

Why will I need to update each and every source file?

For fun, let's use printf as our example even though it's unlikely to change for the forseeable life of C.

int printf(const char *fmt, ...);

int main(void)
{
    printf("Hello, world!\n");
    return 0;
}

You do that in every source file where you use printf, right? Because you don't want to include stdio.h yet still need a declaration. Now the standards committee decides to add another required parameter to printf and you upgrade to a compiler that implements this change. Suddenly your code breaks because printf can't be found, and you must modify the declaration in all of those files (once again, because you didn't want to include stdio.h):

int printf(const char *fmt, int level, ...);

int main(void)
{
    printf("Hello, world!\n", 0);
    return 0;
}

Why does it need int in postfix and not in prefix?

This is a case of Bjarne Stroustup being too clever. The two member functions need a different signature to resolve ambiguity between them. C++ doesn't differentiate between return types when comparing signatures, so it has to be done with either a function name or parameters. In the case of operator overloading, you can't change the name, so the only option without adding a new language feature is to require a dummy parameter. That's what the int parameter for postfix ++ does.

Just try out this code. Hope it may be useful for you.

That code is pretty awful, even after adding reasonable indentation. Let's hit the low hanging fruit first.

#include<conio.h>

This is a good indicator of bad code, because it's usually unnecessary. Further look at the code confirms that this is the case for your code. All you've done is hurt portability by requiring a non-portable library when it's not needed.

void main()

This is also non-portable. If the compiler supports it, okay. If not, you've invoked undefined behavior. Not a good trade off. Especially when the code can be made correct across the board by using int main() and returning 0.

int w = 0, i = 0, j = 0, l, a[10], big;
char ch[25], st[10][20];

Variable names suck and are uninformative. The code is much harder to read as a result.

clrscr();

Unneeded, non-portable, antisocial, and anyone who does this should be ashamed. Put simply, if you create a console program that doesn't explicitly own the console and clears the screen, you'll piss off a lot of users who find the results of previous programs suddenly erased. Or maybe not, because nobody will want to use your program.

printf("Enter the string:");

stdout isn't flushed, so there's no guarantee this prompt will be visible before blocking for input. Unless you print a newline in the prompt, it's a good idea to call fflush.

printf("Enter the …

Playing with the structure examples in the book reminds me of accessing attributes to a python Class

That's not a bad analogy. A structure in C++ is just a class with different default access (public instead of private). A union is different in that all members of a union share the same block of memory rather than each member having its own block of memory.

May be any platform, any compiler, I just want to do the complete procedure myself.

The complete procedure really does vary between compilers and operating systems and the documentation for your compiler will give you specific instructions.

For a static library it's super easy. Just create a standalone project with the functions and types you want, compile, and add the resulting object files to a static library file (typically .a or .lib). From there you link to the library file as normal.

Shared libraries may be a smidge harder depending on your OS. DLLs in Windows require some coding effort in the library itself, for example.

What about this part? How do you handle this?

All of them are under the programmer's complete control. I handle it by not writing stupid code. ;)

No-throw guarantee: this function never throws exceptions.

All functions in C have a no-throw guarantee. Why? Because C doesn't support exceptions in the first place. ;)

If str does not point to a valid C-string

Yup. The same goes for strlen, or strcpy, or anything that expects a valid C-string by definition. The strings contained by argv are guaranteed to be either a valid C-string or NULL. For other strings, a C-string is defined as zero or more characters followed by '\0'. In this case it's a matter of defensive coding to ensure that you don't produce an invalid string.

And of course, NULL is a simple check if there's any possibility of receiving it.

or if endptr does not point to a valid pointer object, it causes undefined behavior.

Noting that NULL is a valid pointer object, this too is a matter of defensive coding. Make sure your pointers point to an actual object or set them to NULL.

Am I using the +1 wrong?

There's not really a way to use it wrong, barring full out abuse like automatically downvoting every post from a member regardless of post content.

Typically I use the voting system as a type of kudos. If I think a post is well written and insightful, upvote. If I think a post is rude and unproductive, downvote. If the post is meh or otherwise average, no vote. Exceptionally good or bad posts get a comment and corresponding rep.

But try again after including the library function #include<conio.h> as well.

Not only will this not solve the problem, it also destroys code portability by requiring the compiler to support a non-standard library.

@deceptikon, is that still the case on most modern implementations?

Yes. In the past the biggest problem with modulo (where small ranges were concerned) was an artifact of low order bits not being as "random", and that's largely been fixed in modern implementations. But the distribution problem remains since it's more of a fundamental mathematical thing; pigeonholing a larger range into a smaller range can be tricky.

A better approach in terms of distribution (assuming the generator gives you a uniform distribution within its natural range) would be something more like this:

int r;

do
    r = rand();
while (!inrange(r, min, max));

With this you're working within the uniform distribution rather than fighting against it.

High modulo divisor with low number of samples is less uniform distribution; but the lower the modulo divisor and higher the number of samples the more uniform the distribution becomes.

True. But typically when you care about the distribution, any bias tends to be too much. ;)

In the program below what is the difference between rand and srand?

rand generates a pseudorandom number. srand seeds the generator that rand uses. The seed essentially determines what the first random number will be and affects subsequent numbers in the sequence. If you don't call srand, the seed is always 1, so the sequence you get will be predictable.

Yet this code returns a number from 1-6, how is that?

Take any number between 0 and 32767, then apply modulo 6. This will force the number into the range of [0,5]. 1 is added to shift the range to [1,6]. You can play with the idea using a calculator, it's simple math. :)

Note that this is a naive technique for fitting the result of a random number generator into the range you want. It's weak because it severely damages the distribution of random numbers, but that's sometimes acceptable.

Vague much?

but neither seem to be working for me.

On a side note, String and string are equivalent. string is a keyword alias for System.String.

Never assign raw data directly to an uninitialised pointer. If done so, where would the pointer point to? Where will the raw data be stored? Maybe it will compile, maybe it won't. Maybe it could lead to disastrous effects. You have to make sure a pointer points to something (safe) before using it. So: char *st="myname"is plain wrong.

Um...what? char *st="myname" is fine. The pointer is initialized and points to a string literal. The only disastrous thing involved is the read-only status of the string literal, and that's only a problem if subsequent code tries to modify it through the pointer.

if we don't use return then there is no value returned to the function?

It's not quite that simple. For extra credit, try to explain what's happening here:

#include <stdio.h>

int foo()
{
}

int main(void)
{
    printf("%d\n", foo());
    return 0;
}

Because if the fields are public, users of the class have unrestricted access to them. Exposing fields through properties introduces a controlled interface. Presumably your question is about this:

class Foo
{
    private int _bar;

    public int Bar
    {
        get { return _bar; }
        set { _bar = value; }
    }
}

This is indeed not much better than making _bar public. The only benefit here is that you have the option of controlling access in the future without changing the public interface. For example, let's say that you later decide Bar can only have a range of [1,10):

class Foo
{
    private int _bar;

    public int Bar
    {
        get { return _bar; }
        set
        {
            if (value > 0 && value < 10)
            {
                _bar = value;
            }
        }
    }
}

This cannot be done if _bar was public originally.

General best practice is for private fields to be used for anything that only the class has access to, public fields should not be used without very good reason, and public properties should be used to expose a controlled interface to private fields if needed.

Your company's IT department will have either an installation disk or a repair disk for your computer. The former requires a product key that the same department will have, though they'll probably ask to install it themselves rather than give it out to you. Since it's your company's property, I would strongly recommend talking to them about your need.

On a side note, asking for product keys to licensed software is illegal and against Daniweb's rules. We'll help direct you to getting a legit copy of Windows installed on your laptop, but we won't help you with anything that smells of piracy.

http://www.daniweb.com/home/tos
http://www.daniweb.com/community/rules

Each forum may have stickies at the top with specific guidelines for posting within that particular sub-community.

IRC is an internet protocol. mIRC is a chat application using that protocol.