Debuggen C ++ Code mit Vorlagen und STL mit GDB
https://stackoverflow.com/questions/1610906
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Was tun gdb Mitglieder halten sich hier über seine Fähigkeiten in Bezug auf die Debugging-Code mit Vorlagen und STL?
Verwenden Sie keine Tricks das Debuggen irgendwie einfacher zu machen? Vielleicht haben einige Python-Skripte? Oder sind Sie die Art und Weise erfüllt es derzeit in GDB ist (ver 6.x, 7.x habe nicht versucht noch)?
Danke.
Lösung
Ich gehe davon aus, dass Sie AWL-Code besser bedeuten Visualisierung (und nicht die debug Modus die sichere Iteratoren und zusätzliche Laufzeitprüfungen geben). Ich bin nicht sicher, ob man sich diese Beiträge ausgesehen haben:
Mit gdb
Ab Version 7.0 enthält GDB Unterstützung recht-Drucker in Python zu schreiben. Hübsche Drucker für STL-Klassen sind mit GCC ab Version 4.5.0 verteilt. Die neueste Version dieser Drucker sind immer in libstdc ++ SVN-Repository gefunden. Um diese Drucker zu aktivieren, Check-out die neuesten Drucker in einem lokalen Verzeichnis:
Versuchen Sie auch, KDevelop / DDD verwenden, wenn möglich -. Sie Hilfe tun
Andere Tipps
Dies kann hilfreich sein: GDB STL Support Tools
Mein Lieblings-Weg GDB zu verwenden ist GDB-Modus in Emacs. Sie erhalten volle visuelle / Source-Level-Debugging, Thread-Fenster, Stack-Fenster (etc) ... Probieren Sie es aus, Sie werden nicht enttäuscht sein.
Das heißt, Griffe GDB Debugging von STL-Containern ganz gut ohne spezielle Add ons ... So stellen Sie sicher, dass Sie mit -g Gebäude sind, und ohne -ON (jeglicher Art) ...
Ich bin nicht sicher, ob Sie Code hinzufügen dürfen, oder Sie debuggen nur den Code, Sorry. Ich schreibe eine einfache Dienstprogramm Funktionen seit einer Weile, ich hoffe, Sie finden es nützlich. Sie könnten den Inhalt der Standardcontainer leicht drucken. Es gibt keinen plattformspezifischen Code, ein Beispiel für die Nutzung (die Test-Fahrer tatsächlich):
#include <iostream>
#include <fstream>
#include <iomanip>
#include <string>
#include <vector>
#include <list>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <boost/array.hpp>
#include <boost/assign.hpp>
#include "streamer.hpp"
const std::size_t consoleWidth = 80;
std::ostream& newline_if_not_console(std::ostream& outputstream)
{
if(&outputstream != & std::cout)
{
outputstream << std::endl;
}
return outputstream;
}
void STL_test_ostream(std::ostream& out)
{
using namespace boost::assign;
using namespace streamer;
double iDoubleArray[] = {0.1, 1.2, 2.3, 3.4, 4.5}; // It could be of any type!
std::vector<int> iVec;
std::list<int> iList;
std::deque<int> iDeque;
std::stack<int> iStack;
std::queue<int> iQueue;
std::priority_queue<int> iPriorityQueue;
std::set<int> iSet;
std::map<int, std::string> iMap;
iVec += 0, 1, 2, 3, 4, 5;
iList += 0, 1, 2, 3, 4, 5;
iDeque += 0, 1, 2, 3, 4, 5;
iStack += 0, 1, 2, 3, 4, 5;
iQueue += 0, 1, 2, 3, 4, 5;
iPriorityQueue += 0, 1, 2, 3, 4, 5;
iSet += 0, 1, 2, 3, 4, 5;
insert(iMap)
( 1 , "one" )
( 2 , "two" )
( 3 , "three" )
( 4 , "four" )
( 5 , "five" );
out << std::string(consoleWidth, '=') << newline_if_not_console
<< "STL Test..." << std::endl
<< std::string(consoleWidth, '=') << newline_if_not_console;
out << "Native Array = " << iDoubleArray << std::endl;
out << "vector = " << iVec << std::endl;
out << "list = " << iList << std::endl;
out << "deque = " << iDeque << std::endl;
out << "queue = " << iQueue << std::endl;
out << "stack = " << iStack << std::endl;
out << "priority_queue = " << iPriorityQueue << std::endl;
out << "set = " << iSet << std::endl;
out << "map = " << iMap << std::endl;
out << std::string(consoleWidth, '=') << std::endl;
}
void Boost_test_ostream(std::ostream& out)
{
out << std::string(consoleWidth, '=') << newline_if_not_console
<< "Boost Test..." << std::endl
<< std::string(consoleWidth, '=') << newline_if_not_console;
}
int main()
{
std::ofstream stl("STL_test_ostream.txt"),
boost("Boost_test_ostream.txt");
STL_test_ostream(std::cout);
Boost_test_ostream(std::cout);
STL_test_ostream(stl);
Boost_test_ostream(boost);
}
Ich habe nicht geschrieben, den Code für die Boost-Container vor. Hoffentlich werde ich es tun irgendwann:)
Alles, was Sie tun müssen, ist, diese Datei schließen [ "streamer.hpp"]:
#ifndef DATASTRUCTRE_STREAMER
#define DATASTRUCTRE_STREAMER
#include <stack>
#include <queue>
#include <boost/array.hpp>
#include <functional>
#include <memory>
namespace streamer
{
// one-value data structure streaming function
template <class Container, class Stream>
Stream& printOneValueContainer(Stream& outputstream, const Container& container)
{
Container::const_iterator beg = container.begin();
outputstream << "[";
while(beg != container.end())
{
outputstream << " " << *beg++;
}
outputstream << " ]";
return outputstream;
}
// pair-value data structure streaming function
template <class Container, class Stream>
Stream& printPairValueContainer(Stream& outputstream, const Container& container)
{
Container::const_iterator beg = container.begin();
outputstream << "[";
while(beg != container.end())
{
outputstream << " " << "<" << beg->first << " , " << beg->second << ">";
beg++;
}
outputstream << " ]";
return outputstream;
}
/*
*************************************************************
C++ Standard Library
*************************************************************
*/
// Sequence Containers.
// vector, list, deque
template
< class Type
, template<class Type, class Allocator = std::allocator<Type> > class Container
, class Stream
>
Stream& operator<<(Stream& outputstream, const Container<Type>& container)
{
return printOneValueContainer(outputstream, container);
}
// Associative Containers.
// set, multiset
template
< class Key
, template<class KeyType, class Traits = std::less<KeyType>, class Allocator = std::allocator<KeyType> > class Container
, class Stream
>
Stream& operator<<(Stream& outputstream, const Container<Key>& container)
{
return printOneValueContainer(outputstream, container);
}
// map, multimap
template
< class Key, class Value
, template<class KeyType, class ValueType, class Traits = std::less<KeyType>, class Allocator = std::allocator<std::pair<const KeyType, ValueType> > > class Container
, class Stream
>
Stream& operator<<(Stream& outputstream, const Container<Key, Value>& container)
{
return printPairValueContainer(outputstream, container);
}
// Adapters.
// stack, queue
template < class Type, class Container >
const Container& container(const std::stack<Type, Container>& stack)
{
struct HackedStack : private std::stack<Type, Container>
{
static const Container& container(const std::stack<Type, Container>& stack)
{
return stack.*&HackedStack::c;
}
};
return HackedStack::container(stack);
}
template < class Type, class Container >
const Container& container(const std::queue<Type, Container>& queue)
{
struct HackedQueue : private std::queue<Type, Container>
{
static const Container& container(const std::queue<Type, Container>& queue)
{
return queue.*&HackedQueue::c;
}
};
return HackedQueue::container(queue);
}
template
< class Type
, template <class Type, class Container = std::deque<Type> > class Adapter
, class Stream
>
Stream& operator<<(Stream& outputstream, const Adapter<Type>& adapter)
{
return printOneValueContainer(outputstream, container(adapter));
}
// priority_queue
template < class Type, class Container, class Compare >
const Container& container(const std::priority_queue<Type, Container, Compare>& priorityQue)
{
struct HackedProiorityQueue : private std::priority_queue<Type, Container, Compare>
{
static const Container& container(const std::priority_queue<Type, Container, Compare>& priorityQue)
{
return priorityQue.*&HackedProiorityQueue::c;
}
};
return HackedProiorityQueue::container(priorityQue);
}
template < class Type, class Container, class Compare, class Stream >
Stream& operator<<(Stream& outputstream, const std::priority_queue<Type, Container, Compare>& adapter)
{
return printOneValueContainer(outputstream, container(adapter));
}
/*
*************************************************************
C++ Native Arrays
*************************************************************
*/
template <class Type, std::size_t size, class Stream>
Stream& operator<<(Stream& outputstream, Type (&array)[size])
{
outputstream << "[";
for(std::size_t i = 0; i < size; ++i)
{
outputstream << " " << array[i];
}
outputstream << " ]";
return outputstream;
}
/*
*************************************************************
Boost
*************************************************************
*/
}
#endif
ddd ist auch toll - mein Favorit
!