Increasing usage for C++ new operators based on data model indexes?



  • Two member functions “QAbstractItemModel::createIndex” are described in a terse way. I have got the impression that they can belong to the function category “memory allocation”.

    Would you like to peform corresponding storage allocations then by customised C++ new operators which will be provided by known class libraries (including Qt)?



  • @elfring said in Increasing usage for C++ new operators based on data model indexes?:

    I have got the impression that they can belong to the function category “memory allocation”.

    Nope, wrong impression. As you can see in the sources, createIndex does nothing but call the private 4 args constructor for QModelIndex and return it by value.
    It's just a safety measure to make sure you don't forget to set the model member of QModelIndex and prevents external users of the model to create an index manually that could potentially result in undefined behaviour.

    May I suggest chapter 3 of this book. Page 113 onward in particular



  • Nope, wrong impression.

    • Is an index for a data model similar to a pointer from the heap?
    • Should desired information be available also without a reference to an other book?


  • @elfring said in Increasing usage for C++ new operators based on data model indexes?:

    Is an index for a data model similar to a pointer from the heap?

    Not even close. It's more similar to a QPoint.
    It's a container for a coordinate in a 3D space (row, column, hierarchical level) of a specific model

    Should desired information be available also without a reference to an other book?

    It is but following your posts it's clear you are quite confused so I thought I'd give you a reference that you can access for free that explain step by step how to custom models work



  • Not even close.

    An item can be added to a model. Its position is identified by a corresponding model index, isn't it?

    It's a container for a coordinate in a 3D space (row, column, hierarchical level) of a specific model

    • A pointer from the heap can be used together with a simple index for a buffer (an array).
    • Do Qt data models manage just vectors of pointers internally?
    • Can the mentioned coordinate be connected then with a pointer for a specific object within the data model in a similar way?

    I'd give you a reference that you can access for free that explain step by step how to custom models work

    Such descriptions can be generally helpful.



  • @elfring said in Increasing usage for C++ new operators based on data model indexes?:

    An item can be added to a model. Its position is identified by a corresponding model index, isn't it?

    yes but the item exists even if no index points to it. just like an element in space exists even if nothing points to it

    A pointer from the heap can be used together with a simple index for a buffer (an array).

    I don't see ho this is related

    Do Qt data models manage just vectors of pointers internally?

    No, you are free to design the internals however you want

    Can the mentioned coordinate be connected then with a pointer for a specific object within the data model in a similar way?

    the coordinate "is" the pointer. the point being that given a QModelIndex the model can map 1:1 an item in its internal structure.

    Such descriptions can be generally helpful.

    The pdf book I linked should be a great starting point



  • yes but the item exists even if no index points to it.

    Do software developers tend to create objects so they can work with them by a specific “address”?

    I don't see ho this is related

    The involved pointer manages information about the desired data type, doesn't it?

    the coordinate "is" the pointer.

    Do we come closer to a similar interpretation of the software situation?

    the point being that given a QModelIndex the model can map 1:1 an item in its internal structure.

    Can this mapping become accessible also by a pointer which was provided by a C++ new operator?

    The pdf book I linked should be a great starting point

    Would you like to clarify the distribution status of the linked file?



  • @elfring said in Increasing usage for C++ new operators based on data model indexes?:

    Do software developers tend to create objects so they can work with them by a specific “address”?

    Yes, but the address is held by the internal structure, not by way of a QModelIndex. Such internal structure is free to be whatever even a file, an SQL query, an item on the stack or one on the heap.

    The involved pointer manages information about the desired data type, doesn't it?

    The QModelIndex doesn't own the data in any shape or form but other than that yes. In this case the QModelIndex will hold an int index (as row or column) so that it can be mapped 1:1 with the internal structure via an offset on the owning pointer that lives inside the model

    Do we come closer to a similar interpretation of the software situation?

    No because you think this pointers owns the data

    Can this mapping become accessible also by a pointer which was provided by a C++ new operator?

    Would you like to clarify the distribution status of the linked file?

    I did not understand this questions, sorry



  • Yes, but the address is held by the internal structure, …

    Does this structure manage pointer data types for the model so that implicit data sharing will work for Qt classes?

    No because you think this pointers owns the data

    Not really for “QModelIndex” at the moment. - I can distinguish the properties of this class from the companion class “QPersistentModelIndex”.
    Is another distinction needed between owning pointers and weak pointers?

    • Would anybody like to construct a C++ new operator for data models?
    • Do you know any existing implementations for model storage allocators?

    I did not understand this questions, sorry

    How do you think about to recheck the distribution rights for book files?



  • @elfring said in Increasing usage for C++ new operators based on data model indexes?:

    Does this structure manage pointer data types for the model so that implicit data sharing will work for Qt classes?

    There is no imposed structure. It can be whatever you want.

    Not really for “QModelIndex” at the moment. - I can distinguish the properties of this class from the companion class “QPersistentModelIndex”.

    QPersistentModelIndex doesn't own the data either, the only difference between the 2 is their response to changes in the position of the item they point. Returning to my QPoint analogy QModelIndex can be seen as an absolute point in space, if the item at those coordinates move it will not follow, it will remain in that place, QPersistentModelIndex is a relative point and will move with the item it is pointing

    Would anybody like to construct a C++ new operator for data models?

    Why would you want to?

    Do you know any existing implementations for model storage allocators?

    what is a "model storage allocator"?

    How do you think about to recheck the distribution rights for book files?

    I actually just googled the book title.



  • Why would you want to?

    The concrete target data types can vary while model indexes are resolved to QVariant objects as the default data.
    A C++ new operator can provide a known pointer data type, can't it?

    what is a "model storage allocator"?

    Some data structures in the C++ standard template library get such a parameter passed.



  • what is a "model storage allocator"?

    Another design view:
    It is just a function which should return a valid pointer for a storage location.
    Under which circumstances would C++ programmers call it like “new”?


  • Qt Champions 2017

    @elfring said in Increasing usage for C++ new operators based on data model indexes?:

    A C++ new operator can provide a known pointer data type, can't it?

    If you mean that pointer to be void *, then yes, formally. However void * (a.k.a. the "opaque pointer") is even worse, as you don't get any type safety with it. QVariant does the same thing, but more cleanly. It keeps taps on what data was put into it and even provides conversions through the meta type system.

    Some data structures in the C++ standard template library get such a parameter passed.

    Are you willing to try and mix templates and QObjects? If so, call me in, I want to watch the fireworks.

    It is just a function which should return a valid pointer for a storage location.

    The model does not do storage! And that's what @VRonin has mentioned couple of times already. The model is your "map" to the data - what is located where, no more - no less.

    Under which circumstances would C++ programmers call it like “new”?

    Look, I get that you like new, but the heap is approximately 10 (and sometimes more) times slower than the stack. There's no really conceivable reason for anyone to create the model index in the heap ... it just does not make any sense.

    Say you're working with points in 3d space - you have 3 coordinates that define the point (i.e. your structure/class has 3 members representing the coordinates), would you go around creating those objects representing points in the heap?



  • If you mean that pointer to be void *, …

    No! - Must a C++ new operator provide a non-void pointer data type?

    The model does not do storage!

    It provides the generic programming interface for the desired data sources.
    Derived classes will contain member variables which will manage storage in expected ways, won't they?

    Look, I get that you like new, …

    C++ programmers are using this operator for various resource allocations.
    I propose to increase the usage of the construct “placement new” also together with customised data models.



  • @kshegunov said in Increasing usage for C++ new operators based on data model indexes?:

    Look, I get that you like new, but the heap is approximately 10 (and sometimes more) times slower than the stack.

    Just a question out of curiosity, because I remeber by instructor also telling me c++ heap allocation is slower than stack and slower than heap allocation in other languages.

    Is there a different method in c++ to allocation memory instead of the standard new?


  • Qt Champions 2017

    @elfring said in Increasing usage for C++ new operators based on data model indexes?:

    Must a C++ new operator provide a non-void pointer data type?

    It can provide whatever type you want it to, however I still don't see how you're going to have a generic type (i.e. QAbstractItemModel) that deals with concrete types it does know nothing about ...

    It provides the generic programming interface for the desired data sources.

    Indeed.

    Derived classes will contain member variables which will manage storage in expected ways, won't they?

    They may or may not. It's up to the user code to decide where and how the storage will be done. There may be no storage at all and the data to be fetched on the fly from someplace.

    C++ programmers are using this operator for various resource allocations.

    Many C++ programmers overuse this operator, especially those with limited experience.

    I propose to increase the usage of the construct “placement new” also together with customised data models.

    https://www.youtube.com/watch?v=iUQCFI02zZA

    @J.Hilk said in Increasing usage for C++ new operators based on data model indexes?:

    Just a question out of curiosity, because I remeber by instructor also telling me c++ heap allocation is slower than stack

    It is. It's a call to the heap manager in the OS. The heap manager has to find a free place for your object before it can return you an address ...
    A stack allocation is nothing on the other hand - you (rather the compiler) move the stack pointer to the appropriate offset from the stack base pointer and voila - you have memory. That also is the reason that you must know the size of the allocated object at compile time.

    and slower than heap allocation in other languages.

    Nope!

    Is there a different method in c++ to allocation memory instead of the standard new?

    You have *alloc from the C runtime, the placement new if you're crazy enough to build your own heap manager (or for some very specific similar purposes), and of course you have my buddy - the stack.



  • @kshegunov thanks for the info.

    IIRC boost also has special allocation methods for faster instantiation of objects. But I'm not sure, never used that libary much.



  • @elfring said in Increasing usage for C++ new operators based on data model indexes?:

    The concrete target data types can vary while model indexes are resolved to QVariant objects as the default data.
    A C++ new operator can provide a known pointer data type, can't it?

    Isn't dynamic_cast what you want?

    @kshegunov said in Increasing usage for C++ new operators based on data model indexes?:

    You have *alloc from the C runtime

    Note for passers-by: If you use those to allocate complex types the constructor may/will not be called



  • …, however I still don't see how you're going to have a generic type (i.e. QAbstractItemModel) that deals with concrete types it does know nothing about ...

    Various data structures are accessible over pointers (or customised indexes?).

    Does the class “QVariant” provide also a programming interface for pointer data types?

    …, the placement new if you're crazy enough to build your own heap manager (or for some very specific similar purposes), …

    I am trying to increase the software development attention for the latter.



  • Isn't dynamic_cast what you want?

    Yes.

    I prefer to avoid null pointers which can eventually be returned by such a cast operation.



  • @elfring said in Increasing usage for C++ new operators based on data model indexes?:

    Does the class “QVariant” provide also a programming interface for pointer data types?

    Yes using QVariant::fromValue or via the constructor if the type is a QObject subclass.
    hic sunt leones though as you need to make clear in your logic who owns the items pointed. In general a QVariant containing a owning pointer is a ticking time bomb toward memory leak and/or double deletion.

    I prefer to avoid null pointers which can eventually be returned by such a cast operation.

    If you are certain of the downcast type you can even use static_cast and forget about null pointers



  • In general a QVariant containing a owning pointer is a ticking time bomb toward memory leak and/or double deletion.

    If you are certain of the downcast type you can even use static_cast and forget about null pointers

    Can it be more convenient to let a C++ new operator (which can work also with extra allocation parameters directly) perform the desired data type conversion?



  • @elfring said in Increasing usage for C++ new operators based on data model indexes?:

    The safe handling of object lifetimes is a general software development challenge.
    But this class is the only way to get data from a model so far, isn't it?

    Yes, what I'm saying is that if you want to store a pointer in a QVariant you probably want a non-owning pointer. Keep the owning pointer somewhere else.

    Can it be more convenient to let a C++ new operator (which can work also with extra allocation parameters directly) perform the desired data type conversion?

    No, new allocates memory. static_cast just tell the compiler to treat a piece of memory as it was a different type.

    But this class is the only way to get data from a model so far, isn't it?

    And here we come back to the fact that having your objects implicitly shared stored in a QVariant directly is much more practical and has a negligible impact on performance



  • new allocates memory.

    Only if you do not use the construct “placement new”.

    And here we come back to the fact that having your objects implicitly shared stored in a QVariant directly is much more practical

    I guess that the run time consequences are more interesting then for the distinction if only pointers are transferred or complete “value objects” are copied.

    and has a negligible impact on performance

    There are software applications where more data transfers might not have a directly noticeable effect. But I guess that some C++ programmers have got a strong focus on software efficiency.


  • Qt Champions 2017

    This is getting pretty ridiculous ...

    @elfring said in Increasing usage for C++ new operators based on data model indexes?:

    Only if you do not use the construct “placement new”.

    Yeah, which I have a creeping suspicion you haven't. The so called placement new is nothing more than going around calling constructors on a preallocated memory block. So where is this preallocated memory going to come from? It's going to materialize from the ether?

    If you're intent on pushing this make-you-own-heap-for-models, I advise to create a proof-of-concept first, then we can have something to base a discussion on, otherwise - thanks but no thanks, I'm out of this conversation.



  • The so called placement new is nothing more than going around calling constructors on a preallocated memory block.

    I agree on this aspect.

    But can you pass a “model index” as another allocation parameter (for existing data) to this C++ operator?



  • @elfring said in Increasing usage for C++ new operators based on data model indexes?:

    Only if you do not use the construct “placement new”.

    Is your plan to do exactly what dynamic_cast does but using a new operator? I mean it's possible but I don't see why you'd want to do it. How would you implement it?

    guess that the run time consequences are more interesting then for the distinction if only pointers are transferred or complete “value objects” are copied.
    There are software applications where more data transfers might not have a directly noticeable effect. But I guess that some C++ programmers have got a strong focus on software efficiency.

    @VRonin said in Increasing usage for C++ new operators based on data model indexes?:

    having your objects implicitly shared

    With implicitly shared objects, the distinction from a pointer to a complete value object when copying is just an operator++ on an int. 1 atomic instruction. 100000 times more efficient than a dynamic_cast.
    If you want to go into memory difference it's 32bits more. If 32 bits break your design then it's the design itself that comes into question



  • Is your plan to do exactly what dynamic_cast does but using a new operator?

    Maybe.

    But these C++ operations provide different functionality, don't they?

    With implicitly shared objects, the distinction from a pointer to a complete value object when copying is just an operator++ on an int.

    Will it become nicer to avoid (or reduce) even the influence of object reference counting?



  • @elfring said in Increasing usage for C++ new operators based on data model indexes?:

    Will it become nicer to avoid (or reduce) even the influence of object reference counting?

    C++ is moving in the opposite direction actually. If you try to suggest replacing std::shared_ptr (which is a pointer + a reference counter) with raw pointers on Stack Overflow you'd better bring a helmet and kevlar vest because you are going to get shot.
    The ISO C++ style guide goes one step further and even discourages the use of owning raw pointer and suggest ownership encapsulation (an implicitly shared object behaves as a smart pointer). If you don't like it, good luck convincing Herb Sutter and Bjarne Stroustrup himself.

    But these C++ operations provide different functionality, don't they?

    Yes but so far you did not highlight any need for custom allocation, your problems all seem to come from casting.



  • but so far you did not highlight any need for custom allocation,

    I suggest to reconsider the software situation once more.

    A pair of row and column values (data model index, address or coordinate) can be passed as a parameter to a C++ new operator.
    You can choose then if you need to work with fresh objects (using dynamic memory allocation) or would like to reuse existing data.

    Is the usage of the construct “placement new” a kind of customised operation?

    your problems all seem to come from casting.

    I hope that specific software development challenges can be adjusted when the new operator call takes care of casting to the desired target (pointer) data type already.



  • @elfring said in Increasing usage for C++ new operators based on data model indexes?:

    A pair of row and column values (data model index, address or coordinate) can be passed as a parameter to a C++ new operator.
    You can choose then if you need to work with fresh objects (using dynamic memory allocation) or would like to reuse existing data.
    Is the usage of the construct “placement new” a kind of customised operation?

    Once again, the model implementation might or might not allocate data. This should not be a problem of the API user.

    Could you please provide a concrete example of what you are suggesting?
    Otherwise we are just discussing of theory and nobody is gaining any value out of it.
    I will not continue the discussion until you provide at least a code snippet



  • Could you please provide a concrete example of what you are suggesting?

    Does the software situation become really more challenging for passing a few extra parameters to a (member) function when it is “accidentally” (or intentionally) called “new”?




  • Moderators

    The first link clearly states:

    ADVICE: Don’t use this “placement new” syntax unless you have to. Use it only when you really care that an object is placed at a particular location in memory. For example, when your hardware has a memory-mapped I/O timer device, and you want to place a Clock object at that memory location.

    In case of model indexes, there seems to be no need to use placement new.



  • In case of model indexes, there seems to be no need to use placement new.


  • Moderators

    @elfring said in Increasing usage for C++ new operators based on data model indexes?:

    In case of model indexes, there seems to be no need to use placement new.

    No I don't.

    I don't understand the question. Accessing data of a QVariant is possible and trivial, if necessary.



  • Accessing data of a QVariant is possible and trivial, if necessary.

    Can the data access become more convenient (and safe) for customised data types?



  • @elfring said in Increasing usage for C++ new operators based on data model indexes?:

    Can the data access become more convenient (and safe) for customised data types?

    No.
    get->change->set is mildly less convenient but infinitely safer.

    Can you think of an example code, and paste it below, where it would?



  • Can you think of an example code, and paste it below, where it would?

    I suggest to take another look at a specific implementation detail: How many function calls do you need finally to get access to a member variable within a customised data model so far?



  • @elfring said in Increasing usage for C++ new operators based on data model indexes?:

    How many function calls do you need finally to get access to a member variable within a customised data model so far?

    2 chained. QModelIndex::data and QVariant::value<T>. e.g.: index.data().value<QString>();. Don't think you can do better.
    Can you show us how would your new implementation look? Call this a test. You haven't wrote a single line of code in all your posts. I want to check that at least you have a rough idea of what you are talking about



Looks like your connection to Qt Forum was lost, please wait while we try to reconnect.