Thread: Definition of const strings in .cpp files

Originally Posted by jimblumberg

First make sure your header file has include guards in place.

Yes it does.

Code:

#ifndef SYMBOLS_H
#define SYMBOLS_H

typedef enum {  error_k,
                plus_k,
                minus_k,
                mult_k,
                div_k,
                lparen_k,
                rparen_k,
                numeric_k,
                end_k
} symbol_t;

const char *symbol_string[] = {
                "Error",
                "+",
                "-",
                "*",
                "/",
                "(",
                ")",
                "Num",
                "End"
};
#endif

This file is included in: ast, lexer and a parser all which need the symbol definitions.

Edit:

Here's the makefile as well

Code:

CC = /opt/local/bin/clang++-mp-3.2
CFLAGS = -W -Wall -Wextra -pedantic

calc: parser.o ast.o lexer.o 
        $(CC) $(CFLAGS) parser.o ast.o lexer.o 

parser.o: parser.cpp
        $(CC) $(CFLAGS) -c parser.cpp

ast.o: ast.cpp
        $(CC) $(CFLAGS) -c ast.cpp

lexer.o: lexer.cpp
        $(CC) $(CFLAGS) -c lexer.cpp

clean:
        rm *.o

Basically, I need a way to forward declare the symbol_string so that it's recognized, and be able to define it in the .cpp file. Or if there are any other methods to do this, well I would like to know.

Originally Posted by jimblumberg

You should probably be using the extern keyword for this variable and defining this variable (without the extern) in one of your source files.

Your include:

Code:

extern const char *symbol_string[] = {
                "Error",
                "+",
                "-",
                "*",
                "/",
                "(",
                ")",
                "Num",
                "End"
};

In the source file:

Code:

 const char *symbol_string[];

Jim

I assume you mean that the first part goes in the source file and the second in the header. That gives this error:

definition of variable with array type needs an explicit size or an initializer
const char *symbol_string[];

Which is the type of errors I've been seeing for a while now. It's like trying to fit a carpet that is too big to fit into a room, you move to one corner and make a perfect fit, then it pops up in the other, lol.

Edit: swapping the extern key word to the header let me define it in the source file, however I still get the linker error.

Why not just make a function that prints a string representation of the enum value? That way you needn't muck around with extern at all, plus you can also catch use of any unrecognized enum values.

The header file:

Code:

#ifndef SYMBOLS_H
#define SYMBOLS_H

// include header file that provides forward declarations of input / output streams
#include <iosfwd>

enum symbol_t
{
    error_k,
    plus_k,
    minus_k,
    mult_k,
    div_k,
    lparen_k,
    rparen_k,
    numeric_k,
    end_k
};


void print_symbol_t( symbol_t enumVal, std::ostream& out );

#endif

The source file:

Code:

#include "Symbols.h"

#include <sstream>
#include <stdexcept>

void print_symbol_t( symbol_t enumVal, std::ostream& out )
{
    switch ( enumVal )
    {
    case error_k:
        out << "error_k";
        break;
        
    case plus_k:
        out << "plus_k";
        break;
        
    case minus_k:
        out << "minus_k";
        break;
        
    case mult_k:
        out << "mult_k";
        break;
        
    case div_k:
        out << "div_k";
        break;
        
    case lparen_k:
        out << "lparen_k";
        break;
        
    case rparen_k:
        out << "rparen_k";
        break;
        
    case numeric_k:
        out << "numeric_k";
        break;
        
    case end_k:
        out << "end_k";
        break;
        
    default:
        // Unrecognized enum value.
        {
            std::ostringstream errorMessage;
            errorMessage << "Unrecognized symbol_t enum with integer value " << enumVal << "!";
            throw std::runtime_error( errorMessage.str() );
        }
    }
}

EDIT: You can easily add a convenience function that returns a string, too.

Code:

#include <string>
#include <sstream>

std::string getStringRepresentation( symbol_t enumVal )
{
    std::ostringstream out;
    print_symbol_t( enumVal, out );
    return out.str();
}