C / C++ / MFC

C^hris L^osinger14-Aug-02 8:24

14-Aug-02 8:24

what's the problem?

-c

Conservative:
One who admires radicals centuries after they're dead.
-- Leo C. Rosten

Nick Parker14-Aug-02 8:26

14-Aug-02 8:26

Sorry, this is what the compiler spits back out at me.

<br />
--------------------Configuration: fun - Win32 Debug--------------------<br />
Compiling...<br />
fun.cpp<br />
C:\Documents and Settings\np0383\My Documents\C++\fun.cpp(66) : error C2679: binary '<<' : no operator defined which takes a right-hand operand of type 'class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >' (or the<br />
re is no acceptable conversion)<br />
Error executing cl.exe.<br />
<br />
fun.exe - 1 error(s), 0 warning(s)<br />

Which points to this line in the code:

cout << strStack.top() << endl;

Nick Parker

C^hris L^osinger14-Aug-02 8:30

14-Aug-02 8:30

try

#include <iostream>

instead of

#include <iostream.h>

Conservative:
Make it possible for programmers to write programs in English and you will find that most programmers can't write English

Nick Parker14-Aug-02 8:31

14-Aug-02 8:31

That didn't work, I just tried it, what is the difference anyway?

Nick Parker

C^hris L^osinger14-Aug-02 8:36

14-Aug-02 8:36

this compiles fine for me:

#include <iostream>
#include <stack>
#include <string>
using namespace std;

int main(int argc, char* argv[])
{
   
   cout << "Fun with stacks begins" << endl;	
   stack<string> strStack;	
   strStack.push("Nick");	
   strStack.push("Megan");	
   while(!strStack.empty())	
   {		
      cout << strStack.top() << endl;		
      strStack.pop();	
   }	
   cout << "Fun with stacks is over." << endl;
}

Conservative:
Make it possible for programmers to write programs in English and you will find that most programmers can't write English

Nick Parker14-Aug-02 8:44

14-Aug-02 8:44

Ok this is funny Chris, I pasted your code into a new file and compiled it, it worked however I got the following warnings.

<br />
--------------------Configuration: test - Win32 Debug--------------------<br />
Compiling...<br />
test.cpp<br />
c:\documents and settings\np0383\my documents\c++\test.cpp(18) : warning C4508: 'main' : function should return a value; 'void' return type assumed<br />
c:\program files\microsoft visual studio\vc98\include\deque(208) : warning C4786: 'std::reverse_iterator<std::deque<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std<br />
::allocator<char> > > >::const_iterator,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::basic_string<char,std::char_traits<char>,std::allocator<char> > const &,std::basic_string<char,std::char_traits<char>,std::allocator<ch<br />
ar> > const *,int>' : identifier was truncated to '255' characters in the debug information<br />
        c:\program files\microsoft visual studio\vc98\include\deque(207) : while compiling class-template member function '__thiscall std::deque<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<ch<br />
ar,std::char_traits<char>,std::allocator<char> > > >::~std::deque<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >(void)'<br />
c:\program files\microsoft visual studio\vc98\include\deque(208) : warning C4786: 'std::reverse_iterator<std::deque<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std<br />
::allocator<char> > > >::iterator,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::basic_string<char,std::char_traits<char>,std::allocator<char> > &,std::basic_string<char,std::char_traits<char>,std::allocator<char> > *,int><br />
' : identifier was truncated to '255' characters in the debug information<br />
        c:\program files\microsoft visual studio\vc98\include\deque(207) : while compiling class-template member function '__thiscall std::deque<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<ch<br />
ar,std::char_traits<char>,std::allocator<char> > > >::~std::deque<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >(void)'<br />
warning C4786: 'std::stack<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::deque<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allocat<br />
or<char> > > > >::~stack<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::deque<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allocator<br />
<char> > > > >' : identifier was truncated to '255' characters in the debug information<br />
c:\program files\microsoft visual studio\vc98\include\stack(22) : warning C4786: 'std::stack<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::deque<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::al<br />
locator<std::basic_string<char,std::char_traits<char>,std::allocator<char> > > > >::stack<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::deque<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::alloc<br />
ator<std::basic_string<char,std::char_traits<char>,std::allocator<char> > > > >' : identifier was truncated to '255' characters in the debug information<br />
c:\program files\microsoft visual studio\vc98\include\stack(27) : warning C4786: 'std::stack<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::deque<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::al<br />
locator<std::basic_string<char,std::char_traits<char>,std::allocator<char> > > > >::empty' : identifier was truncated to '255' characters in the debug information<br />
c:\program files\microsoft visual studio\vc98\include\deque(208) : warning C4786: 'std::deque<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allocator<char> > > <br />
>::~deque<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >' : identifier was truncated to '255' characters in the debug information<br />
c:\program files\microsoft visual studio\vc98\include\deque(191) : warning C4786: 'std::deque<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allocator<char> > > <br />
>::deque<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >' : identifier was truncated to '255' characters in the debug information<br />
Linking...<br />
<br />
test.exe - 0 error(s), 8 warning(s)<br />

I find it odd to say the least that it is throwing that many warnings, yet it works. Hmm... Anyway, let me just show you exactly what my previous code looked like:

#include <iostream>
#include <vector>
#include <stack>
#include <tchar.h>

using namespace std;


template <class T>
class Math{
	public:
		Math(){};
		T Add(T a, T b) 
		{ 
			return a + b;
		}
		T Subtract(T a, T b)
		{
			return a - b;
		}
		T Multiply(T a, T b) 
		{ 
			return a * b;
		}
		T Divide(T a, T b) 
		{ 
			return a / b;
		}
};

void main()
{


Math<double> dMath;
double dReturn = dMath.Add(12.34,36.654);
cout << "12.34 plus 36.654 = " << dReturn << endl << endl;

printf(_T("vector fun begins...\n\n"));

	vector<int> vList;
	for(int i = 1;i <= 20;i++)
	{
		vList.push_back(i);
		cout << "Number " << i << " added to vector." << endl;
	}

	for(i = 20;i > 0;i--)
	{
		vList.pop_back();
		cout << "Number " << i << " being removed from vector." << endl;		
	}
	vList.~vector();



	cout << "Fun with stacks begins" << endl << endl;

	stack<string> strStack;
	strStack.push("Nick");
	strStack.push("Megan");
	while(!strStack.empty())
	{
		cout << strStack.top() << endl;
		strStack.pop();
	}

	cout << "Fun with stacks is over." << endl;
	


}

It's still not working within this code, not sure why though. Confused | :confused:

Nick Parker

C^hris L^osinger14-Aug-02 8:56

14-Aug-02 8:56

you'll get those warnings almost any time you use stl. it's time to become friends with "pragma"

put this before and after your STL includes:

#pragma warning(disable 4786)

-c

Conservative:
Faith is the quality that enables you to eat blackberry jam
on a picnic without looking to see whether the seeds move.

Nick Parker14-Aug-02 9:04

14-Aug-02 9:04

God I feel like an idiot! Now that I have that said I am now getting this error:

<br />
--------------------Configuration: fun - Win32 Debug--------------------<br />
Compiling...<br />
fun.cpp<br />
c:\documents and settings\np0383\my documents\c++\fun.cpp(2) : fatal error C1021: invalid preprocessor command 'pramga'<br />
Error executing cl.exe.<br />
<br />
fun.exe - 1 error(s), 0 warning(s)<br />

Nick Parker

C^hris L^osinger14-Aug-02 9:06

14-Aug-02 9:06

sorry.. that's "pragma", not "pramga" Smile | :)

-c

Conservative:
Faith is the quality that enables you to eat blackberry jam
on a picnic without looking to see whether the seeds move.

Nick Parker14-Aug-02 9:10

14-Aug-02 9:10

Ok Chris, your the man, that did it, really...THANKS!

Could possibly explain to me (or point me to a link that explains) what #pragma does, what its for and why the hell does MVC++ puke without it in there. On a side note it still threw all those warnings with the #pragma in, however it compiled? Thanks again. Smile | :)

Nick Parker

C^hris L^osinger14-Aug-02 9:16

14-Aug-02 9:16

#pragma can do a lot of things. in this case, we're just telling the compiler to suppress those particular warnings. but, you'll find, as you use more STL, that even the mighty pragma can't turn off all warnings in all situations - the STL headers will enable warnings on their own, and the warnings will show up regardless of what you say.

pragma can also force compliations errors or warnings, it can cause automagic linking to static libs, and much more.

most of the STL warnings are harmless. i treat that pragma as simply part of using STL Smile | :)

-c

Conservative:
Faith is the quality that enables you to eat blackberry jam
on a picnic without looking to see whether the seeds move.

Nick Parker14-Aug-02 9:19

14-Aug-02 9:19

Thanks for the tip, I really appreciate it, I am out looking for more information on #pragma now. Smile | :)

Nick Parker

C^hris L^osinger14-Aug-02 9:04

14-Aug-02 9:04

try adding this:

#include <string>

-c

Conservative:
Faith is the quality that enables you to eat blackberry jam
on a picnic without looking to see whether the seeds move.

unique field in an Access database ?

Philippe Mori15-Aug-02 10:22

Philippe Mori

15-Aug-02 10:22

You should not call destructor explicitly.

vList.~vector();

Calling destructor explicitly is very advanced C++ when someone is managing the memory itself (STL does it at a couple of places). In particular, this should not be done if the object is one the stack (the destructor will be called twice, once manually and one automatically which can cause memory corruption and a bunch of problems).

The only time, destructor are called explicitly is when memory is allocated explicitly and placement new is used to construct the object at that location.

Philippe Mori

ns14-Aug-02 7:49

14-Aug-02 7:49

If I want to have a db that will not allow any duplicates in a certain field what do I do? In code if someone tries to put in data thats duplicate for that particular field, how will the entry be prevented? Does Access have an inbuilt feature for this? Thanks,
ns

Ranjan Banerji14-Aug-02 8:15

Ranjan Banerji

14-Aug-02 8:15

Most databases will not let you have duplicates for keys. And the corresponding ADO, OLEDB, ODBC driver will throw an exception when the happens. You just need to trap the exception, decipher it and then let the user know. And yes, Access will throw an exception if you try to enter a duplicate for a primary key. At least it did in Access 2.0. Smile | :)

( Am I ancient or what? )

ns14-Aug-02 8:24

14-Aug-02 8:24

Okay. Thanks. A dumb question. How do you trap an exception?
Thanks,
ns

Ranjan Banerji14-Aug-02 8:35

Ranjan Banerji

14-Aug-02 8:35

Read up on exception handling. Look at some of the ADO samples on this site you will find several try and catch statements. Something like:

try{

Your insert and other database code

}
catch( dbexception ) {
Handle it here
}