Probleme creation classe

(mando@velvet) (~) $ g++ plop.cpp 
plop.cpp: In constructor ‘Rect::Rect(int*)’:
plop.cpp:8:15: error: incompatible types in assignment of ‘int*’ to ‘int [4]’
    m_rect(rect)

std::vector<int>

const

ma_methode

maMethode

std::endl

using namespace std;

#include <iostream>
#include <vector>
#include <cassert>

class Rect
{
    private:

        std::vector<int> m_rect;

    public:

        Rect(const std::vector<int> & rect):
            m_rect(rect)
        {
            assert(rect.size() == 4);
        }

        bool collide_point(int ptx, int pty) {
            for (int x= m_rect[0]; x <= m_rect[2]; x++) const {
                if (x == ptx) {
                    for (int y= m_rect[1]; y <= m_rect[3]; y++) {
                        if (y == pty) {
                            return true;
                        }
                    }
                }
            }
            return false;
        }
};

int main() {
    std::vector<int> rectangle = {0, 0, 20, 20};
    Rect sprite(rectangle);
    std::cout << sprite.collide_point(5, 2) << std::endl;
    return 0;
}

std::vector<int> rectangle(4);
rectangle[0] = 0;
rectangle[1] = 0;
rectangle[2] = 20;
rectangle[3] = 20;

try ... except

assert

-DNDEBUG

=

int tab[4] = {1,2,3,4}

tab

tab

int *

0x00123ab

int * p = tab

0x00123ab

[]

*

*(tab +i)

tab[i]

int *

p[2] = 7;

tab[2]

memcpy

#include <cstring>
#include <iostream>

int main() {
    int tab[4] = {1,2,3,4};
    int p[4];
    memcpy(p, tab, 4 * sizeof(int));
    for (int x : tab) std::cout << x << std::endl;
    for (int x : p)   std::cout << x << std::endl;
    return 0;
}

:

for(unsigned i = 0; i < 4; ++i) { ... }

std::vector<int>

template

inline

#include <ostream>

std::ostream & operator << (std::ostream & os, const Rect & r) {
  os << ... ;
  return os;
}

NULL

#include <stdexcept>

int main() {
  try {
    raise std::runtime_error("plop");
  } catch(MonException & e) {
    // ...
  } catch(...){ // Rattrape toutes les exceptions non rattrapées
    // ...
  }
  return 0;
}

class MonException {};

inline MonException mon_assert(bool b) {
#ifndef DNDEBUG
  if (!b) throw MonException();
#endif
}

#include <iostream>
#include <vector> 

class Rect
{       
    private:
        std::vector<int> m_rect;
    public:
        Rect(int a, int b, int c, int d) {
            m_rect = {a, b, c, d};
        }   

        const std::vector<int> & get_vector() const {
            return m_rect;
        }   
};

template <typename T>
std::ostream & operator << (std::ostream & os, const std::vector<T> & v) {
    os << '[';
    for (auto x : v) os << ' ' << x;
    os << " ]";
    return os;
}

std::ostream & operator << (std::ostream & os, const Rect & r) {
    os << r.get_vector();
}

int main() {
    Rect r(0, 0, 20, 20), a(10, 10, 5, 5), c(21, 80, 6, 8), b(10, 11, 12, 9);
    std::cout << a << std::endl;
    std::vector<Rect> rectangles = {r, a, b, c};
    std::cout << rectangles << std::endl;
    return 0;
}

std::vector

<<

<<

std::set<T>, std::list<T>, std::map<K, V>

stl_io.hpp

(mando@velvet) (~) $ g++ plop.cpp 
(mando@velvet) (~) $ ./a.out 
[ 10 10 5 5 ]
[ [ 0 0 20 20 ] [ 10 10 5 5 ] [ 10 11 12 9 ] [ 21 80 6 8 ] ]