I'm doing right now is creating a function that callocs (I prefer this to malloc) and returns a string, and it will work similar to printf, I'm calling the function alloCpy(),I have several values that I need in a malloced string, so I call Code: myAllocedString = alloCpy("Value 1 is %s, value 2 is %s, and value 3 is %d", str1, str2, num); To do this I'm using the Variadic Macro, the reason I'm not just using a Variadic Function such as this: Code: char* alloCpy(char *format, ...) {} is because I need to append NULL to the end for the sake of looping through arguments, and I'm understanding it thusfar, but I have a few issues, first of all, I tried defining the Macro in a header file, but when I try to call it I get the error "Undefined reference to alloCpy". Also, to loop through arguments to get string lengths I'm using va_arg(args, char*) which requires all the arguments to be of type char*. Here is my code:
myheader.h:
So, how can I do this to, first of all, make my macro function accessible from other files importing myheader.h, and second, how can I make it accept any type of argument like printf, so that my example above would work?
I'm having some problems in understanding how the code below works and why it produces the output it produces.. What I'd expect is that both functions, namely `add_1' and `add_2', would print the same output; but I've been proven wrong :/ So why does the second one get different memory addresses for the same variable?
Code should be self-explaining:
Code: template<typename... Types> void add_1(Types&&... values) { // by the way: why do i have to use `const int' instead of `int'? std::vector<std::reference_wrapper<const int>> vector{ std::forward<Types>(values)...}; std::cout << "add_1:" << std::endl; for (const auto& value:vector) { std::cout << &value.get() << std::endl;
I noticed that when using variadic functions, if I pass the va_arg() as parameter to a function, the parameters get passed in reverse. Is that expected?
For example, the following code outputs Code: 1 2 2 1
I have been experimenting with variadic templates with the aim of caching a call to a class method by storing away the object pointer, method pointer and parameters. I've actually had some reasonable success but have now hit a stumbling block. I now wish to wrap my parameters in a simple template class when I cache them. My success is as follows:
Using variadic template functions to store these pointers and paremeters;
I'm able to pass a method pointer and unwrapped parametersI'm able to pass wrapped parameters on their own.I'm NOT able to pass a method pointer and wrapped parameters I set up a little prototype project to demonstrate the issue and added comments above the function calls to indicate the compilation results. Here is the code:
Code: #include "stdafx.h" ////////////////////////////////////////////////// // Basic class with a simple method ////////////////////////////////////////////////// class MyClass { public: char Method( int i, float f ) { return 'A';
[code]....
But I'm convinced it should take three arguments, the method pointer and two wrapped parameters. Visual studio even suggested it should as shown below:
I'm looking for a way to enter an unlimited amount of types in the <> part of a template function, I found Variadic templates but I'm not sure if it can do it, all the examples I've found are similar to the C argument list and don't use the <> part of the template at all.
Is it possible to define a macro with in a macro? Any trick will do. I am trying to do quick conversion of cuda program to open mp by defining some macros at the top:
I have a variadic base class with a pure-virtual function per type:
Code: template <typename ... Types> class Base; template <typename T, typename ... Types> class Base<T,Types...>: public Base<Types...> { public: using Base<Types...>::doSomething;
[Code] ......
Now, I'd like to inherit from it using another variadic class, which provides implementations of doSomething(), but I run into trouble --- where do I indicate it derives from Base?
Code: template <typename ... Types> class Derived; template <typename T, typename ... Types> class Derived<T,Types...>: public Derived<Types...>
[code]....
I see two possible approaches:
First, virtual inheritance *might* get me what I want, but I don't know how bad a performance hit that might be.
Second, I could do some magic where the full set of types is captured in a tuple at the lowest level and continually passed up, then re-expanded in the base case to indicate Base inheritance. However, I'm not sure if that can be done in an unambigious manner; I can't have two variadic packs at once (Types... and the tuple contents), and I'm not sure if there's a way to use enable_if to check if an arbitrary template type is any kind of tuple.
I had to learn how to use variadic templates recently, and had trouble finding simple examples that just showed the basic syntax.
So I decided to write one myself. Admittedly, it's a bit on the long side, but that is mostly because it includes five specializations.
insert Code: // Variadic.C // Compile command: g++ Variadic.C -std=c++0x // I used GCC version 4.6.3 on Ubuntu.
// This file contains a basic variadic template with five specializations. // It is intended for non-software engineers who are looking for a simple // example of variadic template syntax.
I wonder if it is possible to remove the last argument in an argument pack? Below is an example on what I want to accomplish:
template<template<int...> class A,int... Ints> A<remove_last_int<Ints...>::list> func(const A<Ints...> & a0) { A<remove_last_int<Ints...>::list> a; ... //Here a set the members of a based on a0. ... return a; }
For example, I want the return a A<1,2> value from (const A<1,2,3> & a0)
that successfully allows me to enable the function foo() only if FIRST is convertible to Base*, but I also only want foo() enabled if each type in REST... meets the same condition. What is the syntax for that? If no such syntax exists, how to achieve that effect?
I'm trying to learn how to use variadic templates, and I decided a great example would be serializing a series of types into a stringstream:
Code: // Send a fully constructed message. virtual void send(ostringstream &msg) = 0; // Construct a message from the arguments and send it. // This is the usual entry point. template <typename ...Args> void send(Args ...args {
[Code] ....
This works fine, so far as I can tell. However, I decided to see if I could specialize the way certain types are serialized. I tried using a Google Protocol Buffer object as an example, and added this:
Code: // Handle a protocol buffer type while constructing a message. template <typename ...Args> void send(ostringstream &msg, const google::protobuf::MessageLite &protobuf, Args ...args) { std::string msg_str = protobuf.SerializeAsString(); msg << msg_str; send(msg,args...); }
I would expect this overload to be preferred over the generic T overload when a protobuf object (which always inherits from MessageLite) is passed into send() anywhere in the list. However, this is not happening. I am getting an error message to the effect that << doesn't know how to deal with my concrete type, pointing at the T overload.
#include "tensor.h" int main() { Tensor<2,-2> m = {{1,2},{1,3}}; Tensor<2> v = {1,5}; std::cout<<m*v<<"
[Code] ....
Why do I get an ambiguity and why is not the wanted operator*-overload (the last one in the tensor.h file) not even mentioned as one of the candidates? Is it clear what I want to do? And if so, what can I do to make the call unambiguous?
I am trying to create a small set of filepath functions that I intend to compile across linux and windows (I prefer not to use a big library). I want to have a global constant PATH_SEPARATOR that depends on the OS environment. This is what I set at the top of header file.
Code:
#include <stdio.h> const char PATH_SEPARATOR = #ifdef _WIN32 ''; #else '/'; #endif I was hoping to test this while compiling this in a linux environment using gcc, thusly:
Code:
int main (int argc, char const* argv[]) }
[code]....
where apparently, I seem not to be able to "set" a part of the code to have "_WIN32" defined. I don't know if I explained this clearly.
Code: #define FOO BAR #if FOO == BAR doX(); #else doY(); #endif
This causes doX(); to be executed. But the intent is to have doY(); be run. I'm guessing this is because BAR is undefined and therefore blank, so blank equals blank. Is there some way to compare the symbol FOO was set to instead of its value, BAR?
"If you examine the expansion of max, you will notice some pitfalls. The expressions are evaluated twice; this is bad if they involve side effects like increment operators or input and output. For instance, the below example will increment the larger twice."
#define max(A, B) ((A) > (B) ? (A) : (B))
max(i++, j++)/* WRONG */
I don't see what the problem is with the code above. i is incremented and j is incremented and then it performs a ternary operation to see which is greater. Am I missing something?
Say I have two projects A and B. A depends on B. If project A defines a macro to be 100 and project B defines the same macro to be 200. In project A, if I use this macro, what value would this macro be? Let's just forget macro is evil for the time being. Let's also forget that it is not good to define the same macro twice for the time being.
I need writing a macro that would return true/false (1/0) )value. I want to check if a certain element exists in the array. The macro will accept array, its size, and the value to be compared, and must return yes or no. Here is the code that I have written:
Code: #define EXISTS(T, a, n, val) do { char ret=0; T *a_ = (a); size_t n_ = (n); for (; n_ > 0; --n_, ++a_){ ret = (*a_ == val); } } while(0)
