C++ Chanel

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

bool predicate(int lhs,int rhs){
    return !(lhs < rhs); // in parentheses due to precedence
}

int main(){
    vector<int> v{0,512,22,54,222,10};

    sort(v.begin(),v.end(),predicate);

    for(const auto& i : v)
        cout<<i<<" ";
}

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

int main(){
    vector<int> v{0,512,22,54,222,10};

    sort(v.begin(),v.end(),[](int lhs,int rhs){
        return !(lhs < rhs);
    });

    for(const auto& i : v)
        cout<<i<<" ";
}

512 222 54 22 10 0

#include <iostream>
#include <vector>
using namespace std;

//вспомогательная функция рассчитывает кол-во различных мест внутри ящика
long long counter(const vector<long long>& v,const vector<long long>& rv){
    long long result{};

    if(v == rv) // если наш куб равен размеру ящика,то он вмещаеться только один раз 
        return 1;

    for(long long i = v[1];i<=rv[1];++i){ // идем по длине
        result+=rv[0] - v[0] + 1; // каждую ширину в результат
    }

    int z = rv[2] - v[2] + 1; // высота
    return result*z;
}

int main(){
    int t;cin>>t;
    vector<long long> result;
    
    for(int d = 0;d<t;++d){
        long long x,y,z,S;cin>>x>>y>>z>>S;
        long long maxValue{};
        for(long long  a = 1;a<=x;++a){ 
            for(long long b = 1;b<=y;++b){

                long long c = S/(a*b); // можно сделать цикл от 1 до z - не проходит по рантайму 
                                       // так как будут повторы a и b 

                if(z>=c){ // если с не выходит за пределы 

                    if(a*b*c == S ){ // если объем равен k ( в моем случае S)
                        long long temp = counter({a,b,c},{x,y,z});  // создаю переменную 
                                                                    // для хранения расчетов;
                                                                    // альтернативы:
                                                                    /*
                                                                      1. создать переменную в условии if 
                                                                      2. вызвать counter в присвоении и if 
                                                                        функция будет вызываться по два раза
                                                                    */
     
                        if(temp > maxValue)
                            maxValue = temp;
                    }
                }
            }
        }
        result.push_back(maxValue); // вносим в наш вектор наибольшее значение,
                                    // если такого не нашлось - выводим ноль
    }
    for(const auto& i: result){ // вывод
        cout<<i<<endl;
    }
}

namespace A{
    int i = 3;
}

namespace B{
    int i = 1;
}

void foo(){
    A::i = 53;
    B::i = 12;
}

LibBar::GadgetHelpers::SomeGadgimathing foobar(LibBar::GadgetHelpers::SomeGadget<type> gadget,LibBar::GadgetHelpers::GadgimathingOptions options);

namespace A{
    namespace B{
        namespace C{
            class Type;
        }
    }
}
using A::B::C::Type; // <- using declaration
using Type = A::B::C::Type;// <- namespace aliases
typedef A::B::C::Type Type;// <- typedef

class A{
public:
 A(const int & _a, const double &_b){
  a = _a;
  b = _b;
 } 
private:
 int a;
 double b;
};

class B{
public:
 B(const int &_a, const double &_b): a(_a),b(_b){}
private:
 int a;
 double b;
};

class A{
public:
 A(const int & _a, const double &_b , const int &_c){
  a = _a;
  b = _b;
  c = _c; //expression must be a modifiable lvalue
 }
private:
 int a;
 double b;
 const int c;
};

class B{
public:
 B(const int & _a, const double &_b , const int &_c): a(_a), b(_b), c(_c) {}
private:
 int a;
 double b;
 const int c;
};

#include <iostream>

class A{
public:
    A(){std::cout<<"A";}
};

class B{
public:
    B(){std::cout<<"B";}
};

class C{
private:
    B b;
    A a;

public:
    C() : a(),b(){ } 
};

int main(){
    C c;
}

int value = 256;
int& referenceValue = value; //referenceValue теперь связан с value (псевдоним value)

int main(){
    int arr[10]{};
    int (&r)[10]{arr};
    r[2] = 12;
    std::cout<<arr[2]<<std::endl;  //В консоле будет число 12
}

void Foo(int a[4]);
void Foo(int a[]);
void Foo(int *a);

int(&Foo(int x))[4];

Абстрактные классы используются в качестве обобщенных концепций, на основе которых можно создавать более конкретные производные классы. Невозможно создать объект абстрактного типа класса. Однако можно использовать указатели и ссылки на абстрактные типы классов.

Вы создаете абстрактный класс, объявляя по крайней мере одну чистую виртуальную функцию-член. Это виртуальная функция, объявленная с помощью синтаксиса чистого описателя (= 0). Классы, производные от абстрактного класса, должны реализовывать чисто виртуальную функцию; в противном случае они также будут абстрактными.

#include <iostream>

class Animal {
public:
  virtual void Speak() const = 0;
  virtual ~Animal() {}
};//наш абстрактный класс

class Dog : public Animal{
public:
  virtual void Speak() const override { std::cout << "Dog speak! \n"; }
  virtual ~Dog() {}
};

class Cat : public Animal {
public:
  virtual void Speak() const override { std::cout << "Cat speak! \n"; }
  virtual ~Cat() {}
};
int main() {
  //Animal* prt = new Animal(); - ошибка
  Animal* ptr = new Dog();
  ptr->Speak();
  delete ptr;
  ptr = new Cat();
  ptr->Speak();
  delete ptr;
}

"Если не определить собственный - то компилятор сделает это за вас."

#include <iostream>

class Chiken {
private:
  int m_age;
  std::string m_name;
public:
  Chiken(int age, std::string name) :m_age(age), m_name(name) {
    std::cout << "Constructor called" << std::endl;
  }
  int GetAge() const { return m_age; }
  std::string GetName() const { return m_name; }
};

int main() {
  Chiken chik1;
  std::cout<<chik1.GetName();
}

#include <iostream>

class Chiken {
private:
  int m_age;
  std::string m_name;
public:
  Chiken(int age = 0, std::string name = "Unnamed") :m_age(age), m_name(name) {
    std::cout << "Constructor called" << std::endl;
  }
  int GetAge() const { return m_age; }
  std::string GetName() const { return m_name; }
};

int main() {
  Chiken chik;//вызов конструктора
  Chiken chik1(12,"Vasya");//вызов конструктора 
  std::cout<<chik.GetName()<<std::endl;
  Chiken chik2 = chik1;//Оператор присваивания
  Chiken chik3(chik2); //Копирования конструктора
  std::cout << chik3.GetAge();
}// вызов деструктора

void increase (void* data, int psize)
{
  if ( psize == sizeof(char) )
  { char* pchar; pchar=(char*)data; ++(*pchar); }
  else if (psize == sizeof(int) )
  { int* pint; pint=(int*)data; ++(*pint); }
}

int main ()
{
  char a = 'x';
  int b = 1602;
  increase (&a,sizeof(a));
  increase (&b,sizeof(b));
  cout << a << ", " << b << '\n';
  return 0;
}