Q: accessing element 0 in string array makes it crash I am declaring the following array 
  string names[4]  = { "grass" , "smallGrassBlock" , "dirt" , "sand" };

and then         
extern string names [];`

However it crashes when I do this: 
string ss=names[0];

All relevent code:
Main:
     #include<stdlib.h>
        #include<windows.h>
        #include<GL/glut.h>
        #include<GL/freeglut.h>
        #include<iostream>
        #include <vector>
        #include "include/Block.h"
        #include <string>

        extern string names [];
        void initTextures();
        GLint GetTexture(string file);
        void IdleFunction();
        void removeBlock(int x,int y);
        int xOffset,yOffset = 0;
        using namespace std;
        string to_string(int number);
        void placeBlock(int x,int y);
        void drawBitmapText(char *string, float x, float y, float z);
        void reshape(int w, int h);
        void render(void);
        void keyboard(unsigned char c,int x,int y);
        void mouse(int button,int state, int x, int y);
        void arrows(int key, int x, int y );

        std::vector <Block> blockList;
        GLuint  textures[1];
        int screenXSize=800;
        int screenYSize=800;
        int selectedBlockType = 1;
        int main(int argc, char ** argv){


        blockList.push_back(Block(0,-111,-111));


        string s = blockList.at(0).getName();



        glutInit(&argc,argv);
        glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
        glutInitWindowPosition(100,100);
        glutInitWindowSize(screenXSize,screenYSize);
        glutCreateWindow("TITLE");
        glutDisplayFunc(render);
        glutReshapeFunc(reshape);
        glutKeyboardFunc(keyboard);
        glutIdleFunc(IdleFunction);
        glutSpecialFunc(arrows);
        glutMouseFunc(mouse);

        glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
        initTextures();

        glutMainLoop();








        }
        void initTextures(){



         for(int i =0; i<=2; i++){
            string file = "C:/Users/Samuel/Documents/Documents/projects/test/MapCreator/"+names[i]+".png";


            textures[i]=GetTexture(file);










}


        }
       GLint GetTexture(std::string Filename)
{
    GLuint tex_ID;

    tex_ID = SOIL_load_OGL_texture(
                Filename.c_str(),
                SOIL_LOAD_AUTO,
                SOIL_CREATE_NEW_ID,
                SOIL_FLAG_POWER_OF_TWO
                | SOIL_FLAG_MIPMAPS
                | SOIL_FLAG_MULTIPLY_ALPHA
                | SOIL_FLAG_COMPRESS_TO_DXT
                | SOIL_FLAG_DDS_LOAD_DIRECT
                | SOIL_FLAG_INVERT_Y
                );

        if( tex_ID > 0 )
        {

            glEnable( GL_TEXTURE_2D );
            glBindTexture( GL_TEXTURE_2D, tex_ID );

            return tex_ID;
        }
        else{
            cout<<"Texture failed to load";
            return 0;
}}

        void arrows(int key, int x, int y ){

        if(key==101){


           selectedBlockType++;

           if(selectedBlockType > blockList.at(0).getTotal()){
            selectedBlockType=1;

           }


        }
        if(key==103){
            selectedBlockType--;
           if(selectedBlockType < 0){
            selectedBlockType=blockList.at(0).getTotal();

           }
        }

        }
        void IdleFunction()
{
    glutPostRedisplay();
}

        void mouse(int button,int state, int x, int y){
y+=15;
x-=15;

            if(button==GLUT_RIGHT_BUTTON){
        removeBlock(x,y);

            }
             if(button==GLUT_LEFT_BUTTON){
        placeBlock(x,y);

            }


        }
        void keyboard(unsigned char c,int x,int y){

    //wasd
        if(c==119){
           yOffset+=30;
        }
        if(c==97){
            xOffset-=30;
        }
            if(c==115){
            yOffset-=30;

        }
        if(c==100){
            xOffset+=30;
        }
            if (c==27){
                exit(0);
            }


        }

    void removeBlock(int x, int y){

    y-= yOffset;
    x+=xOffset;
    y-=400;
    y*=-1;
    y+=400;


int xmod = x%30;
    x-=xmod;
    if(xmod>=15){
        x+=30;
    }
    int ymod = y%30;
    y-=ymod;
    if(ymod>=15){
        y+=30;
    }
   for(int i = 0; i<blockList.size();i++){

        if(blockList.at(i).getX()==x){

           if(blockList.at(i).getY()==y){


            blockList.erase(blockList.begin()+i);


           }
        }
    }



    }


        void placeBlock(int x, int y){
            y-= yOffset;
            x+=xOffset;
    y-=400;
    y*=-1;
    y+=400;

    //gets it on the grid lines
    int xmod = x%30;
    x-=xmod;
    if(xmod>=15){
        x+=30;
    }
    int ymod = y%30;
    y-=ymod;
    if(ymod>=15){
        y+=30;
    }

    bool there=false;

    for(int i = 0; i<blockList.size();i++){
        if(blockList.at(i).getXMin()<=x&&blockList.at(i).getXMax()>=x&&blockList.at(i).getYMin()<=y&&blockList.at(i).getYMax()>=y){
            there=true;
            cout<<"cannot place there!"<<endl;
        }
    }
    if(!there){



    blockList.push_back(Block(selectedBlockType, x, y));



    }

        }

    void reshape(int w, int h)
    {

       glViewport (0, 0, (GLsizei) w, (GLsizei) h);
       glMatrixMode (GL_PROJECTION);
       glLoadIdentity ();
       gluOrtho2D (0, (GLdouble) 800, 0, (GLdouble) 800);
       glutReshapeWindow(screenXSize,screenYSize);

    }
    void drawBitmapText(char *string, float x, float y, float z)
    {
        char *c;
        glRasterPos3f(x, y, z);

        for (c=string; *c != '\0'; c++)
        {
            glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, *c);
        }
    }
        void render(void){


        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);


    for(int i = 0; i<blockList.size();i++){


     blockList.at(i).render(xOffset,yOffset,textures[blockList.at(i).getType()]);

    }

    glColor3f(0,0,0);
    //This creates the grid
    //Should be broken every 30
        for(float f = 0;f<800; f+=30){
        glBegin(GL_LINE_STRIP);
            glVertex2f(f,0);
            glVertex2f(f,800);
            glEnd();
            glBegin(GL_LINE_STRIP);
            glVertex2f(0,f);
            glVertex2f(800,f);
            glEnd();

        }

    glColor3f(0.35,0.35,0.35);
    string s = to_string(selectedBlockType);

string ss=names[0];
cout<<"YAY"<<endl;
cout<<ss;
cout<<endl<<"Selected"<<selectedBlockType;
    s=s+" "+names[selectedBlockType];
cout<<"YAY"<<endl;


    char *c = (char*)s.c_str();
        drawBitmapText(c,5,760,0);




        glutSwapBuffers();

        glFlush();

        }

        string to_string(int number){
        string number_string = "";

        char ones_char;
        int ones = 0;
        while(true){
            ones = number % 10;
            switch(ones){
                case 0: ones_char = '0'; break;
                case 1: ones_char = '1'; break;
                case 2: ones_char = '2'; break;
                case 3: ones_char = '3'; break;
                case 4: ones_char = '4'; break;
                case 5: ones_char = '5'; break;
                case 6: ones_char = '6'; break;
                case 7: ones_char = '7'; break;
                case 8: ones_char = '8'; break;
                case 9: ones_char = '9'; break;

            }
            number -= ones;
            number_string = ones_char + number_string;
            if(number == 0){
                break;
            }
            number = number/10;
        }
        return number_string;
    }

Block header:
    #ifndef BLOCK_H
#define BLOCK_H
#include <string>
#include <iostream>
#include<GL/freeglut.h>
#include <soil.h>


using namespace std;

class Block
{
    public:
        int getXMax();
        int getXMin();
        int getYMin();
        int getYMax();
        Block(int,int,int);
       int getX();
       int getY();
       static int getTotal();
       int getType();
       void render(int,int,GLuint);
       string getName();
       string getNType(int i);
        virtual ~Block();
    protected:
    private:

 int x,xsize,ysize,y,Type,size;

};

#endif // BLOCK_H

Block: 
     #include "../include/Block.h"
        #include <string>
        #include <iostream>
        #include<GL/freeglut.h>
        #include <soil.h>

        using namespace std;



  string names[4]  = { "grass" , "smallGrassBlock" , "dirt" , "sand" };




        Block::Block(int type, int X,int Y)
        {
            size=3;
            Type=type;
            x=X;
            y=Y;

            switch(Type){
    case 0:
        xsize=546;
        ysize=217;
        break;
        case 1:

        xsize = 200;
        ysize=95;
        break;
        default:
            xsize=30;
            ysize=30;
            break;
            }

        }
         int Block:: getTotal(){
        return 3;
        }

        int Block::getX(){
            return x;
        }
        int Block::getY(){
            return y;
        }
        int Block::getXMin(){
        return x-(xsize/2);
        }
        int Block::getYMin(){
        return y-(ysize/2);
        }
        int Block::getXMax(){
        return x+(xsize/2);
        }
        int Block::getYMax(){
        return y+(ysize/2);
        }
        int Block::getType(){
        return Type;
        }
        string Block::getName(){




        return names[Type];;
        }
        string Block::getNType(int i){
        return names[i];

        }

        void Block:: render(int xOffset,int yOffset,GLuint texture){

        if(texture==0){


        }



        x-=xOffset;
        y-=yOffset;
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
         glEnable( GL_BLEND );
         glClearColor(0.0,0.0,0.0,0.0);

         glEnable(GL_TEXTURE_2D);
         glBindTexture(GL_TEXTURE_2D, texture);
            glBegin(GL_POLYGON);
                glTexCoord2f(1,1);  glVertex2f(x+(xsize/2), y+(ysize/2));
              glTexCoord2f(1,0);  glVertex2f(x+(xsize/2), y-(ysize/2));

                glTexCoord2f(0,0);  glVertex2f(x-(xsize/2), y-(ysize/2));
              glTexCoord2f(0,1);  glVertex2f(x-(xsize/2), y+(ysize/2));




            glEnd();
            glDisable(GL_TEXTURE_2D);
            glDisable( GL_BLEND );
            glClearColor(1.0,1.0,1.0,0.0);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);


             glPopAttrib();
        x+=xOffset;
        y+=yOffset;

        }
        Block::~Block()
        {


            //dtor
        }

Further information:
The program does not crash when getting any valid element other than 0, nor does it provide an error message.

A: It is not clear how you implemented your program. The following is the test case that I wrote. It ran fine without any problem using Microsoft C++ compiler (cl.exe).
Test.cpp
#include <iostream>
#include <string>
using namespace std;
extern string names[];

int main()
{
  cout << names[0] << endl; 
  return 0;
}

Test2.cpp
#include <string>
using namespace std;
string names[4]  = { "grass" , "smallGrassBlock" , "dirt" , "sand" };

Compile command:
cl.exe test.cpp  test2.cpp


A: If your code is like this, then this works fine 
main.cpp
extern string names[];
int main() {
  string ss = names[3];
  cout <<  ss << endl; 
  cin.get();
}

string.cpp
#include <string>
using namespace std;
string names[4]  = { "grass" , "smallGrassBlock" , "dirt" , "sand" };

Note: Keep both the files in the same project.
OR compile both the .cpp files together
gcc main.cpp other.cpp

