[[MapGen.h]]
void MapGen()
{
	int MapSize = 0;
	int * P_MapSize = &MapSize;
	int MapSize_ResourceVar = 0;

#include "MapGen.h"
...
void Population_Start()
{
	MapGen ();
	int Lands = 0;
	int Population = 0;
	Lands = &MapSize / 4;
	Population = Lands;  //grr... define lands in MapGen().  Need pointers to work :)
	int Gold = 100;
	int * P_Gold = &Gold;
}

Lands = &MapSize / 4;

int a;
// Somewhere later
a = 5;

int a = 5;

#include <iostream>
using namespace std;

/* this function returns a pointer to its local variable */
int *set_val(int val)
{
        int i = val;
        cout << "i = " << i << endl;
        return &i;
}

int main(void)
{
        int *foo, bar;

        foo = set_val(42);

        bar = *foo;
        cout << "bar = " << bar << endl;

        /* previous call to cout wrote over the memory foo points to */
        bar = *foo;
        cout << "bar = " << bar << endl;

        return 0;
}

i = 42
bar = 42
bar = 134519616

Quote:

Original post by nibbuler Ahh... just checked out the scope of variables at cplusplus.com. I thought that I could treat anything I defined as a pointer as a global variable--big mistake (didn't know they would be deleted when the function ended).

void f()
{
    int *i=new int[200];
}

int *f()
{
    int *i=new int[200];
    return i;
}

void g()
{
    int *ptr=f();

    // do stuff

    delete [] ptr;
}

std::vector<int> f()
{
    return std::vector<int>(200);
}

void g()
{
    std::vector<int> v=f();

    // do stuff
}

Quote:

Original post by nibbuler Thanks for the tips! Ahh... just checked out the scope of variables at cplusplus.com. I thought that I could treat anything I defined as a pointer as a global variable--big mistake (didn't know they would be deleted when the function ended). Thanks again.

Quote:

Original post by EasilyConfused The above is very hard to break, and is unlikely to have any significant performance penalties. Even the apparent additional copy of the vector when being returned is likely to be optimised away by the compiler.

void f(std::vector<int>& v)
{
    v.clear();
    v.resize(200);
}

void g()

{
    std::vector<int> v;
    f(v);
    // do stuff
}

Quote:

Original post by Jerax You hope. Unless the function is inlined, I don't see how the compiler can avoid the copy.

Quote:

Original post by Jerax Personally for something like that I'd prefer passing a reference or pointer to an existing vector and filling it in the function:

std::vector<int> v=f();

Quote:

Original post by EasilyConfused However, all of the above are typical examples of the potential problems with using pointers directly in C++ and why you should almost always prefer to use standard library containers or smart pointers instead. std::vector<int> f() { return std::vector<int>(200); } void g() { std::vector<int> v=f(); // do stuff } The above is very hard to break, and is unlikely to have any significant performance penalties. Even the apparent additional copy of the vector when being returned is likely to be optimised away by the compiler.

Quote:

Original post by antiquechrono First of all...never use pointers? I scoff at that remark they are one of the reasons C and C++ are so powerful, without pointers there are tons of things you can not accomplish.

Quote:

Without an understanding of lower level ideas such as pointers you are missing out on how the computer acctually works, which is why people who only understand the higher level languages like Java can be passed up for jobs.

Quote:

Again no, the standard smart pointer that comes with C++ can be a pain to use and is not adequate for some cases.

Quote:

Also, the STL is painfully slow and unoptimized, it seems to be a myth that it is some sort of super fast uber optimized library programmed by God himself.

Quote:

... programming project you need to avoid these things like the black plague if you care at all about speed.

Quote:

If you still do not believe me just write out your own array based string class, for most of the generic string operations it will be hundreds of times faster than the standard string.

Quote:

Original post by antiquechrono I just wanted to point out the nonsense in this post for any confused third parties.

Quote:

Original post by antiquechrono First of all...never use pointers? I scoff at that remark they are one of the reasons C and C++ are so powerful, without pointers there are tons of things you can not accomplish.

Quote:

Original post by antiquechrono Without an understanding of lower level ideas such as pointers you are missing out on how the computer acctually works, which is why people who only understand the higher level languages like Java can be passed up for jobs.

Quote:

Original post by antiquechrono Always prefer standard library containers or smart pointers instead? Again no, the standard smart pointer that comes with C++ can be a pain to use and is not adequate for some cases. Also, the STL is painfully slow and unoptimized, it seems to be a myth that it is some sort of super fast uber optimized library programmed by God himself. It was not written to be fast, it was written to be portable. In any serious programming project you need to avoid these things like the black plague if you care at all about speed.

Quote:

Original post by antiquechrono If you still do not believe me just write out your own array based string class, for most of the generic string operations it will be hundreds of times faster than the standard string.

Quote:

Original post by antiquechrono I just wanted to point out the nonsense in this post for any confused third parties. First of all...never use pointers? I scoff at that remark they are one of the reasons C and C++ are so powerful, without pointers there are tons of things you can not accomplish.

Quote:

Without an understanding of lower level ideas such as pointers you are missing out on how the computer acctually works, which is why people who only understand the higher level languages like Java can be passed up for jobs.

Quote:

Again no, the standard smart pointer that comes with C++ can be a pain to use and is not adequate for some cases. Also, the STL is painfully slow and unoptimized, it seems to be a myth that it is some sort of super fast uber optimized library programmed by God himself. It was not written to be fast, it was written to be portable. In any serious programming project you need to avoid these things like the black plague if you care at all about speed.

Quote:

If you still do not believe me just write out your own array based string class, for most of the generic string operations it will be hundreds of times faster than the standard string.

• Your code does not provide full standard library functionality. This is alright, until you discover that you need said functionality. Besides, the functionality of many elementary constructs (such as vectors) is so simple that missing any part of it makes the result completely useless.
  
• Your code provides full standard library functionality. This means that the compiler writers could have used that implementation technique to write the standard library. And, you know what? They already have.

Quote:

Original post by EasilyConfused So by your "logic", I guess we should be advising beginners on this forum to learn assembly language before C then?

Quote:

Original post by EasilyConfused I'd be interested to see some profiling code that supports any of these claims. Hundreds of times faster?

Quote:

Original post by rip-off Array based? Do you mean an arbitrary upper limit character array? That is comparing apples to oranges.

Quote:

Original post by ToohrVyk A computer does not work 'like pointers'. Pointers have no representation of segmented memory or virtual memory layouts, and low-level memory has no concept of type or stride. Someone who lives with the illusion that the C or C++ operational semantics are somehow representative of computer architectures from the last decade is someone who is not going to be hired.

Quote:

Original post by ToohrVyk Now, this is downright stupid. Global replacement of one methodology with another (such as replacing all standard library code with your own) is not optimization, it's voodoo. Optimization consists in writing some working code as quickly as possible (which will involve using the standard library in almost every single case), and only then optimizing your code based on profiling data. Once you have access to profiling data incriminating standard library code for significant performance losses, you can do the local replacement. Reinventing standard library functionality without profiling data will result in almost every single case in spending dozens of man-hours, worsening code quality, and not achieving any observable result on the user side because you made ten times faster a portion of code which costs you a mere ten milliseconds per day.

Quote:

Original post by ToohrVyk Smart pointers (including boost::shared_ptr, and boost::optional references) and references are enough for 99% of cases. The cases not covered involve mostly pointer arithmetic, string literals and C function interaction, all of which should be cleanly tight-wrapped away from your actual C++ code anyway. Unlike C, programming in C++ is best done without naked pointers.

Quote:

Original post by rip-off Most of the things that you "cannot accomplish without pointers" have been implemented for you in the Standard C++ Library or Boost. Remember, this was posted in "For Beginners". Keep that in mind.

Quote:

Original post by rip-off In any case, I would value a programmer who only understands C++ pretty much the same as one who only knows Java. A good programmer is usually fluent in many languages.

Quote:

Original post by antiquechrono No, I said an array based string. A class that has a dynamically allocated array.

Quote:

Original post by ToohrVyk This is an interesting idea, but how come I never see any smart pointers used in acctual code or examples? My professors certainly have never even mentioned smart pointers before, do you have any resources I can look at discussing this because I have just been taught that *ptr is the way to go.

Quote:

Quote: Original post by rip-off Most of the things that you "cannot accomplish without pointers" have been implemented for you in the Standard C++ Library or Boost. Remember, this was posted in "For Beginners". Keep that in mind. Ever write a custom data structure before?

Quote:

The problem with Java is that there is really nothing inheriently hard in the language because everything is abstracted away. It may be easyer to learn but how much do you acctually understand if all you know is how to write Java code using the wonderful library where everything is written for you? I'm not bashing Java though it is a great language.

Quote:

Original post by antiquechrono Quote: Original post by ToohrVyk A computer does not work 'like pointers'. Pointers have no representation of segmented memory or virtual memory layouts, and low-level memory has no concept of type or stride. Someone who lives with the illusion that the C or C++ operational semantics are somehow representative of computer architectures from the last decade is someone who is not going to be hired. I'm not sure if you are doing quantum computing or something, but last I checked the most basic functionality of a processor is to fetch instructions from an address and execute them and in the process more than likely manipulate data which is at another address. It has no concept of a variable, just an addresses to data. Now call me old fashioned but that sounds an awful lot like what a pointer is.

Quote:

Well you are kind of responsible for starting the thread hijack into code and compiler optimization, I suppose that is a beginners topic as well?

Quote:

I'm just speaking from limited but practical experience. I wrote an RSS feed parser which is obviously heavily text based. I ran callgrind on it and most of my code without surprise was spent manipulating strings thus the reason I wrote my char array based string class which ran circles around the standard string for my purposes.

Quote:

I'm not sure if you are doing quantum computing or something, but last I checked the most basic functionality of a processor is to fetch instructions from an address and execute them and in the process more than likely manipulate data which is at another address. It has no concept of a variable, just an addresses to data. Now call me old fashioned but that sounds an awful lot like what a pointer is.

Quote:

The problem with Java is that there is really nothing inheriently hard in the language because everything is abstracted away. It may be easyer to learn but how much do you acctually understand if all you know is how to write Java code using the wonderful library where everything is written for you? I'm not bashing Java though it is a great language.

Quote:

This is an interesting idea, but how come I never see any smart pointers used in acctual code or examples? My professors certainly have never even mentioned smart pointers before, do you have any resources I can look at discussing this because I have just been taught that *ptr is the way to go.

Quote:

Original post by SiCrane Quote: Original post by antiquechrono Quote: Original post by ToohrVyk A computer does not work 'like pointers'. Pointers have no representation of segmented memory or virtual memory layouts, and low-level memory has no concept of type or stride. Someone who lives with the illusion that the C or C++ operational semantics are somehow representative of computer architectures from the last decade is someone who is not going to be hired. I'm not sure if you are doing quantum computing or something, but last I checked the most basic functionality of a processor is to fetch instructions from an address and execute them and in the process more than likely manipulate data which is at another address. It has no concept of a variable, just an addresses to data. Now call me old fashioned but that sounds an awful lot like what a pointer is. And this is exactly why your assumption that pointers are an accurate model of how a computer actually works is harming you. And old fashioned. Actual computer memory models are much, much more complex than that for almost any computer produced since 1978. And probably even earlier than that. It's a point of view that completely ignores real details like virtual memory, TLBs, cache, page tables and other details of computer architecture hidden behind the pointer abstraction that can have a real effect in program performance, and are thus important for a professional programmer to understand. Not to mention this understanding is required to take full advantage of extensions to the traditional memory models, such as the Windows AWE.

Quote:

Original post by antiquechrono I'm not sure if you are doing quantum computing or something, but last I checked the most basic functionality of a processor is to fetch instructions from an address and execute them and in the process more than likely manipulate data which is at another address. It has no concept of a variable, just an addresses to data. Now call me old fashioned but that sounds an awful lot like what a pointer is.

Quote:

This is an interesting idea, but how come I never see any smart pointers used in acctual code or examples? My professors certainly have never even mentioned smart pointers before, do you have any resources I can look at discussing this because I have just been taught that *ptr is the way to go.

Quote:

Original post by Mike.Popoloski Do you have any good links for required reading on subjects like this? This is the sort of stuff I never get into, or never see referenced anywhere. When you guys get going with these low level discussions I always read along to catch the little bits of interesting info that get scattered all over. I found that article on Named Return Value Optimization to be quite interesting actually.

Quote:

Original post by antiquechronoMy professor who acctually worked "in industry" directly stated that no one who writes professional code "in industry" uses the STL and all the companies rewrite it and even had us do all our projects without it.

Quote:

Original post by ToohrVyk Then, there's the pipeline. Your typical processor today has between 9 and 30 pipeline stages, which are yet again completely unknown to the C language. Pipeline stages include fetching the instruction, decoding it, fetching memory, processing, waiting, retrieving, outputting, and so on. This is a fundamental point in optimization, because a full pipeline stall in a 30-stage pipeline will divide your performance by 30. In our situation here, using either z or the contents of the buffer nearby the write point will result in read-before-write conflicts and will stall the pipeline for the length of the increment processing.

Quote:

Original post by Jerax Also using z can only conflict if it's a write to z (since z is only read in the above example).