c++ including <complex> causes a syntax error in file string - string

Question

Error 3 error C2059: syntax error : ')' c:\program files\microsoft visual studio 10.0\vc\include\string 758 1 ECE572_001_Project1_swirl
Error 6 error C2059: syntax error : ')' c:\program files\microsoft visual studio 10.0\vc\include\string 767 1 ECE572_001_Project1_swirl
Error 1 error C2143: syntax error : missing ')' before 'string' c:\program files\microsoft visual studio 10.0\vc\include\string 758 1 ECE572_001_Project1_swirl
Error 4 error C2143: syntax error : missing ')' before 'string' c:\program files\microsoft visual studio 10.0\vc\include\string 767 1 ECE572_001_Project1_swirl
Error 2 error C2665: 'swprintf' : none of the 2 overloads could convert all the argument types c:\program files\microsoft visual studio 10.0\vc\include\string 758 1 ECE572_001_Project1_swirl
Error 5 error C2665: 'swprintf' : none of the 2 overloads could convert all the argument types c:\program files\microsoft visual studio 10.0\vc\include\string 767 1 ECE572_001_Project1_swirl
I don't understand this error, because it says the error is in the file string, which is a locked file provided by VS2010. Second, I'm not even using string, and third, how could including complex have anything to do with the library string?
Even though including complex causes the error in my project file, I started a whole new file to test including it, and the error didn't happen there.
#include "Image.h"
#include <iostream>
#include <complex>
using namespace std;
#define Usage "makeSwirl inImg outImg coeff\n"
/*
* arg1 is the image to transform.
* arg2 is the swirl coefficient
* Returns image with enhanced edges.
*/
Image swirl(const Image&, const float&);
/*
* arg1 is the image within which the pixel to be transformed is located.
* arg2&3&4 are the row, colum, and channel of the pixel to transform.
* arg5 is the swirl coefficient
* arg6&7 are the rows and cols of arg1.
* returns transformed pixel.
*/
float onePixelSwirl(const Image&, const int&, const int&, const int&, const double&, const int&, const int&);
int main(int argc, char **argv)
{
// Check for proper number of arguments.
if(argc != 4)
{
cout << Usage;
exit(3);
}
// Read in image specified by user.
const Image IN_IMG = readImage(argv[1]);
// Create output image with oil effect.
Image outImg = swirl(IN_IMG, atof(argv[3]));
// Output the image
writeImage(outImg, argv[2]);
// Success!
return(0);
}
Image swirl(const Image& IN_IMG, const float& COEFF)
{
Image outImg;
// Allocate memory
const int ROWS = IN_IMG.getRow();
const int COLS = IN_IMG.getCol();
const int CHANNELS = IN_IMG.getChannel();
outImg.createImage(ROWS, COLS, IN_IMG.getType());
// Perform edge effect
for (int k = 0; k < CHANNELS; ++k)
for (int i = 0; i < ROWS; ++i)
for (int j = 0; j < COLS; ++j)
outImg(i,j,k) = onePixelSwirl(IN_IMG, i, j, k, COEFF, ROWS, COLS);
return outImg;
}
float onePixelSwirl(const Image& IN_IMG, const int& ROW, const int& COL,
const int& CHANNEL, const double& COEFF, const int& ROWS, const int& COLS)
{
// define shift of origin
//const double X_SHIFT = ROWS/2.0;
//const double Y_SHIFT = COLS/2.0;
//const complex<double> NEW_SHIFTED(ROW - X_SHIFT, COL - Y_SHIFT);
//const double r = abs(NEW_SHIFTED);
//const complex<double> OLD_SHIFTED = polar(r, arg(NEW_SHIFTED) + r/COEFF);
//const int OLD_ROW = OLD_SHIFTED.real() <= ROWS ? OLD_SHIFTED.real() : ROWS;
//const int OLD_COL = OLD_SHIFTED.imag() <= COLS ? OLD_SHIFTED.imag() : COLS;
//return IN_IMG(OLD_ROW, OLD_COL, CHANNEL);
return 0;
}
I put the include statement above including image.h, and the compilation bugs vanished. Here is image.h if someone could figure out the problem:
/********************************************************************
* Image.h - header file of the Image library which defines
* a new class "Image" and the associated member functions
*
* Author: Hairong Qi, hqi#utk.edu, ECE, University of Tennessee
*
* Created: 02/05/02
*
* Note:
* This is a simple C++ library for image processing.
* The purpose is not high performance, but to show how
* the algorithm works through programming.
* This library can only read in PGM/PPM format images.
*
* Modification:
* 07/31/09 - moving header files for colorProcessing, imageIO, and
* matrixProcessing to this file
* 01/22/06 - reorganize the Image library such that the Image class
* only contains member functions related to the most
* fundamental image operation
* 11/12/05 - add wavelet transform function
* 09/26/05 - add Fourier transform related functions
* 09/07/05 - add overloading function for "/"
* 09/07/05 - modify createImage() function
* 09/07/05 - fix problems with copy constructor
* 08/07/05 - regrouping functions
********************************************************************/
#ifndef IMAGE_H
#define IMAGE_H
#include <iostream>
#include <cmath>
using namespace std;
#define PGMRAW 1 // magic number is 'P5'
#define PPMRAW 2 // magic number is 'P6'
#define PGMASCII 3 // magic number is 'P2'
#define PPMASCII 4 // magic number is 'P3'
#define GRAY 10 // gray-level image
#define BINARY 11 // binary image
#define NBIT 8
#define L ( pow(2.0,NBIT)-1 ) // the largest intensity represented by NBIT
class Image {
friend ostream & operator<<(ostream &, Image &);
friend Image operator/(Image &, double); // image divided by a scalar
friend Image operator*(Image &, double); // image multiplied by a scalar
friend Image operator+(Image &, double); // image add a scalar
friend Image operator-(Image &, double); // image subtract a scalar
public:
// constructors and destructor
Image(); // default constructor
Image(int, // constructor with row
int, // column
int t=PGMRAW); // type (use PGMRAW, PPMRAW,
// PGMASCII, PPMASCII)
Image(const Image &); // copy constructor
~Image(); // destructor
// create an image
void createImage(); // create an image, parameters all set
void createImage(int, // create an image with row
int c=1, // column (default 1, a column vector)
int t=PGMRAW); // and type, default is PGMRAW
void initImage(float init=0.0); // initiate the pixel value of an img
// the default is 0.0
// get and set functions
int getRow() const; // get row # / the height of the img
int getCol() const; // get col # / the width of the image
int getChannel() const; // get channel number of the image
int getType() const; // get the image type
float getMaximum() const; // get the maximum pixel value
void getMaximum(float &, // return the maximum pixel value
int &, int &); // and its indices
float getMinimum() const; // get the mininum pixel value
void getMinimum(float &, // return the minimum pixel value
int &, int &); // and its indices
Image getRed() const; // get the red channel
Image getGreen() const; // get the green channel
Image getBlue() const; // get the blue channel
Image getImage(int) const; // get the kth channel image,
// k starts at 0
void setRow(int); // set row number
void setCol(int); // set column number
void setChannel(int); // set the number of channel
void setType(int t=PGMRAW); // set the image type
void setRed(Image &); // set the red channel
void setGreen(Image &); // set the green channel
void setBlue(Image &); // set the blue channel
void setImage(Image &, int); // set the kth channel image,
// k starts at 0
// operator overloading functions
float & operator()(int, // operator overloading (i,j,k)
int c = 0, // when c=k=0, a column vector
int k = 0) const;
const Image operator=(const Image &); // = operator overloading
Image operator+(const Image &) const; // overloading + operator
Image operator-(const Image &) const; // overloading - operator
Image operator*(const Image &) const; // overloading pixelwise *
Image operator/(const Image &) const; // overloading pixelwise division
Image operator->*(const Image &) const; // overloading ->* operator
// (matrix multiplication)
bool IsEmpty() const { return (image==NULL); }
private:
int row; // number of rows / height
int col; // number of columns / width
int channel; // nr of channels (1 for gray, 3 for color)
int type; // image type (PGM, PPM, etc.)
int maximum; // the maximum pixel value
float *image; // image buffer
};
////////////////////////////////////
// image I/O
Image readImage(char *); // read image
void writeImage(Image &, // write an image
char *,
int flag=0); // flag for rescale, rescale when == 1
Image rescale(Image &, // rescale an image
float a=0.0, // lower bound
float b=L); // upper bound
////////////////////////////////////
// color processing routines
Image RGB2HSI(Image &); // convert from RGB to HSI model
Image HSI2RGB(Image &); // convert from HSI to RGB model
////////////////////////////////////
// matrix manipulation
Image transpose(Image &); // image transpose
Image inverse(Image &); // image inverse
Image pinv(Image &); // image pseudo-inverse
Image subImage(Image &, // crop an image
int, // starting row index
int, // starting column index
int, // ending row index
int); // ending column index
#endif

Answer 1

There's a number of things that are suspicious but the main one is the definition of L. If I recall, L is used to indicate a Unicode string literal as in L"Some Unicode text". It seems likely that <complex> uses this. By including Image.h before <complex>, you've redefined it. This would also explain the broken calls to swprintf().
Since you don't use L in Image.h is there any reason to declare it there? If L is part of the interface and actually needs to be in the header file, consider renaming it to something less likely to provoke a name conflict.
Other things that look suspicious but aren't necessarily the problem here: You've included <cmath> in Image.h for no apparent reason. Generally, you should only include the files you actually need. A bigger issue is the using namespace std in the header. This is almost always a bad idea since it pulls every name in the std namespace into the local scope of every file that includes this header file. It greatly increases the chance of name collisions that could be tricky to sort out (as you can see)