|
I have two static libs that I want to convert into one DLL. The libs contain class definitions and are statically linked into other DLLs.
We want to be able to use these classes with other DLLs without having th statically link the libs into them, since these classes can change often.
Any easy way to do this?
TIA
-C
|
|
|
|
|
If you have the source it should mostly be a matter of changing the project settings, in VS2005 or later anyway. In V6 you might need to create a new DLL project and manually pull in all the same files and setting the static lib project has.
If you don't have the source then reusing individual classes is out, you'd have to write a wrapper DLL that is itself statically linked to the original lib which kind of defeats the object as you'd get the whole lib in the DLL not just the classes you want.
Assuming you have the source, have you considered just including the source files directly in more than one project? We have a 'Shared' folder in parallel with the folders for our projects which contains source for common classes and headers that are used everywhere. Works fine as long a you only include things that you alwasy want to be the same everywhere they're used.
Nothing is exactly what it seems but everything with seems can be unpicked.
|
|
|
|
|
Its VS60.
I have all the source from the libs. They're class definitions that other classes are derived from. We regularly create new DLLs that statically link these libs. The problem is that if they change, we always have to recompile and version the DLL. We want to move all the class definitions into a DLL that our new DLLs can dynamically link.
So if the new DLL changes, the old ones can always dynamically link to the new changes.
Questions:
- How to convert from static to dynamic libraries?
- How to export the classes to be used by other DLLs? DO we only include the .lib file from the dynamic library into the new project?
- Any other issues?
I'm lost here.
|
|
|
|
|
I had to create a pointer to a structure with an unknown size. I used calloc alread, it was easy:
calloc(1,nSize);
Now I wanted to convert it to new. I did this:
pStruct = (Struct*)new char[nSize];
With the above approach, will delete realize real amount of memory to free?
or even better:
Is it possible to define a size in the new operator?
// "In the end it's a little boy expressing himself." Yanni
while (I_am_alive)
{
cout<<"I love programming.";
}
modified on Thursday, February 28, 2008 10:44 AM
|
|
|
|
|
Hamed Mosavi wrote: With the above approach, will delete realize real amount of memory to free?
Yes, provided you call
delete [] pStruct;
Hamed Mosavi wrote: Is it possible to define a size in the new operator?
If the Lord God Almighty had consulted me before embarking upon the Creation, I would have recommended something simpler.
-- Alfonso the Wise, 13th Century King of Castile.
This is going on my arrogant assumptions. You may have a superb reason why I'm completely wrong.
-- Iain Clarke
|
|
|
|
|
Thank you very much CPallini
CPallini wrote: Is it possible to define a size in the new operator?
I mean: Is it possible to ask new to allocate a custom amount of memory, like what we do in calloc, request nSize of memmory [modified] instead of casting [/modified].
Thank you in advanced.
// "In the end it's a little boy expressing himself." Yanni
while (I_am_alive)
{
cout<<"I love programming.";
}
|
|
|
|
|
BYTE *p = new BYTE[1000];
...
delete [] p;
?
|
|
|
|
|
I understand that. More details:
For instance I know int is 4 bytes. if I write:
int *pInt = new int;
I know pInt points to a memory area with 4 bytes length. If I force c++ to create 8 bytes and then cast the pointer and put it in another variable:
int *pBigInt = (int*)new BYTE[8];
and later on, I call delete:
delete[] pBigInt;
Will compiler uses size of the type of the pBigInt to delete pBigInt, or keeps track of all allocated size and deletes that. If this is the case, it might be possible to write something like this:
myStruct* pStruct = new myStruct(nSize); where nSize is not equal to sizeof(myStruct);.
I hope I'm writing a human readable English 
// "In the end it's a little boy expressing himself." Yanni
while (I_am_alive)
{
cout<<"I love programming.";
}
|
|
|
|
|
Hamed Mosavi wrote: Will compiler uses size of the type of the pBigInt to delete pBigInt, or keeps track of all allocated size and deletes that. If this is the case, it might be possible to write something like this:
myStruct* pStruct = new myStruct(nSize);
where nSize is not equal to sizeof(myStruct);.
you cannot do that, but
myStruct* pStruct = (myStruct*) new BYTE[nSize];
and later
delete [] pStruct;
works fine.
If the Lord God Almighty had consulted me before embarking upon the Creation, I would have recommended something simpler.
-- Alfonso the Wise, 13th Century King of Castile.
This is going on my arrogant assumptions. You may have a superb reason why I'm completely wrong.
-- Iain Clarke
|
|
|
|
|
Thanks guys. Working with more confidence now.
// "In the end it's a little boy expressing himself." Yanni
while (I_am_alive)
{
cout<<"I love programming.";
}
|
|
|
|
|
Hamed Mosavi wrote: If this is the case, it might be possible to write something like this:
myStruct* pStruct = new myStruct(nSize);
where nSize is not equal to sizeof(myStruct);.
it is possible to write like this, in this case compiler creates one object of "myStruct" and calls the overloaded constructor something like "myStruct(int)" or "myStruct(size_t)" whichever you defined.
|
|
|
|
|
Rajkumar R wrote: alls the overloaded constructor
No. That was just an example to see if there is any similar syntax that eliminates need for casting.
// "In the end it's a little boy expressing himself." Yanni
while (I_am_alive)
{
cout<<"I love programming.";
}
|
|
|
|
|
ok. myStruct(nSize), if nSize is not sizeof(myStruct), and if it is not multiples of sizeof(myStruct) how you are thinking to use that object as myStruct. i think you want the nSize to be multiples of sizeof(myStruct), is it?
|
|
|
|
|
Rajkumar R wrote: how you are thinking to use that object as myStruct
Indeed! TAPI is the answer. It was first strange to me as well. It's like the structure holds something like strings and doesn't know the exact size of the string. When I call it once, it sometimes returns an "insufficient memory" error, then I have to get needed size and re allocate enough memory. I have to give the API a pointer to that structure which is actually a pointer to first block of the predefined size of memory.
My question was that, is it possible to get rid of casting and the type specified in new and explicitly define needed size of memory to allocate(and based on the type myStruct) the operator cast the result automatically?
Further than that, it was strange to me how delete works.
// "In the end it's a little boy expressing himself." Yanni
while (I_am_alive)
{
cout<<"I love programming.";
}
|
|
|
|
|
Hamed Mosavi wrote: My question was that, is it possible to get rid of casting and the type specified in new and explicitly define needed size of memory to allocate(and based on the type myStruct) the operator cast the result automatically?
why not, C++ is powerful man,
#include<new>
#include<iostream>
using namespace std;
struct myStruct
{
myStruct( )
{
cout << "Construction myStruct." << this << endl;
};
~myStruct( )
{
cout << "Destructing myStruct." << this << endl;
};
void *__CRTDECL operator new(size_t size, size_t realSize)
{
return malloc(realSize);
}
void __CRTDECL operator delete(void * ptr, size_t)
{
free (ptr);
}
};
int main( )
{
const int nSize = sizeof(myStruct) + 100;
myStruct* pStruct1 = new (nSize) myStruct;
delete pStruct1 ;
char preAllocatedBuffer[nSize];
myStruct* pStruct2 = ::new( &preAllocatedBuffer[0] ) myStruct;
<code>pStruct2->~myStruct();</code>
}
some of the techniques,
you can pass the custom size to the overloaded new operator see the 1) in the code.
And there is also a placement new operator that is defined if you #include <new>, in this you can pass pre allocated buffer and get the class created see 2) in the code, in the placement case donot use delete as the buffer need not to be freed by the class.
and also if size is multiple of myStruct,
straitforward
myStruct* pStruct2 = ::new myStruct[2];
modified on Friday, February 29, 2008 6:58 AM
|
|
|
|
|
Thanks.
This:
Rajkumar R wrote: the placement new
...
::new( &preAllocatedBuffer[0] ) myStruct;
was really interesting. Thank you. I appreciate it.
The first solution (Overloading new operator is nice either) but in this very special situation, I don't have myStruct (it's in fact LINEINITIALIZEEXPARAMS.)
By the way, great tips and techniques. Thanks for sharing.
Rajkumar R wrote: C++ is powerful
Absolutely I love it(my signature.) I wish it had built in support for multi threading.
// "In the end it's a little boy expressing himself." Yanni
while (I_am_alive)
{
cout<<"I love programming.";
}
|
|
|
|
|
Hamed Mosavi wrote: I wish it had built in support for multi threading.
Multiple threads, Process Spawning, etc, OS concepts not language specific, OS can expose the API so that languages can pick it up. You have to be happy that C, C++ can directly access those API in our program, while some language has layers in between.
|
|
|
|
|
Rajkumar R wrote: OS concepts not language specific
 Your right. What a bad mistake. It was a typo 
// "In the end it's a little boy expressing himself." Yanni
while (I_am_alive)
{
cout<<"I love programming.";
}
|
|
|
|
|
Thanks for the BYTE recall. Actually char and unsigned char work differently sometimes.
// "In the end it's a little boy expressing himself." Yanni
while (I_am_alive)
{
cout<<"I love programming.";
}
|
|
|
|
|
Hello,
so far I create dynamic arrays like this
int elements=3;<br />
testclass* parray= new testclass [elements];
Id like to use the same approach on a the testclass with a private constructor without changing the source code of the testclass.
class testclass <br />
{<br />
public: static testclass* New();<br />
<br />
private: testclass(){};<br />
~testclass(){};<br />
};
-----------------------------------
testclass* testclass::New()
{
return new testclass;
};
I would be thankful for any advices..
best regards
tobse
|
|
|
|
|
So what's your question/problem?
"Normal is getting dressed in clothes that you buy for work and driving through traffic in a car that you are still paying for, in order to get to the job you need to pay for the clothes and the car and the house you leave vacant all day so you can afford to live in it." - Ellen Goodman
"To have a respect for ourselves guides our morals; to have deference for others governs our manners." - Laurence Sterne
|
|
|
|
|
The only solution I see is to work with an array of pointers to testclass objects instead of an array of testclass objects. Then you'll need to initialize each pointer by calling testclass::New. This is because an array needs to construct each of its elements, thus calling the constructor.
int elements=3;
testclass** parray= new testclass* [elements];
for (int i=0;i<elements; i++
{
parray[i] = testclass::New();
}
But it's a little bit ugly if you want my opinion 
|
|
|
|
|
Hi,
great, it works ! Thank you.
Accessing the objects with parray[i]-> and deleting with delete [] parray works fine.
tobse
|
|
|
|
|
tobse wrote: and deleting with delete [] parray works fine
Yes, but it leaks memory. You have first to delete each element alone and then delete the array.
Remember that for each call to new, there should be a call to delete associated and for each call to new[], there should be a call to delete[] associated.
|
|
|
|
|
What is your doubt? Cannot you pass the array size to your static method New()?
If the Lord God Almighty had consulted me before embarking upon the Creation, I would have recommended something simpler.
-- Alfonso the Wise, 13th Century King of Castile.
This is going on my arrogant assumptions. You may have a superb reason why I'm completely wrong.
-- Iain Clarke
|
|
|
|
General 
News 
Suggestion 
Question 
Bug 
Answer 
Joke 
Praise 
Rant 
Admin 
Submit an article or tip
