void foo()
{
void* a[1];
a[1] = (void*)&bar;
}-LC:\Qt\curl-7.49.0-win32-mingw\lib -lcurldllwin32|win64: LIBS += -lws2_32 -lshlwapi -lodbc32 -lpsapi -lcomdlg32 \
-L$$PWD/../../Common/cURL/lib/ -lcurldll -lole32 \
-loleaut32data в реализации item<Edge>) не имеет конструктора по умолчанию. Есть три пути.class Edge : public EdgeBase
{
public:
Edge (Point* firstPoint, Point* secondPoint) { init(firstPoint, secondPoint); }
Edge () { init(NULL, NULL); }
void init (Point* firstPoint, Point* secondPoint)
{
this->firstPoint = firstPoint;
this->secondPoint = secondPoint;
}
private:
Point* firstPoint;
Point* secondPoint;
};#include <iostream>
class ImmutableInt
{
public:
explicit ImmutableInt(int x) : fData(x) {}
int data() const { return fData; }
private:
int fData;
};
template <class Payload>
class ListItem
{
public:
Payload payload;
ListItem* next;
ListItem() : next(NULL) {}
ListItem(const Payload& x) : payload(x), next(NULL) {}
};
// Так писать нельзя — эта конструкция расшаблонивает все функции,
// а конструктора по умолчанию как не было, так и нет!
//template class ListItem<ImmutableInt>;
int main()
{
ListItem<ImmutableInt> li(ImmutableInt(42));
std::cout << li.payload.data() << std::endl;
return 0;
}#include <iostream>
class ImmutableInt
{
public:
explicit ImmutableInt(int x) : fData(x) {}
int data() const { return fData; }
private:
int fData;
};
template <class Payload>
class ListItem
{
public:
Payload payload;
ListItem* next = nullptr;
template<class... Args>ListItem(Args... args) : payload(args...) {}
};
int main()
{
ListItem<ImmutableInt> li(42);
std::cout << li.payload.data() << std::endl;
return 0;
}explicit не надо, всё-таки отметил — просто чтобы показать, что во втором случае мы передаём параметром ImmutableInt<42>, а в третьем — 42.template<typename type_t>
struct item
{
item* next;
type_t data;
};bool IsEnded(const Query &aVar) { return (aVar.id == NO_ID); }class Object {
public:
virtual ~Object() {}
};
class List { // interface
protected:
virtual Object& getAt(size_t i) = 0;
public:
virtual size_t size() const = 0;
inline Object& at(size_t i) { return getAt(i); }
inline const Object& at(size_t i) const
{ return const_cast<List*>(this)->getAt(i); }
virtual ~List() {}
};class ListCallback { // interface
public:
virtual void act(size_t index, Object& object) = 0;
virtual ~ListCallback() {}
};
class ListConstCallback { // interface
public:
virtual void act(size_t index, const Object& object) = 0;
virtual ~ListConstCallback() {}
};
class List2 { // interface
public:
virtual size_t size() const = 0;
virtual void enumerate(ListCallback& body) = 0;
virtual void enumerate(ListConstCallback& body) const = 0;
};void DynArray::enumerate(ListConstCallback& body) const {
size_t sz = size();
for (size_t i = 0; i < sz; ++i)
body(i, operator[](i));
}class VirtualListIterator { // interface
public:
virtual bool next() = 0;
virtual Object& value() = 0;
virtual ~VirtualListIterator() {}
};
class ListIterator { // Назван так для красоты, по сути это умный указатель
private:
VirtualListIterator* ptr;
// Запретим копирование и op=, но при желании можно реализовать и их
ListIterator(ListIterator&) {}
void operator=(const ListIterator&) {}
public:
ListIterator() : ptr(NULL) {}
ListIterator(VirtualListIterator* value) : ptr(value) {}
~ListIterator() { delete ptr; }
bool next() { return ptr->next(); }
Object* operator->() const { return &ptr->value(); }
Object& operator*() const { return ptr->value(); }
};
class List3 { // interface
public:
virtual size_t size() const = 0;
virtual VirtualListIterator* enumerate() = 0;
};
class Number : public Object {
public:
int value;
};
// И пользоваться этим так...
void doSmth(List3& aList) {
ListIterator it(aList.enumerate());
while (it.next()) {
std::cout << dynamic_cast<Number&>(*it).value << std::endl;
}
}#include <iostream>
#include <vector>
class Test {
int k;
public:
Test(int _i) {k = _i; }
void put_k(int i) {k = i; }
int get_k() {return k; }
};
struct TestWrapper {
Test payload;
TestWrapper() : payload(0) {}
TestWrapper(int i) : payload(i) {}
TestWrapper(const Test& i) : payload(i) {}
};
int main()
{
Test test(10);
std::vector<TestWrapper> v;
v.push_back(test);
std::cout << v[0].payload.get_k() << std::endl;
return 0;
}#include <iostream>
#include <vector>
#include <memory>
class Test {
int k;
public:
Test(int _i) {k = _i; }
Test& operator=(const Test&) = delete;
Test& operator=(Test&&) = delete;
void put_k(int i) {k = i; }
int get_k() {return k; }
};
int main()
{
std::vector<std::unique_ptr<Test>> v;
v.push_back(std::unique_ptr<Test>(new Test(10)));
std::cout << v[0]->get_k() << std::endl;
return 0;
}(*root)->next.push_back(node);bool Syntax::On_BG(Node * root)bool Syntax::On_BG(Node & root)#include <iostream>
#include <memory>
#include <vector>
class Base{
public:
// Нужен виртуальный деструктор, ведь мы будем уничтожать детей
// через родительский ук-ль. Да и dynamic_cast требует RTTI,
// а значит, хоть одного виртуального.
virtual ~Base() = default;
};
class Exp: public Base
{
int i=0;
public:
int Get() const { return i; }
void Set(const int &num) { i=num; }
};
std::vector<std::shared_ptr<Base>> MyStack;
Base &GetRef() { return **MyStack.begin(); }
int main() {
std::shared_ptr<Exp> a = std::make_shared<Exp>();
a->Set(4);
MyStack.push_back(a);
int res=dynamic_cast<Exp&>(GetRef()).Get(); // Теперь работает
std::cout << res << std::endl;;
}#include <iostream>
#include <conio.h>
int main()
{
setlocale(LC_ALL, "Russian");
const size_t SIZE = 3000000000ul;
char* ptr = NULL;
try
{
ptr = new char[SIZE];
std::cout << "Память используется без сбоев.\n";
}
catch (std::bad_alloc&)
{
std::cout << "Исключение bad_alloc: невозможно разместить данные в памяти.\n";
}
delete[] ptr;
getch();
return 0;
}String s3 = "Нас обманули, расходимся."; означает вот что. Мы создаёт временную строку «Нас обманули, расходимся», а затем присваиваем её нашему s3. Конечно, компилятор это потом заоптимизирует, но это семантика языка, и ей надо следовать.String(const String &S).String(String &&S).class String
{
public:
String() {}
String& operator= (String& s) { return *this; }
};
String operator+ (String a, String b) { return String(); }
int main()
{
String s1;
String s2 = s1;
String s4;
s4 = s1 + s2;
}String& operator= (const String& s). struct Comment {
QMap<QString, QString> objects;
};
struct Post {
QList<Comment> comments;
};objects и на что тебе эта «строкотипизированность»? 
void parseCommaList(
const char *aStart, // указатель на начало
const char *aEnd, // указатель на символ за концом
char aComma, // символ-разделитель
bool aSkipEmpty, // true, если пустые подстроки пропускать
ProcParseCommaList aCallback, // функция-нагрузка
void *aData) // этот параметр нужен, чтобы передавать какие хочешь данные в функцию-нагрузку, удаляй его смело!
{
str::trim(aStart, aEnd); // моя функция; пододвигает aStart вперёд и aEnd назад, убирая пробелы.
// Если удаление пробелов не нужно — удаляй! Если нужно — пиши сам.
if (aStart == aEnd) return;
const char *sstart = aStart;
for (const char *p = aStart; p != aEnd; ++p)
{
if (*p != aComma) continue;
const char *send = p;
str::trim(sstart, send); // то же самое, можно убрать
if (p != sstart || !aSkipEmpty)
aCallback(sstart, send, aData); // замени на боевую нагрузку
sstart = p + 1;
}
str::trim(sstart, aEnd); // то же самое, можно убрать
if (sstart != aEnd || !aSkipEmpty)
aCallback(sstart, aEnd, aData); // замени на боевую нагрузку
}inline void parseCommaList(
const std::string &aIn,
char aComma,
bool aSkipEmpty,
ProcParseCommaList aCallback,
void *aData)
{
parseCommaList(aIn.data(), aIn.data() + aIn.length(), aComma, aSkipEmpty,
aCallback, aData);
}